Class v1.CertificateAuthorityServiceClient (5.2.0)

Package

Constructors

(constructor)(opts, gaxInstance)

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

Properties

apiEndpoint

get apiEndpoint(): string;

apiEndpoint

static get apiEndpoint(): string;

auth

auth: gax.GoogleAuth;

certificateAuthorityServiceStub

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

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

activateCertificateAuthority(request, options)

activateCertificateAuthority(request?: protos.google.cloud.security.privateca.v1.IActivateCertificateAuthorityRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.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 resource name for this
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  in the format `projects/* /locations/* /caPools/* /certificateAuthorities/*`.
   */
  // const name = 'abc123'
  /**
   *  Required. The signed CA certificate issued from
   *  FetchCertificateAuthorityCsrResponse.pem_csr google.cloud.security.privateca.v1.FetchCertificateAuthorityCsrResponse.pem_csr.
   */
  // const pemCaCertificate = 'abc123'
  /**
   *  Required. Must include information about the issuer of
   *  'pem_ca_certificate', and any further issuers until the self-signed CA.
   */
  // const subordinateConfig = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callActivateCertificateAuthority() {
    // Construct request
    const request = {
      name,
      pemCaCertificate,
      subordinateConfig,
    };

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

  callActivateCertificateAuthority();

activateCertificateAuthority(request, options, callback)

activateCertificateAuthority(request: protos.google.cloud.security.privateca.v1.IActivateCertificateAuthorityRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

activateCertificateAuthority(request, callback)

activateCertificateAuthority(request: protos.google.cloud.security.privateca.v1.IActivateCertificateAuthorityRequest, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.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: ''});

caPoolPath(project, location, caPool)

caPoolPath(project: string, location: string, caPool: string): string;

certificateAuthorityPath(project, location, caPool, certificateAuthority)

certificateAuthorityPath(project: string, location: string, caPool: string, certificateAuthority: string): string;

certificatePath(project, location, caPool, certificate)

certificatePath(project: string, location: string, caPool: string, certificate: string): string;

certificateRevocationListPath(project, location, caPool, certificateAuthority, certificateRevocationList)

certificateRevocationListPath(project: string, location: string, caPool: string, certificateAuthority: string, certificateRevocationList: string): string;

certificateTemplatePath(project, location, certificateTemplate)

certificateTemplatePath(project: string, location: string, certificateTemplate: string): string;

checkActivateCertificateAuthorityProgress(name)

checkActivateCertificateAuthorityProgress(name: string): Promise<LROperation<protos.google.cloud.security.privateca.v1.CertificateAuthority, protos.google.cloud.security.privateca.v1.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 resource name for this
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  in the format `projects/* /locations/* /caPools/* /certificateAuthorities/*`.
   */
  // const name = 'abc123'
  /**
   *  Required. The signed CA certificate issued from
   *  FetchCertificateAuthorityCsrResponse.pem_csr google.cloud.security.privateca.v1.FetchCertificateAuthorityCsrResponse.pem_csr.
   */
  // const pemCaCertificate = 'abc123'
  /**
   *  Required. Must include information about the issuer of
   *  'pem_ca_certificate', and any further issuers until the self-signed CA.
   */
  // const subordinateConfig = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callActivateCertificateAuthority() {
    // Construct request
    const request = {
      name,
      pemCaCertificate,
      subordinateConfig,
    };

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

  callActivateCertificateAuthority();

checkCreateCaPoolProgress(name)

checkCreateCaPoolProgress(name: string): Promise<LROperation<protos.google.cloud.security.privateca.v1.CaPool, protos.google.cloud.security.privateca.v1.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 resource name of the location associated with the
   *  CaPool google.cloud.security.privateca.v1.CaPool, in the format
   *  `projects/* /locations/*`.
   */
  // const parent = 'abc123'
  /**
   *  Required. It must be unique within a location and match the regular
   *  expression `[a-zA-Z0-9_-]{1,63}`
   */
  // const caPoolId = 'abc123'
  /**
   *  Required. A CaPool google.cloud.security.privateca.v1.CaPool  with
   *  initial field values.
   */
  // const caPool = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callCreateCaPool() {
    // Construct request
    const request = {
      parent,
      caPoolId,
      caPool,
    };

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

  callCreateCaPool();

checkCreateCertificateAuthorityProgress(name)

checkCreateCertificateAuthorityProgress(name: string): Promise<LROperation<protos.google.cloud.security.privateca.v1.CertificateAuthority, protos.google.cloud.security.privateca.v1.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 resource name of the
   *  CaPool google.cloud.security.privateca.v1.CaPool  associated with the
   *  CertificateAuthorities google.cloud.security.privateca.v1.CertificateAuthority,
   *  in the format `projects/* /locations/* /caPools/*`.
   */
  // const parent = 'abc123'
  /**
   *  Required. It must be unique within a location and match the regular
   *  expression `[a-zA-Z0-9_-]{1,63}`
   */
  // const certificateAuthorityId = 'abc123'
  /**
   *  Required. A
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  with initial field values.
   */
  // const certificateAuthority = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callCreateCertificateAuthority() {
    // Construct request
    const request = {
      parent,
      certificateAuthorityId,
      certificateAuthority,
    };

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

  callCreateCertificateAuthority();

checkCreateCertificateTemplateProgress(name)

checkCreateCertificateTemplateProgress(name: string): Promise<LROperation<protos.google.cloud.security.privateca.v1.CertificateTemplate, protos.google.cloud.security.privateca.v1.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 resource name of the location associated with the
   *  CertificateTemplate google.cloud.security.privateca.v1.CertificateTemplate,
   *  in the format `projects/* /locations/*`.
   */
  // const parent = 'abc123'
  /**
   *  Required. It must be unique within a location and match the regular
   *  expression `[a-zA-Z0-9_-]{1,63}`
   */
  // const certificateTemplateId = 'abc123'
  /**
   *  Required. A
   *  CertificateTemplate google.cloud.security.privateca.v1.CertificateTemplate 
   *  with initial field values.
   */
  // const certificateTemplate = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callCreateCertificateTemplate() {
    // Construct request
    const request = {
      parent,
      certificateTemplateId,
      certificateTemplate,
    };

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

  callCreateCertificateTemplate();

checkDeleteCaPoolProgress(name)

checkDeleteCaPoolProgress(name: string): Promise<LROperation<protos.google.protobuf.Empty, protos.google.cloud.security.privateca.v1.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 resource name for this
   *  CaPool google.cloud.security.privateca.v1.CaPool  in the format
   *  `projects/* /locations/* /caPools/*`.
   */
  // const name = 'abc123'
  /**
   *  Optional. An 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. This field allows this pool to be deleted even if it's being
   *  depended on by another resource. However, doing so may result in unintended
   *  and unrecoverable effects on any dependent resource(s) since the pool will
   *  no longer be able to issue certificates.
   */
  // const ignoreDependentResources = true

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callDeleteCaPool();

checkDeleteCertificateAuthorityProgress(name)

checkDeleteCertificateAuthorityProgress(name: string): Promise<LROperation<protos.google.cloud.security.privateca.v1.CertificateAuthority, protos.google.cloud.security.privateca.v1.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 resource name for this
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  in the format `projects/* /locations/* /caPools/* /certificateAuthorities/*`.
   */
  // const name = 'abc123'
  /**
   *  Optional. An 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. This field allows the CA to be deleted even if the CA has
   *  active certs. Active certs include both unrevoked and unexpired certs.
   */
  // const ignoreActiveCertificates = true
  /**
   *  Optional. If this flag is set, the Certificate Authority will be deleted as
   *  soon as possible without a 30-day grace period where undeletion would have
   *  been allowed. If you proceed, there will be no way to recover this CA.
   */
  // const skipGracePeriod = true
  /**
   *  Optional. This field allows this ca to be deleted even if it's being
   *  depended on by another resource. However, doing so may result in unintended
   *  and unrecoverable effects on any dependent resource(s) since the CA will
   *  no longer be able to issue certificates.
   */
  // const ignoreDependentResources = true

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callDeleteCertificateAuthority();

checkDeleteCertificateTemplateProgress(name)

checkDeleteCertificateTemplateProgress(name: string): Promise<LROperation<protos.google.protobuf.Empty, protos.google.cloud.security.privateca.v1.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 resource name for this
   *  CertificateTemplate google.cloud.security.privateca.v1.CertificateTemplate 
   *  in the format `projects/* /locations/* /certificateTemplates/*`.
   */
  // const name = 'abc123'
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callDeleteCertificateTemplate();

checkDisableCertificateAuthorityProgress(name)

checkDisableCertificateAuthorityProgress(name: string): Promise<LROperation<protos.google.cloud.security.privateca.v1.CertificateAuthority, protos.google.cloud.security.privateca.v1.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 resource name for this
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  in the format `projects/* /locations/* /caPools/* /certificateAuthorities/*`.
   */
  // const name = 'abc123'
  /**
   *  Optional. An 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. This field allows this CA to be disabled even if it's being
   *  depended on by another resource. However, doing so may result in unintended
   *  and unrecoverable effects on any dependent resource(s) since the CA will
   *  no longer be able to issue certificates.
   */
  // const ignoreDependentResources = true

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callDisableCertificateAuthority();

checkEnableCertificateAuthorityProgress(name)

checkEnableCertificateAuthorityProgress(name: string): Promise<LROperation<protos.google.cloud.security.privateca.v1.CertificateAuthority, protos.google.cloud.security.privateca.v1.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 resource name for this
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  in the format `projects/* /locations/* /caPools/* /certificateAuthorities/*`.
   */
  // const name = 'abc123'
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callEnableCertificateAuthority();

checkUndeleteCertificateAuthorityProgress(name)

checkUndeleteCertificateAuthorityProgress(name: string): Promise<LROperation<protos.google.cloud.security.privateca.v1.CertificateAuthority, protos.google.cloud.security.privateca.v1.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 resource name for this
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  in the format `projects/* /locations/* /caPools/* /certificateAuthorities/*`.
   */
  // const name = 'abc123'
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callUndeleteCertificateAuthority();

checkUpdateCaPoolProgress(name)

checkUpdateCaPoolProgress(name: string): Promise<LROperation<protos.google.cloud.security.privateca.v1.CaPool, protos.google.cloud.security.privateca.v1.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. CaPool google.cloud.security.privateca.v1.CaPool  with updated
   *  values.
   */
  // const caPool = {}
  /**
   *  Required. A list of fields to be updated in this request.
   */
  // const updateMask = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callUpdateCaPool() {
    // Construct request
    const request = {
      caPool,
      updateMask,
    };

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

  callUpdateCaPool();

checkUpdateCertificateAuthorityProgress(name)

checkUpdateCertificateAuthorityProgress(name: string): Promise<LROperation<protos.google.cloud.security.privateca.v1.CertificateAuthority, protos.google.cloud.security.privateca.v1.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.
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  with updated values.
   */
  // const certificateAuthority = {}
  /**
   *  Required. A list of fields to be updated in this request.
   */
  // const updateMask = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callUpdateCertificateAuthority() {
    // Construct request
    const request = {
      certificateAuthority,
      updateMask,
    };

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

  callUpdateCertificateAuthority();

checkUpdateCertificateRevocationListProgress(name)

checkUpdateCertificateRevocationListProgress(name: string): Promise<LROperation<protos.google.cloud.security.privateca.v1.CertificateRevocationList, protos.google.cloud.security.privateca.v1.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.
   *  CertificateRevocationList google.cloud.security.privateca.v1.CertificateRevocationList 
   *  with updated values.
   */
  // const certificateRevocationList = {}
  /**
   *  Required. A list of fields to be updated in this request.
   */
  // const updateMask = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callUpdateCertificateRevocationList() {
    // Construct request
    const request = {
      certificateRevocationList,
      updateMask,
    };

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

  callUpdateCertificateRevocationList();

checkUpdateCertificateTemplateProgress(name)

checkUpdateCertificateTemplateProgress(name: string): Promise<LROperation<protos.google.cloud.security.privateca.v1.CertificateTemplate, protos.google.cloud.security.privateca.v1.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.
   *  CertificateTemplate google.cloud.security.privateca.v1.CertificateTemplate 
   *  with updated values.
   */
  // const certificateTemplate = {}
  /**
   *  Required. A list of fields to be updated in this request.
   */
  // const updateMask = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callUpdateCertificateTemplate() {
    // Construct request
    const request = {
      certificateTemplate,
      updateMask,
    };

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

  callUpdateCertificateTemplate();

close()

close(): Promise<void>;

createCaPool(request, options)

createCaPool(request?: protos.google.cloud.security.privateca.v1.ICreateCaPoolRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.security.privateca.v1.ICaPool, protos.google.cloud.security.privateca.v1.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 resource name of the location associated with the
   *  CaPool google.cloud.security.privateca.v1.CaPool, in the format
   *  `projects/* /locations/*`.
   */
  // const parent = 'abc123'
  /**
   *  Required. It must be unique within a location and match the regular
   *  expression `[a-zA-Z0-9_-]{1,63}`
   */
  // const caPoolId = 'abc123'
  /**
   *  Required. A CaPool google.cloud.security.privateca.v1.CaPool  with
   *  initial field values.
   */
  // const caPool = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callCreateCaPool() {
    // Construct request
    const request = {
      parent,
      caPoolId,
      caPool,
    };

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

  callCreateCaPool();

createCaPool(request, options, callback)

createCaPool(request: protos.google.cloud.security.privateca.v1.ICreateCaPoolRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICaPool, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createCaPool(request, callback)

createCaPool(request: protos.google.cloud.security.privateca.v1.ICreateCaPoolRequest, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICaPool, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createCertificate(request, options)

createCertificate(request?: protos.google.cloud.security.privateca.v1.ICreateCertificateRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.ICertificate,
        (protos.google.cloud.security.privateca.v1.ICreateCertificateRequest | 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 resource name of the
   *  CaPool google.cloud.security.privateca.v1.CaPool  associated with the
   *  Certificate google.cloud.security.privateca.v1.Certificate, in the
   *  format `projects/* /locations/* /caPools/*`.
   */
  // const parent = 'abc123'
  /**
   *  Optional. It must be unique within a location and match the regular
   *  expression `[a-zA-Z0-9_-]{1,63}`. This field is required when using a
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  in the Enterprise CertificateAuthority.Tier , but is optional and its
   *  value is ignored otherwise.
   */
  // const certificateId = 'abc123'
  /**
   *  Required. A Certificate google.cloud.security.privateca.v1.Certificate 
   *  with initial field values.
   */
  // const certificate = {}
  /**
   *  Optional. An 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 this is true, no
   *  Certificate google.cloud.security.privateca.v1.Certificate  resource will
   *  be persisted regardless of the
   *  CaPool google.cloud.security.privateca.v1.CaPool's
   *  tier google.cloud.security.privateca.v1.CaPool.tier, and the returned
   *  Certificate google.cloud.security.privateca.v1.Certificate  will not
   *  contain the
   *  pem_certificate google.cloud.security.privateca.v1.Certificate.pem_certificate 
   *  field.
   */
  // const validateOnly = true
  /**
   *  Optional. The resource ID of the
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  that should issue the certificate.  This optional field will ignore the
   *  load-balancing scheme of the Pool and directly issue the certificate from
   *  the CA with the specified ID, contained in the same
   *  CaPool google.cloud.security.privateca.v1.CaPool  referenced by `parent`.
   *  Per-CA quota rules apply. If left empty, a
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  will be chosen from the CaPool google.cloud.security.privateca.v1.CaPool 
   *  by the service. For example, to issue a
   *  Certificate google.cloud.security.privateca.v1.Certificate  from a
   *  Certificate Authority with resource name
   *  "projects/my-project/locations/us-central1/caPools/my-pool/certificateAuthorities/my-ca",
   *  you can set the
   *  parent google.cloud.security.privateca.v1.CreateCertificateRequest.parent 
   *  to "projects/my-project/locations/us-central1/caPools/my-pool" and the
   *  issuing_certificate_authority_id google.cloud.security.privateca.v1.CreateCertificateRequest.issuing_certificate_authority_id 
   *  to "my-ca".
   */
  // const issuingCertificateAuthorityId = 'abc123'

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

    // Run request
    const response = await privatecaClient.createCertificate(request);
    console.log(response);
  }

  callCreateCertificate();

createCertificate(request, options, callback)

createCertificate(request: protos.google.cloud.security.privateca.v1.ICreateCertificateRequest, options: CallOptions, callback: Callback<protos.google.cloud.security.privateca.v1.ICertificate, protos.google.cloud.security.privateca.v1.ICreateCertificateRequest | null | undefined, {} | null | undefined>): void;

createCertificate(request, callback)

createCertificate(request: protos.google.cloud.security.privateca.v1.ICreateCertificateRequest, callback: Callback<protos.google.cloud.security.privateca.v1.ICertificate, protos.google.cloud.security.privateca.v1.ICreateCertificateRequest | null | undefined, {} | null | undefined>): void;

createCertificateAuthority(request, options)

createCertificateAuthority(request?: protos.google.cloud.security.privateca.v1.ICreateCertificateAuthorityRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.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 resource name of the
   *  CaPool google.cloud.security.privateca.v1.CaPool  associated with the
   *  CertificateAuthorities google.cloud.security.privateca.v1.CertificateAuthority,
   *  in the format `projects/* /locations/* /caPools/*`.
   */
  // const parent = 'abc123'
  /**
   *  Required. It must be unique within a location and match the regular
   *  expression `[a-zA-Z0-9_-]{1,63}`
   */
  // const certificateAuthorityId = 'abc123'
  /**
   *  Required. A
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  with initial field values.
   */
  // const certificateAuthority = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callCreateCertificateAuthority() {
    // Construct request
    const request = {
      parent,
      certificateAuthorityId,
      certificateAuthority,
    };

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

  callCreateCertificateAuthority();

createCertificateAuthority(request, options, callback)

createCertificateAuthority(request: protos.google.cloud.security.privateca.v1.ICreateCertificateAuthorityRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createCertificateAuthority(request, callback)

createCertificateAuthority(request: protos.google.cloud.security.privateca.v1.ICreateCertificateAuthorityRequest, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createCertificateTemplate(request, options)

createCertificateTemplate(request?: protos.google.cloud.security.privateca.v1.ICreateCertificateTemplateRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.security.privateca.v1.ICertificateTemplate, protos.google.cloud.security.privateca.v1.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 resource name of the location associated with the
   *  CertificateTemplate google.cloud.security.privateca.v1.CertificateTemplate,
   *  in the format `projects/* /locations/*`.
   */
  // const parent = 'abc123'
  /**
   *  Required. It must be unique within a location and match the regular
   *  expression `[a-zA-Z0-9_-]{1,63}`
   */
  // const certificateTemplateId = 'abc123'
  /**
   *  Required. A
   *  CertificateTemplate google.cloud.security.privateca.v1.CertificateTemplate 
   *  with initial field values.
   */
  // const certificateTemplate = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callCreateCertificateTemplate() {
    // Construct request
    const request = {
      parent,
      certificateTemplateId,
      certificateTemplate,
    };

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

  callCreateCertificateTemplate();

createCertificateTemplate(request, options, callback)

createCertificateTemplate(request: protos.google.cloud.security.privateca.v1.ICreateCertificateTemplateRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateTemplate, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createCertificateTemplate(request, callback)

createCertificateTemplate(request: protos.google.cloud.security.privateca.v1.ICreateCertificateTemplateRequest, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateTemplate, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteCaPool(request, options)

deleteCaPool(request?: protos.google.cloud.security.privateca.v1.IDeleteCaPoolRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.security.privateca.v1.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 resource name for this
   *  CaPool google.cloud.security.privateca.v1.CaPool  in the format
   *  `projects/* /locations/* /caPools/*`.
   */
  // const name = 'abc123'
  /**
   *  Optional. An 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. This field allows this pool to be deleted even if it's being
   *  depended on by another resource. However, doing so may result in unintended
   *  and unrecoverable effects on any dependent resource(s) since the pool will
   *  no longer be able to issue certificates.
   */
  // const ignoreDependentResources = true

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callDeleteCaPool();

deleteCaPool(request, options, callback)

deleteCaPool(request: protos.google.cloud.security.privateca.v1.IDeleteCaPoolRequest, options: CallOptions, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteCaPool(request, callback)

deleteCaPool(request: protos.google.cloud.security.privateca.v1.IDeleteCaPoolRequest, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteCertificateAuthority(request, options)

deleteCertificateAuthority(request?: protos.google.cloud.security.privateca.v1.IDeleteCertificateAuthorityRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.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 resource name for this
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  in the format `projects/* /locations/* /caPools/* /certificateAuthorities/*`.
   */
  // const name = 'abc123'
  /**
   *  Optional. An 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. This field allows the CA to be deleted even if the CA has
   *  active certs. Active certs include both unrevoked and unexpired certs.
   */
  // const ignoreActiveCertificates = true
  /**
   *  Optional. If this flag is set, the Certificate Authority will be deleted as
   *  soon as possible without a 30-day grace period where undeletion would have
   *  been allowed. If you proceed, there will be no way to recover this CA.
   */
  // const skipGracePeriod = true
  /**
   *  Optional. This field allows this ca to be deleted even if it's being
   *  depended on by another resource. However, doing so may result in unintended
   *  and unrecoverable effects on any dependent resource(s) since the CA will
   *  no longer be able to issue certificates.
   */
  // const ignoreDependentResources = true

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callDeleteCertificateAuthority();

deleteCertificateAuthority(request, options, callback)

deleteCertificateAuthority(request: protos.google.cloud.security.privateca.v1.IDeleteCertificateAuthorityRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteCertificateAuthority(request, callback)

deleteCertificateAuthority(request: protos.google.cloud.security.privateca.v1.IDeleteCertificateAuthorityRequest, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteCertificateTemplate(request, options)

deleteCertificateTemplate(request?: protos.google.cloud.security.privateca.v1.IDeleteCertificateTemplateRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.security.privateca.v1.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 resource name for this
   *  CertificateTemplate google.cloud.security.privateca.v1.CertificateTemplate 
   *  in the format `projects/* /locations/* /certificateTemplates/*`.
   */
  // const name = 'abc123'
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callDeleteCertificateTemplate();

deleteCertificateTemplate(request, options, callback)

deleteCertificateTemplate(request: protos.google.cloud.security.privateca.v1.IDeleteCertificateTemplateRequest, options: CallOptions, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteCertificateTemplate(request, callback)

deleteCertificateTemplate(request: protos.google.cloud.security.privateca.v1.IDeleteCertificateTemplateRequest, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.security.privateca.v1.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: ''});

disableCertificateAuthority(request, options)

disableCertificateAuthority(request?: protos.google.cloud.security.privateca.v1.IDisableCertificateAuthorityRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.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 resource name for this
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  in the format `projects/* /locations/* /caPools/* /certificateAuthorities/*`.
   */
  // const name = 'abc123'
  /**
   *  Optional. An 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. This field allows this CA to be disabled even if it's being
   *  depended on by another resource. However, doing so may result in unintended
   *  and unrecoverable effects on any dependent resource(s) since the CA will
   *  no longer be able to issue certificates.
   */
  // const ignoreDependentResources = true

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callDisableCertificateAuthority();

disableCertificateAuthority(request, options, callback)

disableCertificateAuthority(request: protos.google.cloud.security.privateca.v1.IDisableCertificateAuthorityRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

disableCertificateAuthority(request, callback)

disableCertificateAuthority(request: protos.google.cloud.security.privateca.v1.IDisableCertificateAuthorityRequest, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

enableCertificateAuthority(request, options)

enableCertificateAuthority(request?: protos.google.cloud.security.privateca.v1.IEnableCertificateAuthorityRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.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 resource name for this
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  in the format `projects/* /locations/* /caPools/* /certificateAuthorities/*`.
   */
  // const name = 'abc123'
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callEnableCertificateAuthority();

enableCertificateAuthority(request, options, callback)

enableCertificateAuthority(request: protos.google.cloud.security.privateca.v1.IEnableCertificateAuthorityRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

enableCertificateAuthority(request, callback)

enableCertificateAuthority(request: protos.google.cloud.security.privateca.v1.IEnableCertificateAuthorityRequest, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

fetchCaCerts(request, options)

fetchCaCerts(request?: protos.google.cloud.security.privateca.v1.IFetchCaCertsRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.IFetchCaCertsResponse,
        (protos.google.cloud.security.privateca.v1.IFetchCaCertsRequest | 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 resource name for the
   *  CaPool google.cloud.security.privateca.v1.CaPool  in the format
   *  `projects/* /locations/* /caPools/*`.
   */
  // const caPool = 'abc123'
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callFetchCaCerts() {
    // Construct request
    const request = {
      caPool,
    };

    // Run request
    const response = await privatecaClient.fetchCaCerts(request);
    console.log(response);
  }

  callFetchCaCerts();

fetchCaCerts(request, options, callback)

fetchCaCerts(request: protos.google.cloud.security.privateca.v1.IFetchCaCertsRequest, options: CallOptions, callback: Callback<protos.google.cloud.security.privateca.v1.IFetchCaCertsResponse, protos.google.cloud.security.privateca.v1.IFetchCaCertsRequest | null | undefined, {} | null | undefined>): void;

fetchCaCerts(request, callback)

fetchCaCerts(request: protos.google.cloud.security.privateca.v1.IFetchCaCertsRequest, callback: Callback<protos.google.cloud.security.privateca.v1.IFetchCaCertsResponse, protos.google.cloud.security.privateca.v1.IFetchCaCertsRequest | null | undefined, {} | null | undefined>): void;

fetchCertificateAuthorityCsr(request, options)

fetchCertificateAuthorityCsr(request?: protos.google.cloud.security.privateca.v1.IFetchCertificateAuthorityCsrRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.IFetchCertificateAuthorityCsrResponse,
        (protos.google.cloud.security.privateca.v1.IFetchCertificateAuthorityCsrRequest | 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 resource name for this
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  in the format `projects/* /locations/* /caPools/* /certificateAuthorities/*`.
   */
  // const name = 'abc123'

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

    // Run request
    const response = await privatecaClient.fetchCertificateAuthorityCsr(request);
    console.log(response);
  }

  callFetchCertificateAuthorityCsr();

fetchCertificateAuthorityCsr(request, options, callback)

fetchCertificateAuthorityCsr(request: protos.google.cloud.security.privateca.v1.IFetchCertificateAuthorityCsrRequest, options: CallOptions, callback: Callback<protos.google.cloud.security.privateca.v1.IFetchCertificateAuthorityCsrResponse, protos.google.cloud.security.privateca.v1.IFetchCertificateAuthorityCsrRequest | null | undefined, {} | null | undefined>): void;

fetchCertificateAuthorityCsr(request, callback)

fetchCertificateAuthorityCsr(request: protos.google.cloud.security.privateca.v1.IFetchCertificateAuthorityCsrRequest, callback: Callback<protos.google.cloud.security.privateca.v1.IFetchCertificateAuthorityCsrResponse, protos.google.cloud.security.privateca.v1.IFetchCertificateAuthorityCsrRequest | null | undefined, {} | null | undefined>): void;

getCaPool(request, options)

getCaPool(request?: protos.google.cloud.security.privateca.v1.IGetCaPoolRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.ICaPool,
        protos.google.cloud.security.privateca.v1.IGetCaPoolRequest | 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 google.cloud.security.privateca.v1.CaPool.name  of the
   *  CaPool google.cloud.security.privateca.v1.CaPool  to get.
   */
  // const name = 'abc123'

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

    // Run request
    const response = await privatecaClient.getCaPool(request);
    console.log(response);
  }

  callGetCaPool();

getCaPool(request, options, callback)

getCaPool(request: protos.google.cloud.security.privateca.v1.IGetCaPoolRequest, options: CallOptions, callback: Callback<protos.google.cloud.security.privateca.v1.ICaPool, protos.google.cloud.security.privateca.v1.IGetCaPoolRequest | null | undefined, {} | null | undefined>): void;

getCaPool(request, callback)

getCaPool(request: protos.google.cloud.security.privateca.v1.IGetCaPoolRequest, callback: Callback<protos.google.cloud.security.privateca.v1.ICaPool, protos.google.cloud.security.privateca.v1.IGetCaPoolRequest | null | undefined, {} | null | undefined>): void;

getCertificate(request, options)

getCertificate(request?: protos.google.cloud.security.privateca.v1.IGetCertificateRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.ICertificate,
        (protos.google.cloud.security.privateca.v1.IGetCertificateRequest | 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 google.cloud.security.privateca.v1.Certificate.name 
   *  of the Certificate google.cloud.security.privateca.v1.Certificate  to
   *  get.
   */
  // const name = 'abc123'

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

    // Run request
    const response = await privatecaClient.getCertificate(request);
    console.log(response);
  }

  callGetCertificate();

getCertificate(request, options, callback)

getCertificate(request: protos.google.cloud.security.privateca.v1.IGetCertificateRequest, options: CallOptions, callback: Callback<protos.google.cloud.security.privateca.v1.ICertificate, protos.google.cloud.security.privateca.v1.IGetCertificateRequest | null | undefined, {} | null | undefined>): void;

getCertificate(request, callback)

getCertificate(request: protos.google.cloud.security.privateca.v1.IGetCertificateRequest, callback: Callback<protos.google.cloud.security.privateca.v1.ICertificate, protos.google.cloud.security.privateca.v1.IGetCertificateRequest | null | undefined, {} | null | undefined>): void;

getCertificateAuthority(request, options)

getCertificateAuthority(request?: protos.google.cloud.security.privateca.v1.IGetCertificateAuthorityRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.ICertificateAuthority,
        (protos.google.cloud.security.privateca.v1.IGetCertificateAuthorityRequest | 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 google.cloud.security.privateca.v1.CertificateAuthority.name  of the
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  to get.
   */
  // const name = 'abc123'

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

    // Run request
    const response = await privatecaClient.getCertificateAuthority(request);
    console.log(response);
  }

  callGetCertificateAuthority();

getCertificateAuthority(request, options, callback)

getCertificateAuthority(request: protos.google.cloud.security.privateca.v1.IGetCertificateAuthorityRequest, options: CallOptions, callback: Callback<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IGetCertificateAuthorityRequest | null | undefined, {} | null | undefined>): void;

getCertificateAuthority(request, callback)

getCertificateAuthority(request: protos.google.cloud.security.privateca.v1.IGetCertificateAuthorityRequest, callback: Callback<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IGetCertificateAuthorityRequest | null | undefined, {} | null | undefined>): void;

getCertificateRevocationList(request, options)

getCertificateRevocationList(request?: protos.google.cloud.security.privateca.v1.IGetCertificateRevocationListRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.ICertificateRevocationList,
        (protos.google.cloud.security.privateca.v1.IGetCertificateRevocationListRequest | 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 google.cloud.security.privateca.v1.CertificateRevocationList.name 
   *  of the
   *  CertificateRevocationList google.cloud.security.privateca.v1.CertificateRevocationList 
   *  to get.
   */
  // const name = 'abc123'

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

    // Run request
    const response = await privatecaClient.getCertificateRevocationList(request);
    console.log(response);
  }

  callGetCertificateRevocationList();

getCertificateRevocationList(request, options, callback)

getCertificateRevocationList(request: protos.google.cloud.security.privateca.v1.IGetCertificateRevocationListRequest, options: CallOptions, callback: Callback<protos.google.cloud.security.privateca.v1.ICertificateRevocationList, protos.google.cloud.security.privateca.v1.IGetCertificateRevocationListRequest | null | undefined, {} | null | undefined>): void;

getCertificateRevocationList(request, callback)

getCertificateRevocationList(request: protos.google.cloud.security.privateca.v1.IGetCertificateRevocationListRequest, callback: Callback<protos.google.cloud.security.privateca.v1.ICertificateRevocationList, protos.google.cloud.security.privateca.v1.IGetCertificateRevocationListRequest | null | undefined, {} | null | undefined>): void;

getCertificateTemplate(request, options)

getCertificateTemplate(request?: protos.google.cloud.security.privateca.v1.IGetCertificateTemplateRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.ICertificateTemplate,
        (protos.google.cloud.security.privateca.v1.IGetCertificateTemplateRequest | 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 google.cloud.security.privateca.v1.CertificateTemplate.name  of the
   *  CertificateTemplate google.cloud.security.privateca.v1.CertificateTemplate 
   *  to get.
   */
  // const name = 'abc123'

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

    // Run request
    const response = await privatecaClient.getCertificateTemplate(request);
    console.log(response);
  }

  callGetCertificateTemplate();

getCertificateTemplate(request, options, callback)

getCertificateTemplate(request: protos.google.cloud.security.privateca.v1.IGetCertificateTemplateRequest, options: CallOptions, callback: Callback<protos.google.cloud.security.privateca.v1.ICertificateTemplate, protos.google.cloud.security.privateca.v1.IGetCertificateTemplateRequest | null | undefined, {} | null | undefined>): void;

getCertificateTemplate(request, callback)

getCertificateTemplate(request: protos.google.cloud.security.privateca.v1.IGetCertificateTemplateRequest, callback: Callback<protos.google.cloud.security.privateca.v1.ICertificateTemplate, protos.google.cloud.security.privateca.v1.IGetCertificateTemplateRequest | 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]>;

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;

initialize()

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

listCaPools(request, options)

listCaPools(request?: protos.google.cloud.security.privateca.v1.IListCaPoolsRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.ICaPool[],
        protos.google.cloud.security.privateca.v1.IListCaPoolsRequest | null,
        protos.google.cloud.security.privateca.v1.IListCaPoolsResponse
    ]>;

listCaPools(request, options, callback)

listCaPools(request: protos.google.cloud.security.privateca.v1.IListCaPoolsRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.security.privateca.v1.IListCaPoolsRequest, protos.google.cloud.security.privateca.v1.IListCaPoolsResponse | null | undefined, protos.google.cloud.security.privateca.v1.ICaPool>): void;

listCaPools(request, callback)

listCaPools(request: protos.google.cloud.security.privateca.v1.IListCaPoolsRequest, callback: PaginationCallback<protos.google.cloud.security.privateca.v1.IListCaPoolsRequest, protos.google.cloud.security.privateca.v1.IListCaPoolsResponse | null | undefined, protos.google.cloud.security.privateca.v1.ICaPool>): void;

listCaPoolsAsync(request, options)

listCaPoolsAsync(request?: protos.google.cloud.security.privateca.v1.IListCaPoolsRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.security.privateca.v1.ICaPool>;

  /**
   * 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 location associated with the
   *  CaPools google.cloud.security.privateca.v1.CaPool, in the format
   *  `projects/* /locations/*`.
   */
  // const parent = 'abc123'
  /**
   *  Optional. Limit on the number of
   *  CaPools google.cloud.security.privateca.v1.CaPool  to include in the
   *  response. Further CaPools google.cloud.security.privateca.v1.CaPool  can
   *  subsequently be obtained by including the
   *  ListCaPoolsResponse.next_page_token google.cloud.security.privateca.v1.ListCaPoolsResponse.next_page_token 
   *  in a subsequent request. If unspecified, the server will pick an
   *  appropriate default.
   */
  // const pageSize = 1234
  /**
   *  Optional. Pagination token, returned earlier via
   *  ListCaPoolsResponse.next_page_token google.cloud.security.privateca.v1.ListCaPoolsResponse.next_page_token.
   */
  // const pageToken = 'abc123'
  /**
   *  Optional. Only include resources that match the filter in the response.
   */
  // const filter = 'abc123'
  /**
   *  Optional. Specify how the results should be sorted.
   */
  // const orderBy = 'abc123'

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callListCaPools();

listCaPoolsStream(request, options)

listCaPoolsStream(request?: protos.google.cloud.security.privateca.v1.IListCaPoolsRequest, options?: CallOptions): Transform;

listCertificateAuthorities(request, options)

listCertificateAuthorities(request?: protos.google.cloud.security.privateca.v1.IListCertificateAuthoritiesRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.ICertificateAuthority[],
        protos.google.cloud.security.privateca.v1.IListCertificateAuthoritiesRequest | null,
        protos.google.cloud.security.privateca.v1.IListCertificateAuthoritiesResponse
    ]>;

listCertificateAuthorities(request, options, callback)

listCertificateAuthorities(request: protos.google.cloud.security.privateca.v1.IListCertificateAuthoritiesRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.security.privateca.v1.IListCertificateAuthoritiesRequest, protos.google.cloud.security.privateca.v1.IListCertificateAuthoritiesResponse | null | undefined, protos.google.cloud.security.privateca.v1.ICertificateAuthority>): void;

listCertificateAuthorities(request, callback)

listCertificateAuthorities(request: protos.google.cloud.security.privateca.v1.IListCertificateAuthoritiesRequest, callback: PaginationCallback<protos.google.cloud.security.privateca.v1.IListCertificateAuthoritiesRequest, protos.google.cloud.security.privateca.v1.IListCertificateAuthoritiesResponse | null | undefined, protos.google.cloud.security.privateca.v1.ICertificateAuthority>): void;

listCertificateAuthoritiesAsync(request, options)

listCertificateAuthoritiesAsync(request?: protos.google.cloud.security.privateca.v1.IListCertificateAuthoritiesRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.security.privateca.v1.ICertificateAuthority>;

  /**
   * 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
   *  CaPool google.cloud.security.privateca.v1.CaPool  associated with the
   *  CertificateAuthorities google.cloud.security.privateca.v1.CertificateAuthority,
   *  in the format `projects/* /locations/* /caPools/*`.
   */
  // const parent = 'abc123'
  /**
   *  Optional. Limit on the number of
   *  CertificateAuthorities google.cloud.security.privateca.v1.CertificateAuthority 
   *  to include in the response. Further
   *  CertificateAuthorities google.cloud.security.privateca.v1.CertificateAuthority 
   *  can subsequently be obtained by including the
   *  ListCertificateAuthoritiesResponse.next_page_token google.cloud.security.privateca.v1.ListCertificateAuthoritiesResponse.next_page_token 
   *  in a subsequent request. If unspecified, the server will pick an
   *  appropriate default.
   */
  // const pageSize = 1234
  /**
   *  Optional. Pagination token, returned earlier via
   *  ListCertificateAuthoritiesResponse.next_page_token google.cloud.security.privateca.v1.ListCertificateAuthoritiesResponse.next_page_token.
   */
  // const pageToken = 'abc123'
  /**
   *  Optional. Only include resources that match the filter in the response.
   */
  // const filter = 'abc123'
  /**
   *  Optional. Specify how the results should be sorted.
   */
  // const orderBy = 'abc123'

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callListCertificateAuthorities();

listCertificateAuthoritiesStream(request, options)

listCertificateAuthoritiesStream(request?: protos.google.cloud.security.privateca.v1.IListCertificateAuthoritiesRequest, options?: CallOptions): Transform;

listCertificateRevocationLists(request, options)

listCertificateRevocationLists(request?: protos.google.cloud.security.privateca.v1.IListCertificateRevocationListsRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.ICertificateRevocationList[],
        protos.google.cloud.security.privateca.v1.IListCertificateRevocationListsRequest | null,
        protos.google.cloud.security.privateca.v1.IListCertificateRevocationListsResponse
    ]>;

listCertificateRevocationLists(request, options, callback)

listCertificateRevocationLists(request: protos.google.cloud.security.privateca.v1.IListCertificateRevocationListsRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.security.privateca.v1.IListCertificateRevocationListsRequest, protos.google.cloud.security.privateca.v1.IListCertificateRevocationListsResponse | null | undefined, protos.google.cloud.security.privateca.v1.ICertificateRevocationList>): void;

listCertificateRevocationLists(request, callback)

listCertificateRevocationLists(request: protos.google.cloud.security.privateca.v1.IListCertificateRevocationListsRequest, callback: PaginationCallback<protos.google.cloud.security.privateca.v1.IListCertificateRevocationListsRequest, protos.google.cloud.security.privateca.v1.IListCertificateRevocationListsResponse | null | undefined, protos.google.cloud.security.privateca.v1.ICertificateRevocationList>): void;

listCertificateRevocationListsAsync(request, options)

listCertificateRevocationListsAsync(request?: protos.google.cloud.security.privateca.v1.IListCertificateRevocationListsRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.security.privateca.v1.ICertificateRevocationList>;

  /**
   * 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 location associated with the
   *  CertificateRevocationLists google.cloud.security.privateca.v1.CertificateRevocationList,
   *  in the format `projects/* /locations/* /caPools/* /certificateAuthorities/*`.
   */
  // const parent = 'abc123'
  /**
   *  Optional. Limit on the number of
   *  CertificateRevocationLists google.cloud.security.privateca.v1.CertificateRevocationList 
   *  to include in the response. Further
   *  CertificateRevocationLists google.cloud.security.privateca.v1.CertificateRevocationList 
   *  can subsequently be obtained by including the
   *  ListCertificateRevocationListsResponse.next_page_token google.cloud.security.privateca.v1.ListCertificateRevocationListsResponse.next_page_token 
   *  in a subsequent request. If unspecified, the server will pick an
   *  appropriate default.
   */
  // const pageSize = 1234
  /**
   *  Optional. Pagination token, returned earlier via
   *  ListCertificateRevocationListsResponse.next_page_token google.cloud.security.privateca.v1.ListCertificateRevocationListsResponse.next_page_token.
   */
  // const pageToken = 'abc123'
  /**
   *  Optional. Only include resources that match the filter in the response.
   */
  // const filter = 'abc123'
  /**
   *  Optional. Specify how the results should be sorted.
   */
  // const orderBy = 'abc123'

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callListCertificateRevocationLists();

listCertificateRevocationListsStream(request, options)

listCertificateRevocationListsStream(request?: protos.google.cloud.security.privateca.v1.IListCertificateRevocationListsRequest, options?: CallOptions): Transform;

listCertificates(request, options)

listCertificates(request?: protos.google.cloud.security.privateca.v1.IListCertificatesRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.ICertificate[],
        protos.google.cloud.security.privateca.v1.IListCertificatesRequest | null,
        protos.google.cloud.security.privateca.v1.IListCertificatesResponse
    ]>;

listCertificates(request, options, callback)

listCertificates(request: protos.google.cloud.security.privateca.v1.IListCertificatesRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.security.privateca.v1.IListCertificatesRequest, protos.google.cloud.security.privateca.v1.IListCertificatesResponse | null | undefined, protos.google.cloud.security.privateca.v1.ICertificate>): void;

listCertificates(request, callback)

listCertificates(request: protos.google.cloud.security.privateca.v1.IListCertificatesRequest, callback: PaginationCallback<protos.google.cloud.security.privateca.v1.IListCertificatesRequest, protos.google.cloud.security.privateca.v1.IListCertificatesResponse | null | undefined, protos.google.cloud.security.privateca.v1.ICertificate>): void;

listCertificatesAsync(request, options)

listCertificatesAsync(request?: protos.google.cloud.security.privateca.v1.IListCertificatesRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.security.privateca.v1.ICertificate>;

  /**
   * 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 location associated with the
   *  Certificates google.cloud.security.privateca.v1.Certificate, in the
   *  format `projects/* /locations/* /caPools/*`.
   */
  // const parent = 'abc123'
  /**
   *  Optional. Limit on the number of
   *  Certificates google.cloud.security.privateca.v1.Certificate  to include
   *  in the response. Further
   *  Certificates google.cloud.security.privateca.v1.Certificate  can
   *  subsequently be obtained by including the
   *  ListCertificatesResponse.next_page_token google.cloud.security.privateca.v1.ListCertificatesResponse.next_page_token 
   *  in a subsequent request. If unspecified, the server will pick an
   *  appropriate default.
   */
  // const pageSize = 1234
  /**
   *  Optional. Pagination token, returned earlier via
   *  ListCertificatesResponse.next_page_token google.cloud.security.privateca.v1.ListCertificatesResponse.next_page_token.
   */
  // const pageToken = 'abc123'
  /**
   *  Optional. Only include resources that match the filter in the response. For
   *  details on supported filters and syntax, see Certificates Filtering
   *  documentation (https://cloud.google.com/certificate-authority-service/docs/sorting-filtering-certificates#filtering_support).
   */
  // const filter = 'abc123'
  /**
   *  Optional. Specify how the results should be sorted. For details on
   *  supported fields and syntax, see Certificates Sorting
   *  documentation (https://cloud.google.com/certificate-authority-service/docs/sorting-filtering-certificates#sorting_support).
   */
  // const orderBy = 'abc123'

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callListCertificates();

listCertificatesStream(request, options)

listCertificatesStream(request?: protos.google.cloud.security.privateca.v1.IListCertificatesRequest, options?: CallOptions): Transform;

listCertificateTemplates(request, options)

listCertificateTemplates(request?: protos.google.cloud.security.privateca.v1.IListCertificateTemplatesRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.ICertificateTemplate[],
        protos.google.cloud.security.privateca.v1.IListCertificateTemplatesRequest | null,
        protos.google.cloud.security.privateca.v1.IListCertificateTemplatesResponse
    ]>;

listCertificateTemplates(request, options, callback)

listCertificateTemplates(request: protos.google.cloud.security.privateca.v1.IListCertificateTemplatesRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.security.privateca.v1.IListCertificateTemplatesRequest, protos.google.cloud.security.privateca.v1.IListCertificateTemplatesResponse | null | undefined, protos.google.cloud.security.privateca.v1.ICertificateTemplate>): void;

listCertificateTemplates(request, callback)

listCertificateTemplates(request: protos.google.cloud.security.privateca.v1.IListCertificateTemplatesRequest, callback: PaginationCallback<protos.google.cloud.security.privateca.v1.IListCertificateTemplatesRequest, protos.google.cloud.security.privateca.v1.IListCertificateTemplatesResponse | null | undefined, protos.google.cloud.security.privateca.v1.ICertificateTemplate>): void;

listCertificateTemplatesAsync(request, options)

listCertificateTemplatesAsync(request?: protos.google.cloud.security.privateca.v1.IListCertificateTemplatesRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.security.privateca.v1.ICertificateTemplate>;

  /**
   * 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 location associated with the
   *  CertificateTemplates google.cloud.security.privateca.v1.CertificateTemplate,
   *  in the format `projects/* /locations/*`.
   */
  // const parent = 'abc123'
  /**
   *  Optional. Limit on the number of
   *  CertificateTemplates google.cloud.security.privateca.v1.CertificateTemplate 
   *  to include in the response. Further
   *  CertificateTemplates google.cloud.security.privateca.v1.CertificateTemplate 
   *  can subsequently be obtained by including the
   *  ListCertificateTemplatesResponse.next_page_token google.cloud.security.privateca.v1.ListCertificateTemplatesResponse.next_page_token 
   *  in a subsequent request. If unspecified, the server will pick an
   *  appropriate default.
   */
  // const pageSize = 1234
  /**
   *  Optional. Pagination token, returned earlier via
   *  ListCertificateTemplatesResponse.next_page_token google.cloud.security.privateca.v1.ListCertificateTemplatesResponse.next_page_token.
   */
  // const pageToken = 'abc123'
  /**
   *  Optional. Only include resources that match the filter in the response.
   */
  // const filter = 'abc123'
  /**
   *  Optional. Specify how the results should be sorted.
   */
  // const orderBy = 'abc123'

  // Imports the Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callListCertificateTemplates();

listCertificateTemplatesStream(request, options)

listCertificateTemplatesStream(request?: protos.google.cloud.security.privateca.v1.IListCertificateTemplatesRequest, 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)

locationPath(project, location)

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

matchCaPoolFromCaPoolName(caPoolName)

matchCaPoolFromCaPoolName(caPoolName: string): string | number;

matchCaPoolFromCertificateAuthorityName(certificateAuthorityName)

matchCaPoolFromCertificateAuthorityName(certificateAuthorityName: string): string | number;

matchCaPoolFromCertificateName(certificateName)

matchCaPoolFromCertificateName(certificateName: string): string | number;

matchCaPoolFromCertificateRevocationListName(certificateRevocationListName)

matchCaPoolFromCertificateRevocationListName(certificateRevocationListName: string): string | number;

matchCertificateAuthorityFromCertificateAuthorityName(certificateAuthorityName)

matchCertificateAuthorityFromCertificateAuthorityName(certificateAuthorityName: string): string | number;

matchCertificateAuthorityFromCertificateRevocationListName(certificateRevocationListName)

matchCertificateAuthorityFromCertificateRevocationListName(certificateRevocationListName: string): string | number;

matchCertificateFromCertificateName(certificateName)

matchCertificateFromCertificateName(certificateName: string): string | number;

matchCertificateRevocationListFromCertificateRevocationListName(certificateRevocationListName)

matchCertificateRevocationListFromCertificateRevocationListName(certificateRevocationListName: string): string | number;

matchCertificateTemplateFromCertificateTemplateName(certificateTemplateName)

matchCertificateTemplateFromCertificateTemplateName(certificateTemplateName: string): string | number;

matchLocationFromCaPoolName(caPoolName)

matchLocationFromCaPoolName(caPoolName: string): string | number;

matchLocationFromCertificateAuthorityName(certificateAuthorityName)

matchLocationFromCertificateAuthorityName(certificateAuthorityName: string): string | number;

matchLocationFromCertificateName(certificateName)

matchLocationFromCertificateName(certificateName: string): string | number;

matchLocationFromCertificateRevocationListName(certificateRevocationListName)

matchLocationFromCertificateRevocationListName(certificateRevocationListName: string): string | number;

matchLocationFromCertificateTemplateName(certificateTemplateName)

matchLocationFromCertificateTemplateName(certificateTemplateName: string): string | number;

matchLocationFromLocationName(locationName)

matchLocationFromLocationName(locationName: string): string | number;

matchProjectFromCaPoolName(caPoolName)

matchProjectFromCaPoolName(caPoolName: string): string | number;

matchProjectFromCertificateAuthorityName(certificateAuthorityName)

matchProjectFromCertificateAuthorityName(certificateAuthorityName: string): string | number;

matchProjectFromCertificateName(certificateName)

matchProjectFromCertificateName(certificateName: string): string | number;

matchProjectFromCertificateRevocationListName(certificateRevocationListName)

matchProjectFromCertificateRevocationListName(certificateRevocationListName: string): string | number;

matchProjectFromCertificateTemplateName(certificateTemplateName)

matchProjectFromCertificateTemplateName(certificateTemplateName: string): string | number;

matchProjectFromLocationName(locationName)

matchProjectFromLocationName(locationName: string): string | number;

revokeCertificate(request, options)

revokeCertificate(request?: protos.google.cloud.security.privateca.v1.IRevokeCertificateRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.ICertificate,
        (protos.google.cloud.security.privateca.v1.IRevokeCertificateRequest | 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 resource name for this
   *  Certificate google.cloud.security.privateca.v1.Certificate  in the format
   *  `projects/* /locations/* /caPools/* /certificates/*`.
   */
  // const name = 'abc123'
  /**
   *  Required. The
   *  RevocationReason google.cloud.security.privateca.v1.RevocationReason  for
   *  revoking this certificate.
   */
  // const reason = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

    // Run request
    const response = await privatecaClient.revokeCertificate(request);
    console.log(response);
  }

  callRevokeCertificate();

revokeCertificate(request, options, callback)

revokeCertificate(request: protos.google.cloud.security.privateca.v1.IRevokeCertificateRequest, options: CallOptions, callback: Callback<protos.google.cloud.security.privateca.v1.ICertificate, protos.google.cloud.security.privateca.v1.IRevokeCertificateRequest | null | undefined, {} | null | undefined>): void;

revokeCertificate(request, callback)

revokeCertificate(request: protos.google.cloud.security.privateca.v1.IRevokeCertificateRequest, callback: Callback<protos.google.cloud.security.privateca.v1.ICertificate, protos.google.cloud.security.privateca.v1.IRevokeCertificateRequest | null | undefined, {} | null | undefined>): void;

setIamPolicy(request, options, callback)

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

testIamPermissions(request, options, callback)

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

undeleteCertificateAuthority(request, options)

undeleteCertificateAuthority(request?: protos.google.cloud.security.privateca.v1.IUndeleteCertificateAuthorityRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.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 resource name for this
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  in the format `projects/* /locations/* /caPools/* /certificateAuthorities/*`.
   */
  // const name = 'abc123'
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

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

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

  callUndeleteCertificateAuthority();

undeleteCertificateAuthority(request, options, callback)

undeleteCertificateAuthority(request: protos.google.cloud.security.privateca.v1.IUndeleteCertificateAuthorityRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

undeleteCertificateAuthority(request, callback)

undeleteCertificateAuthority(request: protos.google.cloud.security.privateca.v1.IUndeleteCertificateAuthorityRequest, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

updateCaPool(request, options)

updateCaPool(request?: protos.google.cloud.security.privateca.v1.IUpdateCaPoolRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.security.privateca.v1.ICaPool, protos.google.cloud.security.privateca.v1.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. CaPool google.cloud.security.privateca.v1.CaPool  with updated
   *  values.
   */
  // const caPool = {}
  /**
   *  Required. A list of fields to be updated in this request.
   */
  // const updateMask = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callUpdateCaPool() {
    // Construct request
    const request = {
      caPool,
      updateMask,
    };

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

  callUpdateCaPool();

updateCaPool(request, options, callback)

updateCaPool(request: protos.google.cloud.security.privateca.v1.IUpdateCaPoolRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICaPool, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

updateCaPool(request, callback)

updateCaPool(request: protos.google.cloud.security.privateca.v1.IUpdateCaPoolRequest, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICaPool, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

updateCertificate(request, options)

updateCertificate(request?: protos.google.cloud.security.privateca.v1.IUpdateCertificateRequest, options?: CallOptions): Promise<[
        protos.google.cloud.security.privateca.v1.ICertificate,
        (protos.google.cloud.security.privateca.v1.IUpdateCertificateRequest | 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. Certificate google.cloud.security.privateca.v1.Certificate 
   *  with updated values.
   */
  // const certificate = {}
  /**
   *  Required. A list of fields to be updated in this request.
   */
  // const updateMask = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callUpdateCertificate() {
    // Construct request
    const request = {
      certificate,
      updateMask,
    };

    // Run request
    const response = await privatecaClient.updateCertificate(request);
    console.log(response);
  }

  callUpdateCertificate();

updateCertificate(request, options, callback)

updateCertificate(request: protos.google.cloud.security.privateca.v1.IUpdateCertificateRequest, options: CallOptions, callback: Callback<protos.google.cloud.security.privateca.v1.ICertificate, protos.google.cloud.security.privateca.v1.IUpdateCertificateRequest | null | undefined, {} | null | undefined>): void;

updateCertificate(request, callback)

updateCertificate(request: protos.google.cloud.security.privateca.v1.IUpdateCertificateRequest, callback: Callback<protos.google.cloud.security.privateca.v1.ICertificate, protos.google.cloud.security.privateca.v1.IUpdateCertificateRequest | null | undefined, {} | null | undefined>): void;

updateCertificateAuthority(request, options)

updateCertificateAuthority(request?: protos.google.cloud.security.privateca.v1.IUpdateCertificateAuthorityRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.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.
   *  CertificateAuthority google.cloud.security.privateca.v1.CertificateAuthority 
   *  with updated values.
   */
  // const certificateAuthority = {}
  /**
   *  Required. A list of fields to be updated in this request.
   */
  // const updateMask = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callUpdateCertificateAuthority() {
    // Construct request
    const request = {
      certificateAuthority,
      updateMask,
    };

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

  callUpdateCertificateAuthority();

updateCertificateAuthority(request, options, callback)

updateCertificateAuthority(request: protos.google.cloud.security.privateca.v1.IUpdateCertificateAuthorityRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

updateCertificateAuthority(request, callback)

updateCertificateAuthority(request: protos.google.cloud.security.privateca.v1.IUpdateCertificateAuthorityRequest, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateAuthority, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

updateCertificateRevocationList(request, options)

updateCertificateRevocationList(request?: protos.google.cloud.security.privateca.v1.IUpdateCertificateRevocationListRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.security.privateca.v1.ICertificateRevocationList, protos.google.cloud.security.privateca.v1.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.
   *  CertificateRevocationList google.cloud.security.privateca.v1.CertificateRevocationList 
   *  with updated values.
   */
  // const certificateRevocationList = {}
  /**
   *  Required. A list of fields to be updated in this request.
   */
  // const updateMask = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callUpdateCertificateRevocationList() {
    // Construct request
    const request = {
      certificateRevocationList,
      updateMask,
    };

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

  callUpdateCertificateRevocationList();

updateCertificateRevocationList(request, options, callback)

updateCertificateRevocationList(request: protos.google.cloud.security.privateca.v1.IUpdateCertificateRevocationListRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateRevocationList, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

updateCertificateRevocationList(request, callback)

updateCertificateRevocationList(request: protos.google.cloud.security.privateca.v1.IUpdateCertificateRevocationListRequest, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateRevocationList, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

updateCertificateTemplate(request, options)

updateCertificateTemplate(request?: protos.google.cloud.security.privateca.v1.IUpdateCertificateTemplateRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.security.privateca.v1.ICertificateTemplate, protos.google.cloud.security.privateca.v1.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.
   *  CertificateTemplate google.cloud.security.privateca.v1.CertificateTemplate 
   *  with updated values.
   */
  // const certificateTemplate = {}
  /**
   *  Required. A list of fields to be updated in this request.
   */
  // const updateMask = {}
  /**
   *  Optional. An 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 Privateca library
  const {CertificateAuthorityServiceClient} = require('@google-cloud/security-private-ca').v1;

  // Instantiates a client
  const privatecaClient = new CertificateAuthorityServiceClient();

  async function callUpdateCertificateTemplate() {
    // Construct request
    const request = {
      certificateTemplate,
      updateMask,
    };

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

  callUpdateCertificateTemplate();

updateCertificateTemplate(request, options, callback)

updateCertificateTemplate(request: protos.google.cloud.security.privateca.v1.IUpdateCertificateTemplateRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateTemplate, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

updateCertificateTemplate(request, callback)

updateCertificateTemplate(request: protos.google.cloud.security.privateca.v1.IUpdateCertificateTemplateRequest, callback: Callback<LROperation<protos.google.cloud.security.privateca.v1.ICertificateTemplate, protos.google.cloud.security.privateca.v1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;