Class v1.BackupDRClient (0.6.0)

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

  /**
   * 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 backup plan association project and location in the format
   *  `projects/{project_id}/locations/{location}`. In Cloud BackupDR locations
   *  map to GCP regions, for example **us-central1**.
   */
  // const parent = 'abc123'
  /**
   *  Required. The name of the backup plan association to create. The name must
   *  be unique for the specified project and location.
   */
  // const backupPlanAssociationId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const backupPlanAssociation = {}
  /**
   *  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 t
   *  he 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 Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

  async function callCreateBackupPlanAssociation() {
    // Construct request
    const request = {
      parent,
      backupPlanAssociationId,
      backupPlanAssociation,
    };

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

  callCreateBackupPlanAssociation();

  /**
   * 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 `BackupPlan` project and location in the format
   *  `projects/{project}/locations/{location}`. In Cloud BackupDR locations
   *  map to GCP regions, for example **us-central1**.
   */
  // const parent = 'abc123'
  /**
   *  Required. The name of the `BackupPlan` to create. The name must be unique
   *  for the specified project and location.The name must start with a lowercase
   *  letter followed by up to 62 lowercase letters, numbers, or hyphens.
   *  Pattern, /[a-z][a-z0-9-]{,62}/.
   */
  // const backupPlanId = 'abc123'
  /**
   *  Required. The `BackupPlan` resource object to create.
   */
  // const backupPlan = {}
  /**
   *  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 t
   *  he 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 Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

  async function callCreateBackupPlan() {
    // Construct request
    const request = {
      parent,
      backupPlanId,
      backupPlan,
    };

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

  callCreateBackupPlan();

  /**
   * 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
   *  If auto-generating ID server-side, remove this field and
   *  backup_vault_id from the method_signature of Create RPC
   */
  // const backupVaultId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const backupVault = {}
  /**
   *  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. Only validate the request, but do not perform mutations.
   *  The default is 'false'.
   */
  // const validateOnly = true

  // Imports the Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

  async function callCreateBackupVault() {
    // Construct request
    const request = {
      parent,
      backupVaultId,
      backupVault,
    };

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

  callCreateBackupVault();

  /**
   * 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 management server project and location in the format
   *  'projects/{project_id}/locations/{location}'. In Cloud Backup and DR
   *  locations map to Google Cloud regions, for example **us-central1**.
   */
  // const parent = 'abc123'
  /**
   *  Required. The name of the management server to create. The name must be
   *  unique for the specified project and location.
   */
  // const managementServerId = 'abc123'
  /**
   *  Required. A management server
   *  resource google.cloud.backupdr.v1.ManagementServer 
   */
  // const managementServer = {}
  /**
   *  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 Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

  async function callCreateManagementServer() {
    // Construct request
    const request = {
      parent,
      managementServerId,
      managementServer,
    };

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

  callCreateManagementServer();

  /**
   * 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 backup plan association resource, in the format
   *  `projects/{project}/locations/{location}/backupPlanAssociations/{backupPlanAssociationId}`
   */
  // 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'

  // Imports the Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

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

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

  callDeleteBackupPlanAssociation();

  /**
   * 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 resource name of the `BackupPlan` to delete.
   *  Format: `projects/{project}/locations/{location}/backupPlans/{backup_plan}`
   */
  // 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'

  // Imports the Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

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

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

  callDeleteBackupPlan();

  /**
   * 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'
  /**
   *  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 Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

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

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

  callDeleteBackup();

  /**
   * 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'
  /**
   *  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 to true, any data source from this backup vault will also
   *  be deleted.
   */
  // const force = true
  /**
   *  The current etag of the backup vault.
   *  If an etag is provided and does not match the current etag of the
   *  connection, deletion will be blocked.
   */
  // const etag = 'abc123'
  /**
   *  Optional. Only validate the request, but do not perform mutations.
   *  The default is 'false'.
   */
  // const validateOnly = true
  /**
   *  Optional. If true and the BackupVault is not found, the request will
   *  succeed but no action will be taken.
   */
  // const allowMissing = true
  /**
   *  Optional. If set to true, backupvault deletion will proceed even if there
   *  are backup plans referencing the backupvault. The default is 'false'.
   */
  // const ignoreBackupPlanReferences = true

  // Imports the Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

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

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

  callDeleteBackupVault();

  /**
   * 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'
  /**
   *  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 Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

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

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

  callDeleteManagementServer();

  /**
   * 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 resource name of the serviceConfig used to initialize the
   *  service. Format:
   *  `projects/{project_id}/locations/{location}/serviceConfig`.
   */
  // const name = 'abc123'
  /**
   *  Required. The resource type to which the default service config will be
   *  applied. Examples include, "compute.googleapis.com/Instance" and
   *  "storage.googleapis.com/Bucket".
   */
  // const resourceType = '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 since the first request.
   *  For example, consider a situation where you make an initial request and t
   *  he 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 configuration for initializing a Cloud SQL instance.
   */
  // const cloudSqlInstanceInitializationConfig = {}

  // Imports the Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

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

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

  callInitializeService();

  /**
   * 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 resource name of the Backup instance, in the format
   *  'projects/* /locations/* /backupVaults/* /dataSources/* /backups/'.
   */
  // 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'
  /**
   *  Compute Engine target environment to be used during restore.
   */
  // const computeInstanceTargetEnvironment = {}
  /**
   *  Disk target environment to be used during restore.
   */
  // const diskTargetEnvironment = {}
  /**
   *  Region disk target environment to be used during restore.
   */
  // const regionDiskTargetEnvironment = {}
  /**
   *  Compute Engine instance properties to be overridden during restore.
   */
  // const computeInstanceRestoreProperties = {}
  /**
   *  Disk properties to be overridden during restore.
   */
  // const diskRestoreProperties = {}

  // Imports the Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

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

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

  callRestoreBackup();

  /**
   * 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 backup plan association resource, in the format
   *  `projects/{project}/locations/{location}/backupPlanAssociations/{backupPlanAssociationId}`
   */
  // const name = 'abc123'
  /**
   *  Required. backup rule_id for which a backup needs to be triggered.
   */
  // const ruleId = '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 Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

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

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

  callTriggerBackup();

  /**
   * 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 resource being updated
   */
  // const backupPlanAssociation = {}
  /**
   *  Required. The list of fields to update.
   *  Field mask is used to specify the fields to be overwritten in the
   *  BackupPlanAssociation 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 the request will fail.
   *  Currently backup_plan_association.backup_plan is the only supported field.
   */
  // const updateMask = {}
  /**
   *  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 t
   *  he 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 Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

  async function callUpdateBackupPlanAssociation() {
    // Construct request
    const request = {
      backupPlanAssociation,
      updateMask,
    };

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

  callUpdateBackupPlanAssociation();

  /**
   * 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 resource being updated
   */
  // const backupPlan = {}
  /**
   *  Required. The list of fields to update.
   *  Field mask is used to specify the fields to be overwritten in the
   *  BackupPlan 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 the request will fail.
   *  Currently, these fields are supported in update: description, schedules,
   *  retention period, adding and removing Backup Rules.
   */
  // const updateMask = {}
  /**
   *  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 t
   *  he 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 Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

  async function callUpdateBackupPlan() {
    // Construct request
    const request = {
      backupPlan,
      updateMask,
    };

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

  callUpdateBackupPlan();

  /**
   * 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. 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 the request will fail.
   */
  // 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'

  // Imports the Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

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

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

  callUpdateBackup();

  /**
   * 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. Field mask is used to specify the fields to be overwritten in the
   *  BackupVault 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 the request will fail.
   */
  // const updateMask = {}
  /**
   *  Required. The resource being updated
   */
  // const backupVault = {}
  /**
   *  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. Only validate the request, but do not perform mutations.
   *  The default is 'false'.
   */
  // const validateOnly = true
  /**
   *  Optional. If set to true, will not check plan duration against backup vault
   *  enforcement duration.
   */
  // const force = true
  /**
   *  Optional. If set to true, we will force update access restriction even if
   *  some non compliant data sources are present. The default is 'false'.
   */
  // const forceUpdateAccessRestriction = true

  // Imports the Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

  async function callUpdateBackupVault() {
    // Construct request
    const request = {
      updateMask,
      backupVault,
    };

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

  callUpdateBackupVault();

  /**
   * 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. Field mask is used to specify the fields to be overwritten in the
   *  DataSource 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 the request will fail.
   */
  // const updateMask = {}
  /**
   *  Required. The resource being updated
   */
  // const dataSource = {}
  /**
   *  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. Enable upsert.
   */
  // const allowMissing = true

  // Imports the Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

  async function callUpdateDataSource() {
    // Construct request
    const request = {
      updateMask,
      dataSource,
    };

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

  callUpdateDataSource();

  /**
   * 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 `BackupPlan` project and location in the format
   *  `projects/{project}/locations/{location}`. In Cloud BackupDR locations
   *  map to GCP regions, for example **us-central1**.
   */
  // const parent = 'abc123'
  /**
   *  Required. The name of the `BackupPlan` to create. The name must be unique
   *  for the specified project and location.The name must start with a lowercase
   *  letter followed by up to 62 lowercase letters, numbers, or hyphens.
   *  Pattern, /[a-z][a-z0-9-]{,62}/.
   */
  // const backupPlanId = 'abc123'
  /**
   *  Required. The `BackupPlan` resource object to create.
   */
  // const backupPlan = {}
  /**
   *  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 t
   *  he 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 Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

  async function callCreateBackupPlan() {
    // Construct request
    const request = {
      parent,
      backupPlanId,
      backupPlan,
    };

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

  callCreateBackupPlan();

  /**
   * 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 backup plan association project and location in the format
   *  `projects/{project_id}/locations/{location}`. In Cloud BackupDR locations
   *  map to GCP regions, for example **us-central1**.
   */
  // const parent = 'abc123'
  /**
   *  Required. The name of the backup plan association to create. The name must
   *  be unique for the specified project and location.
   */
  // const backupPlanAssociationId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const backupPlanAssociation = {}
  /**
   *  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 t
   *  he 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 Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

  async function callCreateBackupPlanAssociation() {
    // Construct request
    const request = {
      parent,
      backupPlanAssociationId,
      backupPlanAssociation,
    };

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

  callCreateBackupPlanAssociation();

  /**
   * 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
   *  If auto-generating ID server-side, remove this field and
   *  backup_vault_id from the method_signature of Create RPC
   */
  // const backupVaultId = 'abc123'
  /**
   *  Required. The resource being created
   */
  // const backupVault = {}
  /**
   *  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. Only validate the request, but do not perform mutations.
   *  The default is 'false'.
   */
  // const validateOnly = true

  // Imports the Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

  async function callCreateBackupVault() {
    // Construct request
    const request = {
      parent,
      backupVaultId,
      backupVault,
    };

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

  callCreateBackupVault();

  /**
   * 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 management server project and location in the format
   *  'projects/{project_id}/locations/{location}'. In Cloud Backup and DR
   *  locations map to Google Cloud regions, for example **us-central1**.
   */
  // const parent = 'abc123'
  /**
   *  Required. The name of the management server to create. The name must be
   *  unique for the specified project and location.
   */
  // const managementServerId = 'abc123'
  /**
   *  Required. A management server
   *  resource google.cloud.backupdr.v1.ManagementServer 
   */
  // const managementServer = {}
  /**
   *  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 Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

  async function callCreateManagementServer() {
    // Construct request
    const request = {
      parent,
      managementServerId,
      managementServer,
    };

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

  callCreateManagementServer();

  /**
   * 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'
  /**
   *  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 Backupdr library
  const {BackupDRClient} = require('@google-cloud/backupdr').v1;

  // Instantiates a client
  const backupdrClient = new BackupDRClient();

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

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

  callDeleteBackup();