Class v1alpha1.DatastreamClient (3.1.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;

datastreamStub

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

descriptors

descriptors: Descriptors;

innerApiCalls

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

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

checkCreateConnectionProfileProgress(name)

checkCreateConnectionProfileProgress(name: string): Promise<LROperation<protos.google.cloud.datastream.v1alpha1.ConnectionProfile, protos.google.cloud.datastream.v1alpha1.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 parent that owns the collection of ConnectionProfiles.
   */
  // const parent = 'abc123'
  /**
   *  Required. The connection profile identifier.
   */
  // const connectionProfileId = 'abc123'
  /**
   *  Required. The connection profile resource to create.
   */
  // const connectionProfile = {}
  /**
   *  Optional. A request ID to identify requests. Specify a unique request ID
   *  so that if you must retry your request, the server will know to ignore
   *  the request if it has already been completed. The server will guarantee
   *  that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and the
   *  request times out. If you make the request again with the same request ID,
   *  the server can check if original operation with the same request ID was
   *  received, and if so, will ignore the second request. This prevents clients
   *  from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

  async function callCreateConnectionProfile() {
    // Construct request
    const request = {
      parent,
      connectionProfileId,
      connectionProfile,
    };

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

  callCreateConnectionProfile();

checkCreatePrivateConnectionProgress(name)

checkCreatePrivateConnectionProgress(name: string): Promise<LROperation<protos.google.cloud.datastream.v1alpha1.PrivateConnection, protos.google.cloud.datastream.v1alpha1.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 parent that owns the collection of PrivateConnections.
   */
  // const parent = 'abc123'
  /**
   *  Required. The private connectivity identifier.
   */
  // const privateConnectionId = 'abc123'
  /**
   *  Required. The Private Connectivity resource to create.
   */
  // const privateConnection = {}
  /**
   *  Optional. A request ID to identify requests. Specify a unique request ID
   *  so that if you must retry your request, the server will know to ignore
   *  the request if it has already been completed. The server will guarantee
   *  that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and the
   *  request times out. If you make the request again with the same request ID,
   *  the server can check if original operation with the same request ID was
   *  received, and if so, will ignore the second request. This prevents clients
   *  from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

  async function callCreatePrivateConnection() {
    // Construct request
    const request = {
      parent,
      privateConnectionId,
      privateConnection,
    };

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

  callCreatePrivateConnection();

checkCreateRouteProgress(name)

checkCreateRouteProgress(name: string): Promise<LROperation<protos.google.cloud.datastream.v1alpha1.Route, protos.google.cloud.datastream.v1alpha1.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 parent that owns the collection of Routes.
   */
  // const parent = 'abc123'
  /**
   *  Required. The Route identifier.
   */
  // const routeId = 'abc123'
  /**
   *  Required. The Route resource to create.
   */
  // const route = {}
  /**
   *  Optional. A request ID to identify requests. Specify a unique request ID
   *  so that if you must retry your request, the server will know to ignore
   *  the request if it has already been completed. The server will guarantee
   *  that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and the
   *  request times out. If you make the request again with the same request ID,
   *  the server can check if original operation with the same request ID was
   *  received, and if so, will ignore the second request. This prevents clients
   *  from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

  async function callCreateRoute() {
    // Construct request
    const request = {
      parent,
      routeId,
      route,
    };

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

  callCreateRoute();

checkCreateStreamProgress(name)

checkCreateStreamProgress(name: string): Promise<LROperation<protos.google.cloud.datastream.v1alpha1.Stream, protos.google.cloud.datastream.v1alpha1.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 parent that owns the collection of streams.
   */
  // const parent = 'abc123'
  /**
   *  Required. The stream identifier.
   */
  // const streamId = 'abc123'
  /**
   *  Required. The stream resource to create.
   */
  // const stream = {}
  /**
   *  Optional. A request ID to identify requests. Specify a unique request ID
   *  so that if you must retry your request, the server will know to ignore
   *  the request if it has already been completed. The server will guarantee
   *  that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and the
   *  request times out. If you make the request again with the same request ID,
   *  the server can check if original operation with the same request ID was
   *  received, and if so, will ignore the second request. This prevents clients
   *  from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. Only validate the stream, but do not create any resources.
   *  The default is false.
   */
  // const validateOnly = true
  /**
   *  Optional. Create the stream without validating it.
   */
  // const force = true

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

  async function callCreateStream() {
    // Construct request
    const request = {
      parent,
      streamId,
      stream,
    };

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

  callCreateStream();

checkDeleteConnectionProfileProgress(name)

checkDeleteConnectionProfileProgress(name: string): Promise<LROperation<protos.google.protobuf.Empty, protos.google.cloud.datastream.v1alpha1.OperationMetadata>>;

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

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

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

  callDeleteConnectionProfile();

checkDeletePrivateConnectionProgress(name)

checkDeletePrivateConnectionProgress(name: string): Promise<LROperation<protos.google.protobuf.Empty, protos.google.cloud.datastream.v1alpha1.OperationMetadata>>;

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

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

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

  callDeletePrivateConnection();

checkDeleteRouteProgress(name)

checkDeleteRouteProgress(name: string): Promise<LROperation<protos.google.protobuf.Empty, protos.google.cloud.datastream.v1alpha1.OperationMetadata>>;

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

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

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

  callDeleteRoute();

checkDeleteStreamProgress(name)

checkDeleteStreamProgress(name: string): Promise<LROperation<protos.google.protobuf.Empty, protos.google.cloud.datastream.v1alpha1.OperationMetadata>>;

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

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

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

  callDeleteStream();

checkFetchErrorsProgress(name)

checkFetchErrorsProgress(name: string): Promise<LROperation<protos.google.cloud.datastream.v1alpha1.FetchErrorsResponse, protos.google.cloud.datastream.v1alpha1.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.
   */
  /**
   *  Name of the Stream resource for which to fetch any errors.
   */
  // const stream = 'abc123'

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

  async function callFetchErrors() {
    // Construct request
    const request = {
    };

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

  callFetchErrors();

checkUpdateConnectionProfileProgress(name)

checkUpdateConnectionProfileProgress(name: string): Promise<LROperation<protos.google.cloud.datastream.v1alpha1.ConnectionProfile, protos.google.cloud.datastream.v1alpha1.OperationMetadata>>;

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

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

  async function callUpdateConnectionProfile() {
    // Construct request
    const request = {
      connectionProfile,
    };

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

  callUpdateConnectionProfile();

checkUpdateStreamProgress(name)

checkUpdateStreamProgress(name: string): Promise<LROperation<protos.google.cloud.datastream.v1alpha1.Stream, protos.google.cloud.datastream.v1alpha1.OperationMetadata>>;

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

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

  async function callUpdateStream() {
    // Construct request
    const request = {
      stream,
    };

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

  callUpdateStream();

close()

close(): Promise<void>;

connectionProfilePath(project, location, connectionProfile)

connectionProfilePath(project: string, location: string, connectionProfile: string): string;

createConnectionProfile(request, options)

createConnectionProfile(request?: protos.google.cloud.datastream.v1alpha1.ICreateConnectionProfileRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.datastream.v1alpha1.IConnectionProfile, protos.google.cloud.datastream.v1alpha1.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 parent that owns the collection of ConnectionProfiles.
   */
  // const parent = 'abc123'
  /**
   *  Required. The connection profile identifier.
   */
  // const connectionProfileId = 'abc123'
  /**
   *  Required. The connection profile resource to create.
   */
  // const connectionProfile = {}
  /**
   *  Optional. A request ID to identify requests. Specify a unique request ID
   *  so that if you must retry your request, the server will know to ignore
   *  the request if it has already been completed. The server will guarantee
   *  that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and the
   *  request times out. If you make the request again with the same request ID,
   *  the server can check if original operation with the same request ID was
   *  received, and if so, will ignore the second request. This prevents clients
   *  from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

  async function callCreateConnectionProfile() {
    // Construct request
    const request = {
      parent,
      connectionProfileId,
      connectionProfile,
    };

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

  callCreateConnectionProfile();

createConnectionProfile(request, options, callback)

createConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.ICreateConnectionProfileRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.datastream.v1alpha1.IConnectionProfile, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createConnectionProfile(request, callback)

createConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.ICreateConnectionProfileRequest, callback: Callback<LROperation<protos.google.cloud.datastream.v1alpha1.IConnectionProfile, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createPrivateConnection(request, options)

createPrivateConnection(request?: protos.google.cloud.datastream.v1alpha1.ICreatePrivateConnectionRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.datastream.v1alpha1.IPrivateConnection, protos.google.cloud.datastream.v1alpha1.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 parent that owns the collection of PrivateConnections.
   */
  // const parent = 'abc123'
  /**
   *  Required. The private connectivity identifier.
   */
  // const privateConnectionId = 'abc123'
  /**
   *  Required. The Private Connectivity resource to create.
   */
  // const privateConnection = {}
  /**
   *  Optional. A request ID to identify requests. Specify a unique request ID
   *  so that if you must retry your request, the server will know to ignore
   *  the request if it has already been completed. The server will guarantee
   *  that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and the
   *  request times out. If you make the request again with the same request ID,
   *  the server can check if original operation with the same request ID was
   *  received, and if so, will ignore the second request. This prevents clients
   *  from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

  async function callCreatePrivateConnection() {
    // Construct request
    const request = {
      parent,
      privateConnectionId,
      privateConnection,
    };

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

  callCreatePrivateConnection();

createPrivateConnection(request, options, callback)

createPrivateConnection(request: protos.google.cloud.datastream.v1alpha1.ICreatePrivateConnectionRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.datastream.v1alpha1.IPrivateConnection, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createPrivateConnection(request, callback)

createPrivateConnection(request: protos.google.cloud.datastream.v1alpha1.ICreatePrivateConnectionRequest, callback: Callback<LROperation<protos.google.cloud.datastream.v1alpha1.IPrivateConnection, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createRoute(request, options)

createRoute(request?: protos.google.cloud.datastream.v1alpha1.ICreateRouteRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.datastream.v1alpha1.IRoute, protos.google.cloud.datastream.v1alpha1.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 parent that owns the collection of Routes.
   */
  // const parent = 'abc123'
  /**
   *  Required. The Route identifier.
   */
  // const routeId = 'abc123'
  /**
   *  Required. The Route resource to create.
   */
  // const route = {}
  /**
   *  Optional. A request ID to identify requests. Specify a unique request ID
   *  so that if you must retry your request, the server will know to ignore
   *  the request if it has already been completed. The server will guarantee
   *  that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and the
   *  request times out. If you make the request again with the same request ID,
   *  the server can check if original operation with the same request ID was
   *  received, and if so, will ignore the second request. This prevents clients
   *  from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

  async function callCreateRoute() {
    // Construct request
    const request = {
      parent,
      routeId,
      route,
    };

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

  callCreateRoute();

createRoute(request, options, callback)

createRoute(request: protos.google.cloud.datastream.v1alpha1.ICreateRouteRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.datastream.v1alpha1.IRoute, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createRoute(request, callback)

createRoute(request: protos.google.cloud.datastream.v1alpha1.ICreateRouteRequest, callback: Callback<LROperation<protos.google.cloud.datastream.v1alpha1.IRoute, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createStream(request, options)

createStream(request?: protos.google.cloud.datastream.v1alpha1.ICreateStreamRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.datastream.v1alpha1.IStream, protos.google.cloud.datastream.v1alpha1.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 parent that owns the collection of streams.
   */
  // const parent = 'abc123'
  /**
   *  Required. The stream identifier.
   */
  // const streamId = 'abc123'
  /**
   *  Required. The stream resource to create.
   */
  // const stream = {}
  /**
   *  Optional. A request ID to identify requests. Specify a unique request ID
   *  so that if you must retry your request, the server will know to ignore
   *  the request if it has already been completed. The server will guarantee
   *  that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and the
   *  request times out. If you make the request again with the same request ID,
   *  the server can check if original operation with the same request ID was
   *  received, and if so, will ignore the second request. This prevents clients
   *  from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. Only validate the stream, but do not create any resources.
   *  The default is false.
   */
  // const validateOnly = true
  /**
   *  Optional. Create the stream without validating it.
   */
  // const force = true

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

  async function callCreateStream() {
    // Construct request
    const request = {
      parent,
      streamId,
      stream,
    };

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

  callCreateStream();

createStream(request, options, callback)

createStream(request: protos.google.cloud.datastream.v1alpha1.ICreateStreamRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.datastream.v1alpha1.IStream, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

createStream(request, callback)

createStream(request: protos.google.cloud.datastream.v1alpha1.ICreateStreamRequest, callback: Callback<LROperation<protos.google.cloud.datastream.v1alpha1.IStream, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteConnectionProfile(request, options)

deleteConnectionProfile(request?: protos.google.cloud.datastream.v1alpha1.IDeleteConnectionProfileRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

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

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

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

  callDeleteConnectionProfile();

deleteConnectionProfile(request, options, callback)

deleteConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IDeleteConnectionProfileRequest, options: CallOptions, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteConnectionProfile(request, callback)

deleteConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IDeleteConnectionProfileRequest, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deletePrivateConnection(request, options)

deletePrivateConnection(request?: protos.google.cloud.datastream.v1alpha1.IDeletePrivateConnectionRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

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

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

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

  callDeletePrivateConnection();

deletePrivateConnection(request, options, callback)

deletePrivateConnection(request: protos.google.cloud.datastream.v1alpha1.IDeletePrivateConnectionRequest, options: CallOptions, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deletePrivateConnection(request, callback)

deletePrivateConnection(request: protos.google.cloud.datastream.v1alpha1.IDeletePrivateConnectionRequest, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteRoute(request, options)

deleteRoute(request?: protos.google.cloud.datastream.v1alpha1.IDeleteRouteRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

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

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

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

  callDeleteRoute();

deleteRoute(request, options, callback)

deleteRoute(request: protos.google.cloud.datastream.v1alpha1.IDeleteRouteRequest, options: CallOptions, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteRoute(request, callback)

deleteRoute(request: protos.google.cloud.datastream.v1alpha1.IDeleteRouteRequest, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteStream(request, options)

deleteStream(request?: protos.google.cloud.datastream.v1alpha1.IDeleteStreamRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>,
        protos.google.longrunning.IOperation | undefined,
        {} | undefined
    ]>;

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

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

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

  callDeleteStream();

deleteStream(request, options, callback)

deleteStream(request: protos.google.cloud.datastream.v1alpha1.IDeleteStreamRequest, options: CallOptions, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

deleteStream(request, callback)

deleteStream(request: protos.google.cloud.datastream.v1alpha1.IDeleteStreamRequest, callback: Callback<LROperation<protos.google.protobuf.IEmpty, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

discoverConnectionProfile(request, options)

discoverConnectionProfile(request?: protos.google.cloud.datastream.v1alpha1.IDiscoverConnectionProfileRequest, options?: CallOptions): Promise<[
        protos.google.cloud.datastream.v1alpha1.IDiscoverConnectionProfileResponse,
        (protos.google.cloud.datastream.v1alpha1.IDiscoverConnectionProfileRequest | 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 parent resource of the ConnectionProfile type. Must be in the
   *  format `projects/* /locations/*`.
   */
  // const parent = 'abc123'
  /**
   *  An ad-hoc ConnectionProfile configuration.
   */
  // const connectionProfile = {}
  /**
   *  A reference to an existing ConnectionProfile.
   */
  // const connectionProfileName = 'abc123'
  /**
   *  Whether to retrieve the full hierarchy of data objects (TRUE) or only the
   *  current level (FALSE).
   */
  // const recursive = true
  /**
   *  The number of hierarchy levels below the current level to be retrieved.
   */
  // const recursionDepth = 1234
  /**
   *  Oracle RDBMS to enrich with child data objects and metadata.
   */
  // const oracleRdbms = {}
  /**
   *  MySQL RDBMS to enrich with child data objects and metadata.
   */
  // const mysqlRdbms = {}

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

    // Run request
    const response = await datastreamClient.discoverConnectionProfile(request);
    console.log(response);
  }

  callDiscoverConnectionProfile();

discoverConnectionProfile(request, options, callback)

discoverConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IDiscoverConnectionProfileRequest, options: CallOptions, callback: Callback<protos.google.cloud.datastream.v1alpha1.IDiscoverConnectionProfileResponse, protos.google.cloud.datastream.v1alpha1.IDiscoverConnectionProfileRequest | null | undefined, {} | null | undefined>): void;

discoverConnectionProfile(request, callback)

discoverConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IDiscoverConnectionProfileRequest, callback: Callback<protos.google.cloud.datastream.v1alpha1.IDiscoverConnectionProfileResponse, protos.google.cloud.datastream.v1alpha1.IDiscoverConnectionProfileRequest | null | undefined, {} | null | undefined>): void;

fetchErrors(request, options)

fetchErrors(request?: protos.google.cloud.datastream.v1alpha1.IFetchErrorsRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.datastream.v1alpha1.IFetchErrorsResponse, protos.google.cloud.datastream.v1alpha1.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.
   */
  /**
   *  Name of the Stream resource for which to fetch any errors.
   */
  // const stream = 'abc123'

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

  async function callFetchErrors() {
    // Construct request
    const request = {
    };

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

  callFetchErrors();

fetchErrors(request, options, callback)

fetchErrors(request: protos.google.cloud.datastream.v1alpha1.IFetchErrorsRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.datastream.v1alpha1.IFetchErrorsResponse, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

fetchErrors(request, callback)

fetchErrors(request: protos.google.cloud.datastream.v1alpha1.IFetchErrorsRequest, callback: Callback<LROperation<protos.google.cloud.datastream.v1alpha1.IFetchErrorsResponse, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

fetchStaticIps(request, options)

fetchStaticIps(request?: protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsRequest, options?: CallOptions): Promise<[
        string[],
        protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsRequest | null,
        protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsResponse
    ]>;

fetchStaticIps(request, options, callback)

fetchStaticIps(request: protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsRequest, protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsResponse | null | undefined, string>): void;

fetchStaticIps(request, callback)

fetchStaticIps(request: protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsRequest, callback: PaginationCallback<protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsRequest, protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsResponse | null | undefined, string>): void;

fetchStaticIpsAsync(request, options)

fetchStaticIpsAsync(request?: protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsRequest, options?: CallOptions): AsyncIterable<string>;

  /**
   * 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 resource of the Response type. Must be in the
   *  format `projects/* /locations/*`.
   */
  // const name = 'abc123'
  /**
   *  Maximum number of Ips to return, will likely not be specified.
   */
  // const pageSize = 1234
  /**
   *  A page token, received from a previous `ListStaticIps` call.
   *  will likely not be specified.
   */
  // const pageToken = 'abc123'

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

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

  callFetchStaticIps();

fetchStaticIpsStream(request, options)

fetchStaticIpsStream(request?: protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsRequest, options?: CallOptions): Transform;

getConnectionProfile(request, options)

getConnectionProfile(request?: protos.google.cloud.datastream.v1alpha1.IGetConnectionProfileRequest, options?: CallOptions): Promise<[
        protos.google.cloud.datastream.v1alpha1.IConnectionProfile,
        (protos.google.cloud.datastream.v1alpha1.IGetConnectionProfileRequest | undefined),
        {} | undefined
    ]>;

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

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

    // Run request
    const response = await datastreamClient.getConnectionProfile(request);
    console.log(response);
  }

  callGetConnectionProfile();

getConnectionProfile(request, options, callback)

getConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IGetConnectionProfileRequest, options: CallOptions, callback: Callback<protos.google.cloud.datastream.v1alpha1.IConnectionProfile, protos.google.cloud.datastream.v1alpha1.IGetConnectionProfileRequest | null | undefined, {} | null | undefined>): void;

getConnectionProfile(request, callback)

getConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IGetConnectionProfileRequest, callback: Callback<protos.google.cloud.datastream.v1alpha1.IConnectionProfile, protos.google.cloud.datastream.v1alpha1.IGetConnectionProfileRequest | null | undefined, {} | null | undefined>): void;

getPrivateConnection(request, options)

getPrivateConnection(request?: protos.google.cloud.datastream.v1alpha1.IGetPrivateConnectionRequest, options?: CallOptions): Promise<[
        protos.google.cloud.datastream.v1alpha1.IPrivateConnection,
        (protos.google.cloud.datastream.v1alpha1.IGetPrivateConnectionRequest | undefined),
        {} | undefined
    ]>;

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

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

    // Run request
    const response = await datastreamClient.getPrivateConnection(request);
    console.log(response);
  }

  callGetPrivateConnection();

getPrivateConnection(request, options, callback)

getPrivateConnection(request: protos.google.cloud.datastream.v1alpha1.IGetPrivateConnectionRequest, options: CallOptions, callback: Callback<protos.google.cloud.datastream.v1alpha1.IPrivateConnection, protos.google.cloud.datastream.v1alpha1.IGetPrivateConnectionRequest | null | undefined, {} | null | undefined>): void;

getPrivateConnection(request, callback)

getPrivateConnection(request: protos.google.cloud.datastream.v1alpha1.IGetPrivateConnectionRequest, callback: Callback<protos.google.cloud.datastream.v1alpha1.IPrivateConnection, protos.google.cloud.datastream.v1alpha1.IGetPrivateConnectionRequest | null | undefined, {} | null | undefined>): void;

getProjectId()

getProjectId(): Promise<string>;

getProjectId(callback)

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

getRoute(request, options)

getRoute(request?: protos.google.cloud.datastream.v1alpha1.IGetRouteRequest, options?: CallOptions): Promise<[
        protos.google.cloud.datastream.v1alpha1.IRoute,
        protos.google.cloud.datastream.v1alpha1.IGetRouteRequest | undefined,
        {} | undefined
    ]>;

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

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

    // Run request
    const response = await datastreamClient.getRoute(request);
    console.log(response);
  }

  callGetRoute();

getRoute(request, options, callback)

getRoute(request: protos.google.cloud.datastream.v1alpha1.IGetRouteRequest, options: CallOptions, callback: Callback<protos.google.cloud.datastream.v1alpha1.IRoute, protos.google.cloud.datastream.v1alpha1.IGetRouteRequest | null | undefined, {} | null | undefined>): void;

getRoute(request, callback)

getRoute(request: protos.google.cloud.datastream.v1alpha1.IGetRouteRequest, callback: Callback<protos.google.cloud.datastream.v1alpha1.IRoute, protos.google.cloud.datastream.v1alpha1.IGetRouteRequest | null | undefined, {} | null | undefined>): void;

getStream(request, options)

getStream(request?: protos.google.cloud.datastream.v1alpha1.IGetStreamRequest, options?: CallOptions): Promise<[
        protos.google.cloud.datastream.v1alpha1.IStream,
        protos.google.cloud.datastream.v1alpha1.IGetStreamRequest | undefined,
        {} | undefined
    ]>;

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

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

    // Run request
    const response = await datastreamClient.getStream(request);
    console.log(response);
  }

  callGetStream();

getStream(request, options, callback)

getStream(request: protos.google.cloud.datastream.v1alpha1.IGetStreamRequest, options: CallOptions, callback: Callback<protos.google.cloud.datastream.v1alpha1.IStream, protos.google.cloud.datastream.v1alpha1.IGetStreamRequest | null | undefined, {} | null | undefined>): void;

getStream(request, callback)

getStream(request: protos.google.cloud.datastream.v1alpha1.IGetStreamRequest, callback: Callback<protos.google.cloud.datastream.v1alpha1.IStream, protos.google.cloud.datastream.v1alpha1.IGetStreamRequest | null | undefined, {} | null | undefined>): void;

initialize()

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

listConnectionProfiles(request, options)

listConnectionProfiles(request?: protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesRequest, options?: CallOptions): Promise<[
        protos.google.cloud.datastream.v1alpha1.IConnectionProfile[],
        protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesRequest | null,
        protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesResponse
    ]>;

listConnectionProfiles(request, options, callback)

listConnectionProfiles(request: protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesRequest, protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesResponse | null | undefined, protos.google.cloud.datastream.v1alpha1.IConnectionProfile>): void;

listConnectionProfiles(request, callback)

listConnectionProfiles(request: protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesRequest, callback: PaginationCallback<protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesRequest, protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesResponse | null | undefined, protos.google.cloud.datastream.v1alpha1.IConnectionProfile>): void;

listConnectionProfilesAsync(request, options)

listConnectionProfilesAsync(request?: protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.datastream.v1alpha1.IConnectionProfile>;

  /**
   * 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 parent that owns the collection of connection profiles.
   */
  // const parent = 'abc123'
  /**
   *  Maximum number of connection profiles to return.
   *  If unspecified, at most 50 connection profiles will be returned.
   *  The maximum value is 1000; values above 1000 will be coerced to 1000.
   */
  // const pageSize = 1234
  /**
   *  Page token received from a previous `ListConnectionProfiles` call.
   *  Provide this to retrieve the subsequent page.
   *  When paginating, all other parameters provided to `ListConnectionProfiles`
   *  must match the call that provided the page token.
   */
  // const pageToken = 'abc123'
  /**
   *  Filter request.
   */
  // const filter = 'abc123'
  /**
   *  Order by fields for the result.
   */
  // const orderBy = 'abc123'

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

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

  callListConnectionProfiles();

listConnectionProfilesStream(request, options)

listConnectionProfilesStream(request?: protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesRequest, options?: CallOptions): Transform;

listPrivateConnections(request, options)

listPrivateConnections(request?: protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsRequest, options?: CallOptions): Promise<[
        protos.google.cloud.datastream.v1alpha1.IPrivateConnection[],
        protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsRequest | null,
        protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsResponse
    ]>;

listPrivateConnections(request, options, callback)

listPrivateConnections(request: protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsRequest, protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsResponse | null | undefined, protos.google.cloud.datastream.v1alpha1.IPrivateConnection>): void;

listPrivateConnections(request, callback)

listPrivateConnections(request: protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsRequest, callback: PaginationCallback<protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsRequest, protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsResponse | null | undefined, protos.google.cloud.datastream.v1alpha1.IPrivateConnection>): void;

listPrivateConnectionsAsync(request, options)

listPrivateConnectionsAsync(request?: protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.datastream.v1alpha1.IPrivateConnection>;

  /**
   * 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 parent that owns the collection of private connectivity configurations.
   */
  // const parent = 'abc123'
  /**
   *  Maximum number of private connectivity configurations to return.
   *  If unspecified, at most 50 private connectivity configurations that will be
   *  returned. The maximum value is 1000; values above 1000 will be coerced to
   *  1000.
   */
  // const pageSize = 1234
  /**
   *  Page token received from a previous `ListPrivateConnections` call.
   *  Provide this to retrieve the subsequent page.
   *  When paginating, all other parameters provided to
   *  `ListPrivateConnections` must match the call that provided the page
   *  token.
   */
  // const pageToken = 'abc123'
  /**
   *  Filter request.
   */
  // const filter = 'abc123'
  /**
   *  Order by fields for the result.
   */
  // const orderBy = 'abc123'

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

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

  callListPrivateConnections();

listPrivateConnectionsStream(request, options)

listPrivateConnectionsStream(request?: protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsRequest, options?: CallOptions): Transform;

listRoutes(request, options)

listRoutes(request?: protos.google.cloud.datastream.v1alpha1.IListRoutesRequest, options?: CallOptions): Promise<[
        protos.google.cloud.datastream.v1alpha1.IRoute[],
        protos.google.cloud.datastream.v1alpha1.IListRoutesRequest | null,
        protos.google.cloud.datastream.v1alpha1.IListRoutesResponse
    ]>;

listRoutes(request, options, callback)

listRoutes(request: protos.google.cloud.datastream.v1alpha1.IListRoutesRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.datastream.v1alpha1.IListRoutesRequest, protos.google.cloud.datastream.v1alpha1.IListRoutesResponse | null | undefined, protos.google.cloud.datastream.v1alpha1.IRoute>): void;

listRoutes(request, callback)

listRoutes(request: protos.google.cloud.datastream.v1alpha1.IListRoutesRequest, callback: PaginationCallback<protos.google.cloud.datastream.v1alpha1.IListRoutesRequest, protos.google.cloud.datastream.v1alpha1.IListRoutesResponse | null | undefined, protos.google.cloud.datastream.v1alpha1.IRoute>): void;

listRoutesAsync(request, options)

listRoutesAsync(request?: protos.google.cloud.datastream.v1alpha1.IListRoutesRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.datastream.v1alpha1.IRoute>;

  /**
   * 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 parent that owns the collection of Routess.
   */
  // const parent = 'abc123'
  /**
   *  Maximum number of Routes to return. The service may return
   *  fewer than this value. If unspecified, at most 50 Routes
   *  will be returned. The maximum value is 1000; values above 1000 will be
   *  coerced to 1000.
   */
  // const pageSize = 1234
  /**
   *  Page token received from a previous `ListRoutes` call.
   *  Provide this to retrieve the subsequent page.
   *  When paginating, all other parameters provided to
   *  `ListRoutes` must match the call that provided the page
   *  token.
   */
  // const pageToken = 'abc123'
  /**
   *  Filter request.
   */
  // const filter = 'abc123'
  /**
   *  Order by fields for the result.
   */
  // const orderBy = 'abc123'

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

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

  callListRoutes();

listRoutesStream(request, options)

listRoutesStream(request?: protos.google.cloud.datastream.v1alpha1.IListRoutesRequest, options?: CallOptions): Transform;

listStreams(request, options)

listStreams(request?: protos.google.cloud.datastream.v1alpha1.IListStreamsRequest, options?: CallOptions): Promise<[
        protos.google.cloud.datastream.v1alpha1.IStream[],
        protos.google.cloud.datastream.v1alpha1.IListStreamsRequest | null,
        protos.google.cloud.datastream.v1alpha1.IListStreamsResponse
    ]>;

listStreams(request, options, callback)

listStreams(request: protos.google.cloud.datastream.v1alpha1.IListStreamsRequest, options: CallOptions, callback: PaginationCallback<protos.google.cloud.datastream.v1alpha1.IListStreamsRequest, protos.google.cloud.datastream.v1alpha1.IListStreamsResponse | null | undefined, protos.google.cloud.datastream.v1alpha1.IStream>): void;

listStreams(request, callback)

listStreams(request: protos.google.cloud.datastream.v1alpha1.IListStreamsRequest, callback: PaginationCallback<protos.google.cloud.datastream.v1alpha1.IListStreamsRequest, protos.google.cloud.datastream.v1alpha1.IListStreamsResponse | null | undefined, protos.google.cloud.datastream.v1alpha1.IStream>): void;

listStreamsAsync(request, options)

listStreamsAsync(request?: protos.google.cloud.datastream.v1alpha1.IListStreamsRequest, options?: CallOptions): AsyncIterable<protos.google.cloud.datastream.v1alpha1.IStream>;

  /**
   * 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 parent that owns the collection of streams.
   */
  // const parent = 'abc123'
  /**
   *  Maximum number of streams to return.
   *  If unspecified, at most 50 streams will  be returned. The maximum
   *  value is 1000; values above 1000 will be coerced to 1000.
   */
  // const pageSize = 1234
  /**
   *  Page token received from a previous `ListStreams` call.
   *  Provide this to retrieve the subsequent page.
   *  When paginating, all other parameters provided to `ListStreams`
   *  must match the call that provided the page token.
   */
  // const pageToken = 'abc123'
  /**
   *  Filter request.
   */
  // const filter = 'abc123'
  /**
   *  Order by fields for the result.
   */
  // const orderBy = 'abc123'

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

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

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

  callListStreams();

listStreamsStream(request, options)

listStreamsStream(request?: protos.google.cloud.datastream.v1alpha1.IListStreamsRequest, options?: CallOptions): Transform;

locationPath(project, location)

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

matchConnectionProfileFromConnectionProfileName(connectionProfileName)

matchConnectionProfileFromConnectionProfileName(connectionProfileName: string): string | number;

matchLocationFromConnectionProfileName(connectionProfileName)

matchLocationFromConnectionProfileName(connectionProfileName: string): string | number;

matchLocationFromLocationName(locationName)

matchLocationFromLocationName(locationName: string): string | number;

matchLocationFromPrivateConnectionName(privateConnectionName)

matchLocationFromPrivateConnectionName(privateConnectionName: string): string | number;

matchLocationFromRouteName(routeName)

matchLocationFromRouteName(routeName: string): string | number;

matchLocationFromStreamName(streamName)

matchLocationFromStreamName(streamName: string): string | number;

matchPrivateConnectionFromPrivateConnectionName(privateConnectionName)

matchPrivateConnectionFromPrivateConnectionName(privateConnectionName: string): string | number;

matchPrivateConnectionFromRouteName(routeName)

matchPrivateConnectionFromRouteName(routeName: string): string | number;

matchProjectFromConnectionProfileName(connectionProfileName)

matchProjectFromConnectionProfileName(connectionProfileName: string): string | number;

matchProjectFromLocationName(locationName)

matchProjectFromLocationName(locationName: string): string | number;

matchProjectFromPrivateConnectionName(privateConnectionName)

matchProjectFromPrivateConnectionName(privateConnectionName: string): string | number;

matchProjectFromProjectName(projectName)

matchProjectFromProjectName(projectName: string): string | number;

matchProjectFromRouteName(routeName)

matchProjectFromRouteName(routeName: string): string | number;

matchProjectFromStreamName(streamName)

matchProjectFromStreamName(streamName: string): string | number;

matchRouteFromRouteName(routeName)

matchRouteFromRouteName(routeName: string): string | number;

matchStreamFromStreamName(streamName)

matchStreamFromStreamName(streamName: string): string | number;

privateConnectionPath(project, location, privateConnection)

privateConnectionPath(project: string, location: string, privateConnection: string): string;

projectPath(project)

projectPath(project: string): string;

routePath(project, location, privateConnection, route)

routePath(project: string, location: string, privateConnection: string, route: string): string;

streamPath(project, location, stream)

streamPath(project: string, location: string, stream: string): string;

updateConnectionProfile(request, options)

updateConnectionProfile(request?: protos.google.cloud.datastream.v1alpha1.IUpdateConnectionProfileRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.datastream.v1alpha1.IConnectionProfile, protos.google.cloud.datastream.v1alpha1.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.
   */
  /**
   *  Optional. Field mask is used to specify the fields to be overwritten in the
   *  ConnectionProfile resource by the update.
   *  The fields specified in the update_mask are relative to the resource, not
   *  the full request. A field will be overwritten if it is in the mask. If the
   *  user does not provide a mask then all fields will be overwritten.
   */
  // const updateMask = {}
  /**
   *  Required. The ConnectionProfile to update.
   */
  // const connectionProfile = {}
  /**
   *  Optional. A request ID to identify requests. Specify a unique request ID
   *  so that if you must retry your request, the server will know to ignore
   *  the request if it has already been completed. The server will guarantee
   *  that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and the
   *  request times out. If you make the request again with the same request ID,
   *  the server can check if original operation with the same request ID was
   *  received, and if so, will ignore the second request. This prevents clients
   *  from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

  async function callUpdateConnectionProfile() {
    // Construct request
    const request = {
      connectionProfile,
    };

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

  callUpdateConnectionProfile();

updateConnectionProfile(request, options, callback)

updateConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IUpdateConnectionProfileRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.datastream.v1alpha1.IConnectionProfile, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

updateConnectionProfile(request, callback)

updateConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IUpdateConnectionProfileRequest, callback: Callback<LROperation<protos.google.cloud.datastream.v1alpha1.IConnectionProfile, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

updateStream(request, options)

updateStream(request?: protos.google.cloud.datastream.v1alpha1.IUpdateStreamRequest, options?: CallOptions): Promise<[
        LROperation<protos.google.cloud.datastream.v1alpha1.IStream, protos.google.cloud.datastream.v1alpha1.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.
   */
  /**
   *  Optional. Field mask is used to specify the fields to be overwritten in the
   *  stream resource by the update.
   *  The fields specified in the update_mask are relative to the resource, not
   *  the full request. A field will be overwritten if it is in the mask. If the
   *  user does not provide a mask then all fields will be overwritten.
   */
  // const updateMask = {}
  /**
   *  Required. The stream resource to update.
   */
  // const stream = {}
  /**
   *  Optional. A request ID to identify requests. Specify a unique request ID
   *  so that if you must retry your request, the server will know to ignore
   *  the request if it has already been completed. The server will guarantee
   *  that for at least 60 minutes since the first request.
   *  For example, consider a situation where you make an initial request and the
   *  request times out. If you make the request again with the same request ID,
   *  the server can check if original operation with the same request ID was
   *  received, and if so, will ignore the second request. This prevents clients
   *  from accidentally creating duplicate commitments.
   *  The request ID must be a valid UUID with the exception that zero UUID is
   *  not supported (00000000-0000-0000-0000-000000000000).
   */
  // const requestId = 'abc123'
  /**
   *  Optional. Only validate the stream with the changes, without actually updating it.
   *  The default is false.
   */
  // const validateOnly = true
  /**
   *  Optional. Execute the update without validating it.
   */
  // const force = true

  // Imports the Datastream library
  const {DatastreamClient} = require('@google-cloud/datastream').v1alpha1;

  // Instantiates a client
  const datastreamClient = new DatastreamClient();

  async function callUpdateStream() {
    // Construct request
    const request = {
      stream,
    };

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

  callUpdateStream();

updateStream(request, options, callback)

updateStream(request: protos.google.cloud.datastream.v1alpha1.IUpdateStreamRequest, options: CallOptions, callback: Callback<LROperation<protos.google.cloud.datastream.v1alpha1.IStream, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;

updateStream(request, callback)

updateStream(request: protos.google.cloud.datastream.v1alpha1.IUpdateStreamRequest, callback: Callback<LROperation<protos.google.cloud.datastream.v1alpha1.IStream, protos.google.cloud.datastream.v1alpha1.IOperationMetadata>, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void;