Class v1beta.AlloyDBAdminClient (1.6.0)

Package

Constructors

(constructor)(opts, gaxInstance)

constructor(opts?: ClientOptions, gaxInstance?: typeof gax | typeof gax.fallback);

Properties

alloyDBAdminStub

alloyDBAdminStub?: Promise<{
        [name: string]: Function;
    }>;

apiEndpoint

get apiEndpoint(): string;

apiEndpoint

static get apiEndpoint(): string;

auth

auth: gax.GoogleAuth;

descriptors

descriptors: Descriptors;

iamClient

iamClient: IamClient;

innerApiCalls

innerApiCalls: {
        [name: string]: Function;
    };

locationsClient

locationsClient: LocationsClient;

operationsClient

operationsClient: gax.OperationsClient;

pathTemplates

pathTemplates: {
        [name: string]: gax.PathTemplate;
    };

port

static get port(): number;

scopes

static get scopes(): string[];

servicePath

static get servicePath(): string;

universeDomain

get universeDomain(): string;

warn

warn: (code: string, message: string, warnType?: string) => void;

Methods

backupPath(project, location, backup)

backupPath(project: string, location: string, backup: string): string;

batchCreateInstances(request, options)

batchCreateInstances(request?: protos.google.cloud.alloydb.v1beta.IBatchCreateInstancesRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.alloydb.v1beta.IBatchCreateInstancesResponse, protos.google.cloud.alloydb.v1beta.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the parent resource.
   */
  // const parent = 'abc123'
  /**
   *  Required. Resources being created.
   */
  // const requests = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callBatchCreateInstances() {
    // Construct request
    const request = {
      parent,
      requests,
    };

    // Run request
    const [operation] = await alloydbClient.batchCreateInstances(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callBatchCreateInstances();

batchCreateInstances(request, options, callback)

batchCreateInstances(request: protos.google.cloud.alloydb.v1beta.IBatchCreateInstancesRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.IBatchCreateInstancesResponse, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

batchCreateInstances(request, callback)

batchCreateInstances(request: protos.google.cloud.alloydb.v1beta.IBatchCreateInstancesRequest, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.IBatchCreateInstancesResponse, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

cancelOperation(request, options, callback)

cancelOperation(request: protos.google.longrunning.CancelOperationRequest, options?: gax.CallOptions | Callback<protos.google.protobuf.Empty, protos.google.longrunning.CancelOperationRequest, {} | undefined | null>, callback?: Callback<protos.google.longrunning.CancelOperationRequest, protos.google.protobuf.Empty, {} | undefined | null>): Promise<protos.google.protobuf.Empty>;

const client = longrunning.operationsClient();
await client.cancelOperation({name: ''});

checkBatchCreateInstancesProgress(name)

checkBatchCreateInstancesProgress(name: string): Promise<LROperation<protos.google.cloud.alloydb.v1beta.BatchCreateInstancesResponse, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the parent resource.
   */
  // const parent = 'abc123'
  /**
   *  Required. Resources being created.
   */
  // const requests = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callBatchCreateInstances() {
    // Construct request
    const request = {
      parent,
      requests,
    };

    // Run request
    const [operation] = await alloydbClient.batchCreateInstances(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callBatchCreateInstances();

checkCreateBackupProgress(name)

checkCreateBackupProgress(name: string): Promise<LROperation<protos.google.cloud.alloydb.v1beta.Backup, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Value for parent.
   */
  // const parent = 'abc123'
  /**
   *  Required. ID of the requesting object.
   */
  // const backupId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const backup = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, the backend validates the request, but doesn't actually
   *  execute it.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callCreateBackup() {
    // Construct request
    const request = {
      parent,
      backupId,
      backup,
    };

    // Run request
    const [operation] = await alloydbClient.createBackup(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateBackup();

checkCreateClusterProgress(name)

checkCreateClusterProgress(name: string): Promise<LROperation<protos.google.cloud.alloydb.v1beta.Cluster, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The location of the new cluster. For the required format, see the
   *  comment on the Cluster.name field.
   */
  // const parent = 'abc123'
  /**
   *  Required. ID of the requesting object.
   */
  // const clusterId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const cluster = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the create
   *  request.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callCreateCluster() {
    // Construct request
    const request = {
      parent,
      clusterId,
      cluster,
    };

    // Run request
    const [operation] = await alloydbClient.createCluster(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateCluster();

checkCreateInstanceProgress(name)

checkCreateInstanceProgress(name: string): Promise<LROperation<protos.google.cloud.alloydb.v1beta.Instance, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the parent resource. For the required format, see the
   *  comment on the Instance.name field.
   */
  // const parent = 'abc123'
  /**
   *  Required. ID of the requesting object.
   */
  // const instanceId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const instance = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the create
   *  request.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callCreateInstance() {
    // Construct request
    const request = {
      parent,
      instanceId,
      instance,
    };

    // Run request
    const [operation] = await alloydbClient.createInstance(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateInstance();

checkCreateSecondaryClusterProgress(name)

checkCreateSecondaryClusterProgress(name: string): Promise<LROperation<protos.google.cloud.alloydb.v1beta.Cluster, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The location of the new cluster. For the required
   *  format, see the comment on the Cluster.name field.
   */
  // const parent = 'abc123'
  /**
   *  Required. ID of the requesting object (the secondary cluster).
   */
  // const clusterId = 'abc123'
  /**
   *  Required. Configuration of the requesting object (the secondary cluster).
   */
  // const cluster = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the create
   *  request.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callCreateSecondaryCluster() {
    // Construct request
    const request = {
      parent,
      clusterId,
      cluster,
    };

    // Run request
    const [operation] = await alloydbClient.createSecondaryCluster(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateSecondaryCluster();

checkCreateSecondaryInstanceProgress(name)

checkCreateSecondaryInstanceProgress(name: string): Promise<LROperation<protos.google.cloud.alloydb.v1beta.Instance, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the parent resource. For the required format, see the
   *  comment on the Instance.name field.
   */
  // const parent = 'abc123'
  /**
   *  Required. ID of the requesting object.
   */
  // const instanceId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const instance = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the create
   *  request.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callCreateSecondaryInstance() {
    // Construct request
    const request = {
      parent,
      instanceId,
      instance,
    };

    // Run request
    const [operation] = await alloydbClient.createSecondaryInstance(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateSecondaryInstance();

checkDeleteBackupProgress(name)

checkDeleteBackupProgress(name: string): Promise<LROperation<protos.google.protobuf.Empty, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource. For the required format, see the comment on
   *  the Backup.name field.
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, the backend validates the request, but doesn't actually
   *  execute it.
   */
  // const validateOnly = true
  /**
   *  Optional. The current etag of the Backup.
   *  If an etag is provided and does not match the current etag of the Backup,
   *  deletion will be blocked and an ABORTED error will be returned.
   */
  // const etag = 'abc123'

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callDeleteBackup() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await alloydbClient.deleteBackup(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callDeleteBackup();

checkDeleteClusterProgress(name)

checkDeleteClusterProgress(name: string): Promise<LROperation<protos.google.protobuf.Empty, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the Cluster.name field.
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. The current etag of the Cluster.
   *  If an etag is provided and does not match the current etag of the Cluster,
   *  deletion will be blocked and an ABORTED error will be returned.
   */
  // const etag = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the delete.
   */
  // const validateOnly = true
  /**
   *  Optional. Whether to cascade delete child instances for given cluster.
   */
  // const force = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callDeleteCluster() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await alloydbClient.deleteCluster(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callDeleteCluster();

checkDeleteInstanceProgress(name)

checkDeleteInstanceProgress(name: string): Promise<LROperation<protos.google.protobuf.Empty, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the Instance.name field.
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. The current etag of the Instance.
   *  If an etag is provided and does not match the current etag of the Instance,
   *  deletion will be blocked and an ABORTED error will be returned.
   */
  // const etag = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the delete.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callDeleteInstance() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await alloydbClient.deleteInstance(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callDeleteInstance();

checkFailoverInstanceProgress(name)

checkFailoverInstanceProgress(name: string): Promise<LROperation<protos.google.cloud.alloydb.v1beta.Instance, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the Instance.name field.
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the failover.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callFailoverInstance() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await alloydbClient.failoverInstance(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callFailoverInstance();

checkInjectFaultProgress(name)

checkInjectFaultProgress(name: string): Promise<LROperation<protos.google.cloud.alloydb.v1beta.Instance, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The type of fault to be injected in an instance.
   */
  // const faultType = {}
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the Instance.name field.
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the fault
   *  injection.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callInjectFault() {
    // Construct request
    const request = {
      faultType,
      name,
    };

    // Run request
    const [operation] = await alloydbClient.injectFault(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callInjectFault();

checkPromoteClusterProgress(name)

checkPromoteClusterProgress(name: string): Promise<LROperation<protos.google.cloud.alloydb.v1beta.Cluster, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the Cluster.name field
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. The current etag of the Cluster.
   *  If an etag is provided and does not match the current etag of the Cluster,
   *  deletion will be blocked and an ABORTED error will be returned.
   */
  // const etag = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the delete.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callPromoteCluster() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await alloydbClient.promoteCluster(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callPromoteCluster();

checkRestartInstanceProgress(name)

checkRestartInstanceProgress(name: string): Promise<LROperation<protos.google.cloud.alloydb.v1beta.Instance, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the Instance.name field.
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the restart.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callRestartInstance() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await alloydbClient.restartInstance(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callRestartInstance();

checkRestoreClusterProgress(name)

checkRestoreClusterProgress(name: string): Promise<LROperation<protos.google.cloud.alloydb.v1beta.Cluster, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Backup source.
   */
  // const backupSource = {}
  /**
   *  ContinuousBackup source. Continuous backup needs to be enabled in the
   *  source cluster for this operation to succeed.
   */
  // const continuousBackupSource = {}
  /**
   *  Required. The name of the parent resource. For the required format, see the
   *  comment on the Cluster.name field.
   */
  // const parent = 'abc123'
  /**
   *  Required. ID of the requesting object.
   */
  // const clusterId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const cluster = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the import
   *  request.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callRestoreCluster() {
    // Construct request
    const request = {
      parent,
      clusterId,
      cluster,
    };

    // Run request
    const [operation] = await alloydbClient.restoreCluster(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callRestoreCluster();

checkUpdateBackupProgress(name)

checkUpdateBackupProgress(name: string): Promise<LROperation<protos.google.cloud.alloydb.v1beta.Backup, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Optional. Field mask is used to specify the fields to be overwritten in the
   *  Backup resource by the update.
   *  The fields specified in the update_mask are relative to the resource, not
   *  the full request. A field will be overwritten if it is in the mask. If the
   *  user does not provide a mask then all fields will be overwritten.
   */
  // const updateMask = {}
  /**
   *  Required. The resource being updated
   */
  // const backup = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, the backend validates the request, but doesn't actually
   *  execute it.
   */
  // const validateOnly = true
  /**
   *  Optional. If set to true, update succeeds even if instance is not found. In
   *  that case, a new backup is created and `update_mask` is ignored.
   */
  // const allowMissing = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callUpdateBackup() {
    // Construct request
    const request = {
      backup,
    };

    // Run request
    const [operation] = await alloydbClient.updateBackup(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callUpdateBackup();

checkUpdateClusterProgress(name)

checkUpdateClusterProgress(name: string): Promise<LROperation<protos.google.cloud.alloydb.v1beta.Cluster, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Optional. Field mask is used to specify the fields to be overwritten in the
   *  Cluster resource by the update.
   *  The fields specified in the update_mask are relative to the resource, not
   *  the full request. A field will be overwritten if it is in the mask. If the
   *  user does not provide a mask then all fields will be overwritten.
   */
  // const updateMask = {}
  /**
   *  Required. The resource being updated
   */
  // const cluster = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the update
   *  request.
   */
  // const validateOnly = true
  /**
   *  Optional. If set to true, update succeeds even if cluster is not found. In
   *  that case, a new cluster is created and `update_mask` is ignored.
   */
  // const allowMissing = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callUpdateCluster() {
    // Construct request
    const request = {
      cluster,
    };

    // Run request
    const [operation] = await alloydbClient.updateCluster(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callUpdateCluster();

checkUpdateInstanceProgress(name)

checkUpdateInstanceProgress(name: string): Promise<LROperation<protos.google.cloud.alloydb.v1beta.Instance, protos.google.cloud.alloydb.v1beta.OperationMetadata>>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Optional. Field mask is used to specify the fields to be overwritten in the
   *  Instance resource by the update.
   *  The fields specified in the update_mask are relative to the resource, not
   *  the full request. A field will be overwritten if it is in the mask. If the
   *  user does not provide a mask then all fields will be overwritten.
   */
  // const updateMask = {}
  /**
   *  Required. The resource being updated
   */
  // const instance = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the update
   *  request.
   */
  // const validateOnly = true
  /**
   *  Optional. If set to true, update succeeds even if instance is not found. In
   *  that case, a new instance is created and `update_mask` is ignored.
   */
  // const allowMissing = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callUpdateInstance() {
    // Construct request
    const request = {
      instance,
    };

    // Run request
    const [operation] = await alloydbClient.updateInstance(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callUpdateInstance();

close()

close(): Promise<void>;

clusterPath(project, location, cluster)

clusterPath(project: string, location: string, cluster: string): string;

connectionInfoPath(project, location, cluster, instance)

connectionInfoPath(project: string, location: string, cluster: string, instance: string): string;

createBackup(request, options)

createBackup(request?: protos.google.cloud.alloydb.v1beta.ICreateBackupRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.alloydb.v1beta.IBackup, protos.google.cloud.alloydb.v1beta.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Value for parent.
   */
  // const parent = 'abc123'
  /**
   *  Required. ID of the requesting object.
   */
  // const backupId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const backup = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, the backend validates the request, but doesn't actually
   *  execute it.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callCreateBackup() {
    // Construct request
    const request = {
      parent,
      backupId,
      backup,
    };

    // Run request
    const [operation] = await alloydbClient.createBackup(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateBackup();

createBackup(request, options, callback)

createBackup(request: protos.google.cloud.alloydb.v1beta.ICreateBackupRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.IBackup, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createBackup(request, callback)

createBackup(request: protos.google.cloud.alloydb.v1beta.ICreateBackupRequest, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.IBackup, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createCluster(request, options)

createCluster(request?: protos.google.cloud.alloydb.v1beta.ICreateClusterRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.alloydb.v1beta.ICluster, protos.google.cloud.alloydb.v1beta.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The location of the new cluster. For the required format, see the
   *  comment on the Cluster.name field.
   */
  // const parent = 'abc123'
  /**
   *  Required. ID of the requesting object.
   */
  // const clusterId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const cluster = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the create
   *  request.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callCreateCluster() {
    // Construct request
    const request = {
      parent,
      clusterId,
      cluster,
    };

    // Run request
    const [operation] = await alloydbClient.createCluster(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateCluster();

createCluster(request, options, callback)

createCluster(request: protos.google.cloud.alloydb.v1beta.ICreateClusterRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.ICluster, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createCluster(request, callback)

createCluster(request: protos.google.cloud.alloydb.v1beta.ICreateClusterRequest, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.ICluster, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createInstance(request, options)

createInstance(request?: protos.google.cloud.alloydb.v1beta.ICreateInstanceRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the parent resource. For the required format, see the
   *  comment on the Instance.name field.
   */
  // const parent = 'abc123'
  /**
   *  Required. ID of the requesting object.
   */
  // const instanceId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const instance = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the create
   *  request.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callCreateInstance() {
    // Construct request
    const request = {
      parent,
      instanceId,
      instance,
    };

    // Run request
    const [operation] = await alloydbClient.createInstance(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateInstance();

createInstance(request, options, callback)

createInstance(request: protos.google.cloud.alloydb.v1beta.ICreateInstanceRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createInstance(request, callback)

createInstance(request: protos.google.cloud.alloydb.v1beta.ICreateInstanceRequest, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createSecondaryCluster(request, options)

createSecondaryCluster(request?: protos.google.cloud.alloydb.v1beta.ICreateSecondaryClusterRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.alloydb.v1beta.ICluster, protos.google.cloud.alloydb.v1beta.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The location of the new cluster. For the required
   *  format, see the comment on the Cluster.name field.
   */
  // const parent = 'abc123'
  /**
   *  Required. ID of the requesting object (the secondary cluster).
   */
  // const clusterId = 'abc123'
  /**
   *  Required. Configuration of the requesting object (the secondary cluster).
   */
  // const cluster = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the create
   *  request.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callCreateSecondaryCluster() {
    // Construct request
    const request = {
      parent,
      clusterId,
      cluster,
    };

    // Run request
    const [operation] = await alloydbClient.createSecondaryCluster(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateSecondaryCluster();

createSecondaryCluster(request, options, callback)

createSecondaryCluster(request: protos.google.cloud.alloydb.v1beta.ICreateSecondaryClusterRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.ICluster, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createSecondaryCluster(request, callback)

createSecondaryCluster(request: protos.google.cloud.alloydb.v1beta.ICreateSecondaryClusterRequest, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.ICluster, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createSecondaryInstance(request, options)

createSecondaryInstance(request?: protos.google.cloud.alloydb.v1beta.ICreateSecondaryInstanceRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the parent resource. For the required format, see the
   *  comment on the Instance.name field.
   */
  // const parent = 'abc123'
  /**
   *  Required. ID of the requesting object.
   */
  // const instanceId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const instance = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the create
   *  request.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callCreateSecondaryInstance() {
    // Construct request
    const request = {
      parent,
      instanceId,
      instance,
    };

    // Run request
    const [operation] = await alloydbClient.createSecondaryInstance(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateSecondaryInstance();

createSecondaryInstance(request, options, callback)

createSecondaryInstance(request: protos.google.cloud.alloydb.v1beta.ICreateSecondaryInstanceRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createSecondaryInstance(request, callback)

createSecondaryInstance(request: protos.google.cloud.alloydb.v1beta.ICreateSecondaryInstanceRequest, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createUser(request, options)

createUser(request?: protos.google.cloud.alloydb.v1beta.ICreateUserRequest, options?: CallOptions): Promise<[
        protos.google.cloud.alloydb.v1beta.IUser,
        protos.google.cloud.alloydb.v1beta.ICreateUserRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Value for parent.
   */
  // const parent = 'abc123'
  /**
   *  Required. ID of the requesting object.
   */
  // const userId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const user = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, the backend validates the request, but doesn't actually
   *  execute it.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callCreateUser() {
    // Construct request
    const request = {
      parent,
      userId,
      user,
    };

    // Run request
    const response = await alloydbClient.createUser(request);
    console.log(response);
  }

  callCreateUser();

createUser(request, options, callback)

createUser(request: protos.google.cloud.alloydb.v1beta.ICreateUserRequest, options: CallOptions, callback: Callback<protos.google.cloud.alloydb.v1beta.IUser, protos.google.cloud.alloydb.v1beta.ICreateUserRequest | null | undefined, {} | null | undefined>): void;

createUser(request, callback)

createUser(request: protos.google.cloud.alloydb.v1beta.ICreateUserRequest, callback: Callback<protos.google.cloud.alloydb.v1beta.IUser, protos.google.cloud.alloydb.v1beta.ICreateUserRequest | null | undefined, {} | null | undefined>): void;

databasePath(project, location, cluster, database)

databasePath(project: string, location: string, cluster: string, database: string): string;

deleteBackup(request, options)

deleteBackup(request?: protos.google.cloud.alloydb.v1beta.IDeleteBackupRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.alloydb.v1beta.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource. For the required format, see the comment on
   *  the Backup.name field.
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, the backend validates the request, but doesn't actually
   *  execute it.
   */
  // const validateOnly = true
  /**
   *  Optional. The current etag of the Backup.
   *  If an etag is provided and does not match the current etag of the Backup,
   *  deletion will be blocked and an ABORTED error will be returned.
   */
  // const etag = 'abc123'

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callDeleteBackup() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await alloydbClient.deleteBackup(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callDeleteBackup();

deleteBackup(request, options, callback)

deleteBackup(request: protos.google.cloud.alloydb.v1beta.IDeleteBackupRequest, options: CallOptions, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteBackup(request, callback)

deleteBackup(request: protos.google.cloud.alloydb.v1beta.IDeleteBackupRequest, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteCluster(request, options)

deleteCluster(request?: protos.google.cloud.alloydb.v1beta.IDeleteClusterRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.alloydb.v1beta.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the Cluster.name field.
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. The current etag of the Cluster.
   *  If an etag is provided and does not match the current etag of the Cluster,
   *  deletion will be blocked and an ABORTED error will be returned.
   */
  // const etag = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the delete.
   */
  // const validateOnly = true
  /**
   *  Optional. Whether to cascade delete child instances for given cluster.
   */
  // const force = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callDeleteCluster() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await alloydbClient.deleteCluster(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callDeleteCluster();

deleteCluster(request, options, callback)

deleteCluster(request: protos.google.cloud.alloydb.v1beta.IDeleteClusterRequest, options: CallOptions, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteCluster(request, callback)

deleteCluster(request: protos.google.cloud.alloydb.v1beta.IDeleteClusterRequest, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteInstance(request, options)

deleteInstance(request?: protos.google.cloud.alloydb.v1beta.IDeleteInstanceRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.alloydb.v1beta.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the Instance.name field.
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. The current etag of the Instance.
   *  If an etag is provided and does not match the current etag of the Instance,
   *  deletion will be blocked and an ABORTED error will be returned.
   */
  // const etag = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the delete.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callDeleteInstance() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await alloydbClient.deleteInstance(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callDeleteInstance();

deleteInstance(request, options, callback)

deleteInstance(request: protos.google.cloud.alloydb.v1beta.IDeleteInstanceRequest, options: CallOptions, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteInstance(request, callback)

deleteInstance(request: protos.google.cloud.alloydb.v1beta.IDeleteInstanceRequest, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteOperation(request, options, callback)

deleteOperation(request: protos.google.longrunning.DeleteOperationRequest, options?: gax.CallOptions | Callback<protos.google.protobuf.Empty, protos.google.longrunning.DeleteOperationRequest, {} | null | undefined>, callback?: Callback<protos.google.protobuf.Empty, protos.google.longrunning.DeleteOperationRequest, {} | null | undefined>): Promise<protos.google.protobuf.Empty>;

const client = longrunning.operationsClient();
await client.deleteOperation({name: ''});

deleteUser(request, options)

deleteUser(request?: protos.google.cloud.alloydb.v1beta.IDeleteUserRequest, options?: CallOptions): Promise<[
        protos.google.protobuf.IEmpty,
        protos.google.cloud.alloydb.v1beta.IDeleteUserRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the User.name field.
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, the backend validates the request, but doesn't actually
   *  execute it.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callDeleteUser() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await alloydbClient.deleteUser(request);
    console.log(response);
  }

  callDeleteUser();

deleteUser(request, options, callback)

deleteUser(request: protos.google.cloud.alloydb.v1beta.IDeleteUserRequest, options: CallOptions, callback: Callback<protos.google.protobuf.IEmpty, protos.google.cloud.alloydb.v1beta.IDeleteUserRequest | null | undefined, {} | null | undefined>): void;

deleteUser(request, callback)

deleteUser(request: protos.google.cloud.alloydb.v1beta.IDeleteUserRequest, callback: Callback<protos.google.protobuf.IEmpty, protos.google.cloud.alloydb.v1beta.IDeleteUserRequest | null | undefined, {} | null | undefined>): void;

failoverInstance(request, options)

failoverInstance(request?: protos.google.cloud.alloydb.v1beta.IFailoverInstanceRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the Instance.name field.
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the failover.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callFailoverInstance() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await alloydbClient.failoverInstance(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callFailoverInstance();

failoverInstance(request, options, callback)

failoverInstance(request: protos.google.cloud.alloydb.v1beta.IFailoverInstanceRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

failoverInstance(request, callback)

failoverInstance(request: protos.google.cloud.alloydb.v1beta.IFailoverInstanceRequest, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

generateClientCertificate(request, options)

generateClientCertificate(request?: protos.google.cloud.alloydb.v1beta.IGenerateClientCertificateRequest, options?: CallOptions): Promise<[
        protos.google.cloud.alloydb.v1beta.IGenerateClientCertificateResponse,
        (protos.google.cloud.alloydb.v1beta.IGenerateClientCertificateRequest | undefined),
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the parent resource. The required format is:
   *   * projects/{project}/locations/{location}/clusters/{cluster}
   */
  // const parent = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. A pem-encoded X.509 certificate signing request (CSR). It is
   *  recommended to use public_key instead.
   */
  // const pemCsr = 'abc123'
  /**
   *  Optional. An optional hint to the endpoint to generate the client
   *  certificate with the requested duration. The duration can be from 1 hour to
   *  24 hours. The endpoint may or may not honor the hint. If the hint is left
   *  unspecified or is not honored, then the endpoint will pick an appropriate
   *  default duration.
   */
  // const certDuration = {}
  /**
   *  Optional. The public key from the client.
   */
  // const publicKey = 'abc123'
  /**
   *  Optional. An optional hint to the endpoint to generate a client
   *  ceritificate that can be used by AlloyDB connectors to exchange additional
   *  metadata with the server after TLS handshake.
   */
  // const useMetadataExchange = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callGenerateClientCertificate() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const response = await alloydbClient.generateClientCertificate(request);
    console.log(response);
  }

  callGenerateClientCertificate();

generateClientCertificate(request, options, callback)

generateClientCertificate(request: protos.google.cloud.alloydb.v1beta.IGenerateClientCertificateRequest, options: CallOptions, callback: Callback<protos.google.cloud.alloydb.v1beta.IGenerateClientCertificateResponse, protos.google.cloud.alloydb.v1beta.IGenerateClientCertificateRequest | null | undefined, {} | null | undefined>): void;

generateClientCertificate(request, callback)

generateClientCertificate(request: protos.google.cloud.alloydb.v1beta.IGenerateClientCertificateRequest, callback: Callback<protos.google.cloud.alloydb.v1beta.IGenerateClientCertificateResponse, protos.google.cloud.alloydb.v1beta.IGenerateClientCertificateRequest | null | undefined, {} | null | undefined>): void;

getBackup(request, options)

getBackup(request?: protos.google.cloud.alloydb.v1beta.IGetBackupRequest, options?: CallOptions): Promise<[
        protos.google.cloud.alloydb.v1beta.IBackup,
        protos.google.cloud.alloydb.v1beta.IGetBackupRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Name of the resource
   */
  // const name = 'abc123'

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callGetBackup() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await alloydbClient.getBackup(request);
    console.log(response);
  }

  callGetBackup();

getBackup(request, options, callback)

getBackup(request: protos.google.cloud.alloydb.v1beta.IGetBackupRequest, options: CallOptions, callback: Callback<protos.google.cloud.alloydb.v1beta.IBackup, protos.google.cloud.alloydb.v1beta.IGetBackupRequest | null | undefined, {} | null | undefined>): void;

getBackup(request, callback)

getBackup(request: protos.google.cloud.alloydb.v1beta.IGetBackupRequest, callback: Callback<protos.google.cloud.alloydb.v1beta.IBackup, protos.google.cloud.alloydb.v1beta.IGetBackupRequest | null | undefined, {} | null | undefined>): void;

getCluster(request, options)

getCluster(request?: protos.google.cloud.alloydb.v1beta.IGetClusterRequest, options?: CallOptions): Promise<[
        protos.google.cloud.alloydb.v1beta.ICluster,
        protos.google.cloud.alloydb.v1beta.IGetClusterRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the Cluster.name field.
   */
  // const name = 'abc123'
  /**
   *  Optional. The view of the cluster to return. Returns all default fields if
   *  not set.
   */
  // const view = {}

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callGetCluster() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await alloydbClient.getCluster(request);
    console.log(response);
  }

  callGetCluster();

getCluster(request, options, callback)

getCluster(request: protos.google.cloud.alloydb.v1beta.IGetClusterRequest, options: CallOptions, callback: Callback<protos.google.cloud.alloydb.v1beta.ICluster, protos.google.cloud.alloydb.v1beta.IGetClusterRequest | null | undefined, {} | null | undefined>): void;

getCluster(request, callback)

getCluster(request: protos.google.cloud.alloydb.v1beta.IGetClusterRequest, callback: Callback<protos.google.cloud.alloydb.v1beta.ICluster, protos.google.cloud.alloydb.v1beta.IGetClusterRequest | null | undefined, {} | null | undefined>): void;

getConnectionInfo(request, options)

getConnectionInfo(request?: protos.google.cloud.alloydb.v1beta.IGetConnectionInfoRequest, options?: CallOptions): Promise<[
        protos.google.cloud.alloydb.v1beta.IConnectionInfo,
        protos.google.cloud.alloydb.v1beta.IGetConnectionInfoRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the parent resource. The required format is:
   *  projects/{project}/locations/{location}/clusters/{cluster}/instances/{instance}
   */
  // const parent = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callGetConnectionInfo() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const response = await alloydbClient.getConnectionInfo(request);
    console.log(response);
  }

  callGetConnectionInfo();

getConnectionInfo(request, options, callback)

getConnectionInfo(request: protos.google.cloud.alloydb.v1beta.IGetConnectionInfoRequest, options: CallOptions, callback: Callback<protos.google.cloud.alloydb.v1beta.IConnectionInfo, protos.google.cloud.alloydb.v1beta.IGetConnectionInfoRequest | null | undefined, {} | null | undefined>): void;

getConnectionInfo(request, callback)

getConnectionInfo(request: protos.google.cloud.alloydb.v1beta.IGetConnectionInfoRequest, callback: Callback<protos.google.cloud.alloydb.v1beta.IConnectionInfo, protos.google.cloud.alloydb.v1beta.IGetConnectionInfoRequest | null | undefined, {} | null | undefined>): void;

getIamPolicy(request, options, callback)

getIamPolicy(request: IamProtos.google.iam.v1.GetIamPolicyRequest, options?: gax.CallOptions | Callback<IamProtos.google.iam.v1.Policy, IamProtos.google.iam.v1.GetIamPolicyRequest | null | undefined, {} | null | undefined>, callback?: Callback<IamProtos.google.iam.v1.Policy, IamProtos.google.iam.v1.GetIamPolicyRequest | null | undefined, {} | null | undefined>): Promise<[IamProtos.google.iam.v1.Policy]>;

getInstance(request, options)

getInstance(request?: protos.google.cloud.alloydb.v1beta.IGetInstanceRequest, options?: CallOptions): Promise<[
        protos.google.cloud.alloydb.v1beta.IInstance,
        protos.google.cloud.alloydb.v1beta.IGetInstanceRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the Instance.name field.
   */
  // const name = 'abc123'
  /**
   *  The view of the instance to return.
   */
  // const view = {}

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callGetInstance() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await alloydbClient.getInstance(request);
    console.log(response);
  }

  callGetInstance();

getInstance(request, options, callback)

getInstance(request: protos.google.cloud.alloydb.v1beta.IGetInstanceRequest, options: CallOptions, callback: Callback<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IGetInstanceRequest | null | undefined, {} | null | undefined>): void;

getInstance(request, callback)

getInstance(request: protos.google.cloud.alloydb.v1beta.IGetInstanceRequest, callback: Callback<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IGetInstanceRequest | null | undefined, {} | null | undefined>): void;

getLocation(request, options, callback)

getLocation(request: LocationProtos.google.cloud.location.IGetLocationRequest, options?: gax.CallOptions | Callback<LocationProtos.google.cloud.location.ILocation, LocationProtos.google.cloud.location.IGetLocationRequest | null | undefined, {} | null | undefined>, callback?: Callback<LocationProtos.google.cloud.location.ILocation, LocationProtos.google.cloud.location.IGetLocationRequest | null | undefined, {} | null | undefined>): Promise<LocationProtos.google.cloud.location.ILocation>;

const [response] = await client.getLocation(request);

getOperation(request, options, callback)

getOperation(request: protos.google.longrunning.GetOperationRequest, options?: gax.CallOptions | Callback<protos.google.longrunning.Operation, protos.google.longrunning.GetOperationRequest, {} | null | undefined>, callback?: Callback<protos.google.longrunning.Operation, protos.google.longrunning.GetOperationRequest, {} | null | undefined>): Promise<[protos.google.longrunning.Operation]>;

const client = longrunning.operationsClient();
const name = '';
const [response] = await client.getOperation({name});
// doThingsWith(response)

getProjectId()

getProjectId(): Promise<string>;

getProjectId(callback)

getProjectId(callback: Callback<string, undefined, undefined>): void;

getUser(request, options)

getUser(request?: protos.google.cloud.alloydb.v1beta.IGetUserRequest, options?: CallOptions): Promise<[
        protos.google.cloud.alloydb.v1beta.IUser,
        protos.google.cloud.alloydb.v1beta.IGetUserRequest | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the User.name field.
   */
  // const name = 'abc123'

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callGetUser() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const response = await alloydbClient.getUser(request);
    console.log(response);
  }

  callGetUser();

getUser(request, options, callback)

getUser(request: protos.google.cloud.alloydb.v1beta.IGetUserRequest, options: CallOptions, callback: Callback<protos.google.cloud.alloydb.v1beta.IUser, protos.google.cloud.alloydb.v1beta.IGetUserRequest | null | undefined, {} | null | undefined>): void;

getUser(request, callback)

getUser(request: protos.google.cloud.alloydb.v1beta.IGetUserRequest, callback: Callback<protos.google.cloud.alloydb.v1beta.IUser, protos.google.cloud.alloydb.v1beta.IGetUserRequest | null | undefined, {} | null | undefined>): void;

initialize()

initialize(): Promise<{
        [name: string]: Function;
    }>;

injectFault(request, options)

injectFault(request?: protos.google.cloud.alloydb.v1beta.IInjectFaultRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The type of fault to be injected in an instance.
   */
  // const faultType = {}
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the Instance.name field.
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the fault
   *  injection.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callInjectFault() {
    // Construct request
    const request = {
      faultType,
      name,
    };

    // Run request
    const [operation] = await alloydbClient.injectFault(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callInjectFault();

injectFault(request, options, callback)

injectFault(request: protos.google.cloud.alloydb.v1beta.IInjectFaultRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

injectFault(request, callback)

injectFault(request: protos.google.cloud.alloydb.v1beta.IInjectFaultRequest, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

instancePath(project, location, cluster, instance)

instancePath(project: string, location: string, cluster: string, instance: string): string;

listBackups(request, options)

listBackups(request?: protos.google.cloud.alloydb.v1beta.IListBackupsRequest, options?: CallOptions): Promise<[
        protos.google.cloud.alloydb.v1beta.IBackup[],
        protos.google.cloud.alloydb.v1beta.IListBackupsRequest | null,
        protos.google.cloud.alloydb.v1beta.IListBackupsResponse
    ]>;

listBackups(request, options, callback)

listBackups(request: protos.google.cloud.alloydb.v1beta.IListBackupsRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.alloydb.v1beta.IListBackupsRequest, protos.google.cloud.alloydb.v1beta.IListBackupsResponse | null | undefined, protos.google.cloud.alloydb.v1beta.IBackup>): void;

listBackups(request, callback)

listBackups(request: protos.google.cloud.alloydb.v1beta.IListBackupsRequest, callback: PaginationCallback<protos.google.cloud.alloydb.v1beta.IListBackupsRequest, protos.google.cloud.alloydb.v1beta.IListBackupsResponse | null | undefined, protos.google.cloud.alloydb.v1beta.IBackup>): void;

listBackupsAsync(request, options)

listBackupsAsync(request?: protos.google.cloud.alloydb.v1beta.IListBackupsRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.alloydb.v1beta.IBackup>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Parent value for ListBackupsRequest
   */
  // const parent = 'abc123'
  /**
   *  Requested page size. Server may return fewer items than requested.
   *  If unspecified, server will pick an appropriate default.
   */
  // const pageSize = 1234
  /**
   *  A token identifying a page of results the server should return.
   */
  // const pageToken = 'abc123'
  /**
   *  Filtering results
   */
  // const filter = 'abc123'
  /**
   *  Hint for how to order the results
   */
  // const orderBy = 'abc123'

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callListBackups() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const iterable = alloydbClient.listBackupsAsync(request);
    for await (const response of iterable) {
        console.log(response);
    }
  }

  callListBackups();

listBackupsStream(request, options)

listBackupsStream(request?: protos.google.cloud.alloydb.v1beta.IListBackupsRequest, options?: CallOptions): Transform;

listClusters(request, options)

listClusters(request?: protos.google.cloud.alloydb.v1beta.IListClustersRequest, options?: CallOptions): Promise<[
        protos.google.cloud.alloydb.v1beta.ICluster[],
        protos.google.cloud.alloydb.v1beta.IListClustersRequest | null,
        protos.google.cloud.alloydb.v1beta.IListClustersResponse
    ]>;

listClusters(request, options, callback)

listClusters(request: protos.google.cloud.alloydb.v1beta.IListClustersRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.alloydb.v1beta.IListClustersRequest, protos.google.cloud.alloydb.v1beta.IListClustersResponse | null | undefined, protos.google.cloud.alloydb.v1beta.ICluster>): void;

listClusters(request, callback)

listClusters(request: protos.google.cloud.alloydb.v1beta.IListClustersRequest, callback: PaginationCallback<protos.google.cloud.alloydb.v1beta.IListClustersRequest, protos.google.cloud.alloydb.v1beta.IListClustersResponse | null | undefined, protos.google.cloud.alloydb.v1beta.ICluster>): void;

listClustersAsync(request, options)

listClustersAsync(request?: protos.google.cloud.alloydb.v1beta.IListClustersRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.alloydb.v1beta.ICluster>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the parent resource. For the required format, see the
   *  comment on the Cluster.name field. Additionally, you can perform an
   *  aggregated list operation by specifying a value with the following format:
   *   * projects/{project}/locations/-
   */
  // const parent = 'abc123'
  /**
   *  Optional. Requested page size. Server may return fewer items than
   *  requested. If unspecified, server will pick an appropriate default.
   */
  // const pageSize = 1234
  /**
   *  A token identifying a page of results the server should return.
   */
  // const pageToken = 'abc123'
  /**
   *  Optional. Filtering results
   */
  // const filter = 'abc123'
  /**
   *  Optional. Hint for how to order the results
   */
  // const orderBy = 'abc123'

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callListClusters() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const iterable = alloydbClient.listClustersAsync(request);
    for await (const response of iterable) {
        console.log(response);
    }
  }

  callListClusters();

listClustersStream(request, options)

listClustersStream(request?: protos.google.cloud.alloydb.v1beta.IListClustersRequest, options?: CallOptions): Transform;

listDatabases(request, options)

listDatabases(request?: protos.google.cloud.alloydb.v1beta.IListDatabasesRequest, options?: CallOptions): Promise<[
        protos.google.cloud.alloydb.v1beta.IDatabase[],
        protos.google.cloud.alloydb.v1beta.IListDatabasesRequest | null,
        protos.google.cloud.alloydb.v1beta.IListDatabasesResponse
    ]>;

listDatabases(request, options, callback)

listDatabases(request: protos.google.cloud.alloydb.v1beta.IListDatabasesRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.alloydb.v1beta.IListDatabasesRequest, protos.google.cloud.alloydb.v1beta.IListDatabasesResponse | null | undefined, protos.google.cloud.alloydb.v1beta.IDatabase>): void;

listDatabases(request, callback)

listDatabases(request: protos.google.cloud.alloydb.v1beta.IListDatabasesRequest, callback: PaginationCallback<protos.google.cloud.alloydb.v1beta.IListDatabasesRequest, protos.google.cloud.alloydb.v1beta.IListDatabasesResponse | null | undefined, protos.google.cloud.alloydb.v1beta.IDatabase>): void;

listDatabasesAsync(request, options)

listDatabasesAsync(request?: protos.google.cloud.alloydb.v1beta.IListDatabasesRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.alloydb.v1beta.IDatabase>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Parent value for ListDatabasesRequest.
   */
  // const parent = 'abc123'
  /**
   *  Optional. The maximum number of databases to return. The service may return
   *  fewer than this value. If unspecified, an appropriate number of databases
   *  will be returned. The max value will be 2000, values above max will be
   *  coerced to max.
   */
  // const pageSize = 1234
  /**
   *  Optional. A page token, received from a previous `ListDatabases` call.
   *  This should be provided to retrieve the subsequent page.
   *  This field is currently not supported, its value will be ignored if passed.
   */
  // const pageToken = 'abc123'
  /**
   *  Optional. Filtering results.
   *  This field is currently not supported, its value will be ignored if passed.
   */
  // const filter = 'abc123'

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callListDatabases() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const iterable = alloydbClient.listDatabasesAsync(request);
    for await (const response of iterable) {
        console.log(response);
    }
  }

  callListDatabases();

listDatabasesStream(request, options)

listDatabasesStream(request?: protos.google.cloud.alloydb.v1beta.IListDatabasesRequest, options?: CallOptions): Transform;

listInstances(request, options)

listInstances(request?: protos.google.cloud.alloydb.v1beta.IListInstancesRequest, options?: CallOptions): Promise<[
        protos.google.cloud.alloydb.v1beta.IInstance[],
        protos.google.cloud.alloydb.v1beta.IListInstancesRequest | null,
        protos.google.cloud.alloydb.v1beta.IListInstancesResponse
    ]>;

listInstances(request, options, callback)

listInstances(request: protos.google.cloud.alloydb.v1beta.IListInstancesRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.alloydb.v1beta.IListInstancesRequest, protos.google.cloud.alloydb.v1beta.IListInstancesResponse | null | undefined, protos.google.cloud.alloydb.v1beta.IInstance>): void;

listInstances(request, callback)

listInstances(request: protos.google.cloud.alloydb.v1beta.IListInstancesRequest, callback: PaginationCallback<protos.google.cloud.alloydb.v1beta.IListInstancesRequest, protos.google.cloud.alloydb.v1beta.IListInstancesResponse | null | undefined, protos.google.cloud.alloydb.v1beta.IInstance>): void;

listInstancesAsync(request, options)

listInstancesAsync(request?: protos.google.cloud.alloydb.v1beta.IListInstancesRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.alloydb.v1beta.IInstance>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the parent resource. For the required format, see the
   *  comment on the Instance.name field. Additionally, you can perform an
   *  aggregated list operation by specifying a value with one of the following
   *  formats:
   *   * projects/{project}/locations/-/clusters/-
   *   * projects/{project}/locations/{region}/clusters/-
   */
  // const parent = 'abc123'
  /**
   *  Optional. Requested page size. Server may return fewer items than
   *  requested. If unspecified, server will pick an appropriate default.
   */
  // const pageSize = 1234
  /**
   *  A token identifying a page of results the server should return.
   */
  // const pageToken = 'abc123'
  /**
   *  Optional. Filtering results
   */
  // const filter = 'abc123'
  /**
   *  Optional. Hint for how to order the results
   */
  // const orderBy = 'abc123'

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callListInstances() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const iterable = alloydbClient.listInstancesAsync(request);
    for await (const response of iterable) {
        console.log(response);
    }
  }

  callListInstances();

listInstancesStream(request, options)

listInstancesStream(request?: protos.google.cloud.alloydb.v1beta.IListInstancesRequest, options?: CallOptions): Transform;

listLocationsAsync(request, options)

listLocationsAsync(request: LocationProtos.google.cloud.location.IListLocationsRequest, options?: CallOptions): AsyncIterable<LocationProtos.google.cloud.location.ILocation>;

const iterable = client.listLocationsAsync(request);
for await (const response of iterable) {
  // process response
}

listOperationsAsync(request, options)

listOperationsAsync(request: protos.google.longrunning.ListOperationsRequest, options?: gax.CallOptions): AsyncIterable<protos.google.longrunning.ListOperationsResponse>;

const client = longrunning.operationsClient();
for await (const response of client.listOperationsAsync(request));
// doThingsWith(response)

listSupportedDatabaseFlags(request, options)

listSupportedDatabaseFlags(request?: protos.google.cloud.alloydb.v1beta.IListSupportedDatabaseFlagsRequest, options?: CallOptions): Promise<[
        protos.google.cloud.alloydb.v1beta.ISupportedDatabaseFlag[],
        protos.google.cloud.alloydb.v1beta.IListSupportedDatabaseFlagsRequest | null,
        protos.google.cloud.alloydb.v1beta.IListSupportedDatabaseFlagsResponse
    ]>;

listSupportedDatabaseFlags(request, options, callback)

listSupportedDatabaseFlags(request: protos.google.cloud.alloydb.v1beta.IListSupportedDatabaseFlagsRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.alloydb.v1beta.IListSupportedDatabaseFlagsRequest, protos.google.cloud.alloydb.v1beta.IListSupportedDatabaseFlagsResponse | null | undefined, protos.google.cloud.alloydb.v1beta.ISupportedDatabaseFlag>): void;

listSupportedDatabaseFlags(request, callback)

listSupportedDatabaseFlags(request: protos.google.cloud.alloydb.v1beta.IListSupportedDatabaseFlagsRequest, callback: PaginationCallback<protos.google.cloud.alloydb.v1beta.IListSupportedDatabaseFlagsRequest, protos.google.cloud.alloydb.v1beta.IListSupportedDatabaseFlagsResponse | null | undefined, protos.google.cloud.alloydb.v1beta.ISupportedDatabaseFlag>): void;

listSupportedDatabaseFlagsAsync(request, options)

listSupportedDatabaseFlagsAsync(request?: protos.google.cloud.alloydb.v1beta.IListSupportedDatabaseFlagsRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.alloydb.v1beta.ISupportedDatabaseFlag>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the parent resource. The required format is:
   *   * projects/{project}/locations/{location}
   *  Regardless of the parent specified here, as long it is contains a valid
   *  project and location, the service will return a static list of supported
   *  flags resources. Note that we do not yet support region-specific
   *  flags.
   */
  // const parent = 'abc123'
  /**
   *  Requested page size. Server may return fewer items than requested.
   *  If unspecified, server will pick an appropriate default.
   */
  // const pageSize = 1234
  /**
   *  A token identifying a page of results the server should return.
   */
  // const pageToken = 'abc123'

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callListSupportedDatabaseFlags() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const iterable = alloydbClient.listSupportedDatabaseFlagsAsync(request);
    for await (const response of iterable) {
        console.log(response);
    }
  }

  callListSupportedDatabaseFlags();

listSupportedDatabaseFlagsStream(request, options)

listSupportedDatabaseFlagsStream(request?: protos.google.cloud.alloydb.v1beta.IListSupportedDatabaseFlagsRequest, options?: CallOptions): Transform;

listUsers(request, options)

listUsers(request?: protos.google.cloud.alloydb.v1beta.IListUsersRequest, options?: CallOptions): Promise<[
        protos.google.cloud.alloydb.v1beta.IUser[],
        protos.google.cloud.alloydb.v1beta.IListUsersRequest | null,
        protos.google.cloud.alloydb.v1beta.IListUsersResponse
    ]>;

listUsers(request, options, callback)

listUsers(request: protos.google.cloud.alloydb.v1beta.IListUsersRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.alloydb.v1beta.IListUsersRequest, protos.google.cloud.alloydb.v1beta.IListUsersResponse | null | undefined, protos.google.cloud.alloydb.v1beta.IUser>): void;

listUsers(request, callback)

listUsers(request: protos.google.cloud.alloydb.v1beta.IListUsersRequest, callback: PaginationCallback<protos.google.cloud.alloydb.v1beta.IListUsersRequest, protos.google.cloud.alloydb.v1beta.IListUsersResponse | null | undefined, protos.google.cloud.alloydb.v1beta.IUser>): void;

listUsersAsync(request, options)

listUsersAsync(request?: protos.google.cloud.alloydb.v1beta.IListUsersRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.alloydb.v1beta.IUser>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Parent value for ListUsersRequest
   */
  // const parent = 'abc123'
  /**
   *  Optional. Requested page size. Server may return fewer items than
   *  requested. If unspecified, server will pick an appropriate default.
   */
  // const pageSize = 1234
  /**
   *  Optional. A token identifying a page of results the server should return.
   */
  // const pageToken = 'abc123'
  /**
   *  Optional. Filtering results
   */
  // const filter = 'abc123'
  /**
   *  Optional. Hint for how to order the results
   */
  // const orderBy = 'abc123'

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callListUsers() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const iterable = alloydbClient.listUsersAsync(request);
    for await (const response of iterable) {
        console.log(response);
    }
  }

  callListUsers();

listUsersStream(request, options)

listUsersStream(request?: protos.google.cloud.alloydb.v1beta.IListUsersRequest, options?: CallOptions): Transform;

locationPath(project, location)

locationPath(project: string, location: string): string;

matchBackupFromBackupName(backupName)

matchBackupFromBackupName(backupName: string): string | number;

matchClusterFromClusterName(clusterName)

matchClusterFromClusterName(clusterName: string): string | number;

matchClusterFromConnectionInfoName(connectionInfoName)

matchClusterFromConnectionInfoName(connectionInfoName: string): string | number;

matchClusterFromDatabaseName(databaseName)

matchClusterFromDatabaseName(databaseName: string): string | number;

matchClusterFromInstanceName(instanceName)

matchClusterFromInstanceName(instanceName: string): string | number;

matchClusterFromUserName(userName)

matchClusterFromUserName(userName: string): string | number;

matchDatabaseFromDatabaseName(databaseName)

matchDatabaseFromDatabaseName(databaseName: string): string | number;

matchFlagFromSupportedDatabaseFlagName(supportedDatabaseFlagName)

matchFlagFromSupportedDatabaseFlagName(supportedDatabaseFlagName: string): string | number;

matchInstanceFromConnectionInfoName(connectionInfoName)

matchInstanceFromConnectionInfoName(connectionInfoName: string): string | number;

matchInstanceFromInstanceName(instanceName)

matchInstanceFromInstanceName(instanceName: string): string | number;

matchLocationFromBackupName(backupName)

matchLocationFromBackupName(backupName: string): string | number;

matchLocationFromClusterName(clusterName)

matchLocationFromClusterName(clusterName: string): string | number;

matchLocationFromConnectionInfoName(connectionInfoName)

matchLocationFromConnectionInfoName(connectionInfoName: string): string | number;

matchLocationFromDatabaseName(databaseName)

matchLocationFromDatabaseName(databaseName: string): string | number;

matchLocationFromInstanceName(instanceName)

matchLocationFromInstanceName(instanceName: string): string | number;

matchLocationFromLocationName(locationName)

matchLocationFromLocationName(locationName: string): string | number;

matchLocationFromSupportedDatabaseFlagName(supportedDatabaseFlagName)

matchLocationFromSupportedDatabaseFlagName(supportedDatabaseFlagName: string): string | number;

matchLocationFromUserName(userName)

matchLocationFromUserName(userName: string): string | number;

matchProjectFromBackupName(backupName)

matchProjectFromBackupName(backupName: string): string | number;

matchProjectFromClusterName(clusterName)

matchProjectFromClusterName(clusterName: string): string | number;

matchProjectFromConnectionInfoName(connectionInfoName)

matchProjectFromConnectionInfoName(connectionInfoName: string): string | number;

matchProjectFromDatabaseName(databaseName)

matchProjectFromDatabaseName(databaseName: string): string | number;

matchProjectFromInstanceName(instanceName)

matchProjectFromInstanceName(instanceName: string): string | number;

matchProjectFromLocationName(locationName)

matchProjectFromLocationName(locationName: string): string | number;

matchProjectFromProjectName(projectName)

matchProjectFromProjectName(projectName: string): string | number;

matchProjectFromSupportedDatabaseFlagName(supportedDatabaseFlagName)

matchProjectFromSupportedDatabaseFlagName(supportedDatabaseFlagName: string): string | number;

matchProjectFromUserName(userName)

matchProjectFromUserName(userName: string): string | number;

matchUserFromUserName(userName)

matchUserFromUserName(userName: string): string | number;

projectPath(project)

projectPath(project: string): string;

promoteCluster(request, options)

promoteCluster(request?: protos.google.cloud.alloydb.v1beta.IPromoteClusterRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.alloydb.v1beta.ICluster, protos.google.cloud.alloydb.v1beta.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the Cluster.name field
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. The current etag of the Cluster.
   *  If an etag is provided and does not match the current etag of the Cluster,
   *  deletion will be blocked and an ABORTED error will be returned.
   */
  // const etag = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the delete.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callPromoteCluster() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await alloydbClient.promoteCluster(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callPromoteCluster();

promoteCluster(request, options, callback)

promoteCluster(request: protos.google.cloud.alloydb.v1beta.IPromoteClusterRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.ICluster, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

promoteCluster(request, callback)

promoteCluster(request: protos.google.cloud.alloydb.v1beta.IPromoteClusterRequest, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.ICluster, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

restartInstance(request, options)

restartInstance(request?: protos.google.cloud.alloydb.v1beta.IRestartInstanceRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The name of the resource. For the required format, see the
   *  comment on the Instance.name field.
   */
  // const name = 'abc123'
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes after the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the restart.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callRestartInstance() {
    // Construct request
    const request = {
      name,
    };

    // Run request
    const [operation] = await alloydbClient.restartInstance(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callRestartInstance();

restartInstance(request, options, callback)

restartInstance(request: protos.google.cloud.alloydb.v1beta.IRestartInstanceRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

restartInstance(request, callback)

restartInstance(request: protos.google.cloud.alloydb.v1beta.IRestartInstanceRequest, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.IInstance, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

restoreCluster(request, options)

restoreCluster(request?: protos.google.cloud.alloydb.v1beta.IRestoreClusterRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.alloydb.v1beta.ICluster, protos.google.cloud.alloydb.v1beta.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Backup source.
   */
  // const backupSource = {}
  /**
   *  ContinuousBackup source. Continuous backup needs to be enabled in the
   *  source cluster for this operation to succeed.
   */
  // const continuousBackupSource = {}
  /**
   *  Required. The name of the parent resource. For the required format, see the
   *  comment on the Cluster.name field.
   */
  // const parent = 'abc123'
  /**
   *  Required. ID of the requesting object.
   */
  // const clusterId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const cluster = {}
  /**
   *  Optional. An optional request ID to identify requests. Specify a unique
   *  request ID so that if you must retry your request, the server will know to
   *  ignore the request if it has already been completed. The server will
   *  guarantee that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and
   *  the request times out. If you make the request again with the same request
   *  ID, the server can check if original operation with the same request ID
   *  was received, and if so, will ignore the second request. This prevents
   *  clients from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. If set, performs request validation (e.g. permission checks and
   *  any other type of validation), but do not actually execute the import
   *  request.
   */
  // const validateOnly = true

  // Imports the Alloydb library
  const {AlloyDBAdminClient} = require('@google-cloud/alloydb').v1beta;

  // Instantiates a client
  const alloydbClient = new AlloyDBAdminClient();

  async function callRestoreCluster() {
    // Construct request
    const request = {
      parent,
      clusterId,
      cluster,
    };

    // Run request
    const [operation] = await alloydbClient.restoreCluster(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callRestoreCluster();

restoreCluster(request, options, callback)

restoreCluster(request: protos.google.cloud.alloydb.v1beta.IRestoreClusterRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.alloydb.v1beta.ICluster, protos.google.cloud.alloydb.v1beta.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;