import type * as gax from 'google-gax'; import type { Callback, CallOptions, Descriptors, ClientOptions, LROperation, PaginationCallback } from 'google-gax'; import { Transform } from 'stream'; import * as protos from '../../protos/protos'; /** * Datastream service * @class * @memberof v1alpha1 */ export declare class DatastreamClient { private _terminated; private _opts; private _providedCustomServicePath; private _gaxModule; private _gaxGrpc; private _protos; private _defaults; private _universeDomain; private _servicePath; private _log; auth: gax.GoogleAuth; descriptors: Descriptors; warn: (code: string, message: string, warnType?: string) => void; innerApiCalls: { [name: string]: Function; }; pathTemplates: { [name: string]: gax.PathTemplate; }; operationsClient: gax.OperationsClient; datastreamStub?: Promise<{ [name: string]: Function; }>; /** * Construct an instance of DatastreamClient. * * @param {object} [options] - The configuration object. * The options accepted by the constructor are described in detail * in [this document](https://github.com/googleapis/gax-nodejs/blob/main/client-libraries.md#creating-the-client-instance). * The common options are: * @param {object} [options.credentials] - Credentials object. * @param {string} [options.credentials.client_email] * @param {string} [options.credentials.private_key] * @param {string} [options.email] - Account email address. Required when * using a .pem or .p12 keyFilename. * @param {string} [options.keyFilename] - Full path to the a .json, .pem, or * .p12 key downloaded from the Google Developers Console. If you provide * a path to a JSON file, the projectId option below is not necessary. * NOTE: .pem and .p12 require you to specify options.email as well. * @param {number} [options.port] - The port on which to connect to * the remote host. * @param {string} [options.projectId] - The project ID from the Google * Developer's Console, e.g. 'grape-spaceship-123'. We will also check * the environment variable GCLOUD_PROJECT for your project ID. If your * app is running in an environment which supports * {@link https://cloud.google.com/docs/authentication/application-default-credentials Application Default Credentials}, * your project ID will be detected automatically. * @param {string} [options.apiEndpoint] - The domain name of the * API remote host. * @param {gax.ClientConfig} [options.clientConfig] - Client configuration override. * Follows the structure of {@link gapicConfig}. * @param {boolean} [options.fallback] - Use HTTP/1.1 REST mode. * For more information, please check the * {@link https://github.com/googleapis/gax-nodejs/blob/main/client-libraries.md#http11-rest-api-mode documentation}. * @param {gax} [gaxInstance]: loaded instance of `google-gax`. Useful if you * need to avoid loading the default gRPC version and want to use the fallback * HTTP implementation. Load only fallback version and pass it to the constructor: * ``` * const gax = require('google-gax/build/src/fallback'); // avoids loading google-gax with gRPC * const client = new DatastreamClient({fallback: true}, gax); * ``` */ constructor(opts?: ClientOptions, gaxInstance?: typeof gax | typeof gax.fallback); /** * Initialize the client. * Performs asynchronous operations (such as authentication) and prepares the client. * This function will be called automatically when any class method is called for the * first time, but if you need to initialize it before calling an actual method, * feel free to call initialize() directly. * * You can await on this method if you want to make sure the client is initialized. * * @returns {Promise} A promise that resolves to an authenticated service stub. */ initialize(): Promise<{ [name: string]: Function; }>; /** * The DNS address for this API service. * @deprecated Use the apiEndpoint method of the client instance. * @returns {string} The DNS address for this service. */ static get servicePath(): string; /** * The DNS address for this API service - same as servicePath. * @deprecated Use the apiEndpoint method of the client instance. * @returns {string} The DNS address for this service. */ static get apiEndpoint(): string; /** * The DNS address for this API service. * @returns {string} The DNS address for this service. */ get apiEndpoint(): string; get universeDomain(): string; /** * The port for this API service. * @returns {number} The default port for this service. */ static get port(): number; /** * The scopes needed to make gRPC calls for every method defined * in this service. * @returns {string[]} List of default scopes. */ static get scopes(): string[]; getProjectId(): Promise; getProjectId(callback: Callback): void; /** * Use this method to get details about a connection profile. * * @param {Object} request * The request object that will be sent. * @param {string} request.name * Required. The name of the connection profile resource to get. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing {@link protos.google.cloud.datastream.v1alpha1.ConnectionProfile|ConnectionProfile}. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.get_connection_profile.js * region_tag:datastream_v1alpha1_generated_Datastream_GetConnectionProfile_async */ 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 ]>; getConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IGetConnectionProfileRequest, options: CallOptions, callback: Callback): void; getConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IGetConnectionProfileRequest, callback: Callback): void; /** * Use this method to discover a connection profile. * The discover API call exposes the data objects and metadata belonging to * the profile. Typically, a request returns children data objects under a * parent data object that's optionally supplied in the request. * * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent resource of the ConnectionProfile type. Must be in the * format `projects/* /locations/*`. * @param {google.cloud.datastream.v1alpha1.ConnectionProfile} request.connectionProfile * An ad-hoc ConnectionProfile configuration. * @param {string} request.connectionProfileName * A reference to an existing ConnectionProfile. * @param {boolean} request.recursive * Whether to retrieve the full hierarchy of data objects (TRUE) or only the * current level (FALSE). * @param {number} request.recursionDepth * The number of hierarchy levels below the current level to be retrieved. * @param {google.cloud.datastream.v1alpha1.OracleRdbms} request.oracleRdbms * Oracle RDBMS to enrich with child data objects and metadata. * @param {google.cloud.datastream.v1alpha1.MysqlRdbms} request.mysqlRdbms * MySQL RDBMS to enrich with child data objects and metadata. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing {@link protos.google.cloud.datastream.v1alpha1.DiscoverConnectionProfileResponse|DiscoverConnectionProfileResponse}. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.discover_connection_profile.js * region_tag:datastream_v1alpha1_generated_Datastream_DiscoverConnectionProfile_async */ 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 ]>; discoverConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IDiscoverConnectionProfileRequest, options: CallOptions, callback: Callback): void; discoverConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IDiscoverConnectionProfileRequest, callback: Callback): void; /** * Use this method to get details about a stream. * * @param {Object} request * The request object that will be sent. * @param {string} request.name * Required. The name of the stream resource to get. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing {@link protos.google.cloud.datastream.v1alpha1.Stream|Stream}. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.get_stream.js * region_tag:datastream_v1alpha1_generated_Datastream_GetStream_async */ 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 ]>; getStream(request: protos.google.cloud.datastream.v1alpha1.IGetStreamRequest, options: CallOptions, callback: Callback): void; getStream(request: protos.google.cloud.datastream.v1alpha1.IGetStreamRequest, callback: Callback): void; /** * Use this method to get details about a private connectivity configuration. * * @param {Object} request * The request object that will be sent. * @param {string} request.name * Required. The name of the private connectivity configuration to get. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing {@link protos.google.cloud.datastream.v1alpha1.PrivateConnection|PrivateConnection}. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.get_private_connection.js * region_tag:datastream_v1alpha1_generated_Datastream_GetPrivateConnection_async */ 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 ]>; getPrivateConnection(request: protos.google.cloud.datastream.v1alpha1.IGetPrivateConnectionRequest, options: CallOptions, callback: Callback): void; getPrivateConnection(request: protos.google.cloud.datastream.v1alpha1.IGetPrivateConnectionRequest, callback: Callback): void; /** * Use this method to get details about a route. * * @param {Object} request * The request object that will be sent. * @param {string} request.name * Required. The name of the Route resource to get. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing {@link protos.google.cloud.datastream.v1alpha1.Route|Route}. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.get_route.js * region_tag:datastream_v1alpha1_generated_Datastream_GetRoute_async */ 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 ]>; getRoute(request: protos.google.cloud.datastream.v1alpha1.IGetRouteRequest, options: CallOptions, callback: Callback): void; getRoute(request: protos.google.cloud.datastream.v1alpha1.IGetRouteRequest, callback: Callback): void; /** * Use this method to create a connection profile in a project and location. * * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of ConnectionProfiles. * @param {string} request.connectionProfileId * Required. The connection profile identifier. * @param {google.cloud.datastream.v1alpha1.ConnectionProfile} request.connectionProfile * Required. The connection profile resource to create. * @param {string} [request.requestId] * 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). * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing * a long running operation. Its `promise()` method returns a promise * you can `await` for. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.create_connection_profile.js * region_tag:datastream_v1alpha1_generated_Datastream_CreateConnectionProfile_async */ createConnectionProfile(request?: protos.google.cloud.datastream.v1alpha1.ICreateConnectionProfileRequest, options?: CallOptions): Promise<[ LROperation, protos.google.longrunning.IOperation | undefined, {} | undefined ]>; createConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.ICreateConnectionProfileRequest, options: CallOptions, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; createConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.ICreateConnectionProfileRequest, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; /** * Check the status of the long running operation returned by `createConnectionProfile()`. * @param {String} name * The operation name that will be passed. * @returns {Promise} - The promise which resolves to an object. * The decoded operation object has result and metadata field to get information from. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.create_connection_profile.js * region_tag:datastream_v1alpha1_generated_Datastream_CreateConnectionProfile_async */ checkCreateConnectionProfileProgress(name: string): Promise>; /** * Use this method to update the parameters of a connection profile. * * @param {Object} request * The request object that will be sent. * @param {google.protobuf.FieldMask} [request.updateMask] * 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. * @param {google.cloud.datastream.v1alpha1.ConnectionProfile} request.connectionProfile * Required. The ConnectionProfile to update. * @param {string} [request.requestId] * 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). * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing * a long running operation. Its `promise()` method returns a promise * you can `await` for. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.update_connection_profile.js * region_tag:datastream_v1alpha1_generated_Datastream_UpdateConnectionProfile_async */ updateConnectionProfile(request?: protos.google.cloud.datastream.v1alpha1.IUpdateConnectionProfileRequest, options?: CallOptions): Promise<[ LROperation, protos.google.longrunning.IOperation | undefined, {} | undefined ]>; updateConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IUpdateConnectionProfileRequest, options: CallOptions, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; updateConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IUpdateConnectionProfileRequest, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; /** * Check the status of the long running operation returned by `updateConnectionProfile()`. * @param {String} name * The operation name that will be passed. * @returns {Promise} - The promise which resolves to an object. * The decoded operation object has result and metadata field to get information from. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.update_connection_profile.js * region_tag:datastream_v1alpha1_generated_Datastream_UpdateConnectionProfile_async */ checkUpdateConnectionProfileProgress(name: string): Promise>; /** * Use this method to delete a connection profile.. * * @param {Object} request * The request object that will be sent. * @param {string} request.name * Required. The name of the connection profile resource to delete. * @param {string} [request.requestId] * 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). * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing * a long running operation. Its `promise()` method returns a promise * you can `await` for. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.delete_connection_profile.js * region_tag:datastream_v1alpha1_generated_Datastream_DeleteConnectionProfile_async */ deleteConnectionProfile(request?: protos.google.cloud.datastream.v1alpha1.IDeleteConnectionProfileRequest, options?: CallOptions): Promise<[ LROperation, protos.google.longrunning.IOperation | undefined, {} | undefined ]>; deleteConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IDeleteConnectionProfileRequest, options: CallOptions, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; deleteConnectionProfile(request: protos.google.cloud.datastream.v1alpha1.IDeleteConnectionProfileRequest, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; /** * Check the status of the long running operation returned by `deleteConnectionProfile()`. * @param {String} name * The operation name that will be passed. * @returns {Promise} - The promise which resolves to an object. * The decoded operation object has result and metadata field to get information from. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.delete_connection_profile.js * region_tag:datastream_v1alpha1_generated_Datastream_DeleteConnectionProfile_async */ checkDeleteConnectionProfileProgress(name: string): Promise>; /** * Use this method to create a stream. * * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of streams. * @param {string} request.streamId * Required. The stream identifier. * @param {google.cloud.datastream.v1alpha1.Stream} request.stream * Required. The stream resource to create. * @param {string} [request.requestId] * 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). * @param {boolean} [request.validateOnly] * Optional. Only validate the stream, but do not create any resources. * The default is false. * @param {boolean} [request.force] * Optional. Create the stream without validating it. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing * a long running operation. Its `promise()` method returns a promise * you can `await` for. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.create_stream.js * region_tag:datastream_v1alpha1_generated_Datastream_CreateStream_async */ createStream(request?: protos.google.cloud.datastream.v1alpha1.ICreateStreamRequest, options?: CallOptions): Promise<[ LROperation, protos.google.longrunning.IOperation | undefined, {} | undefined ]>; createStream(request: protos.google.cloud.datastream.v1alpha1.ICreateStreamRequest, options: CallOptions, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; createStream(request: protos.google.cloud.datastream.v1alpha1.ICreateStreamRequest, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; /** * Check the status of the long running operation returned by `createStream()`. * @param {String} name * The operation name that will be passed. * @returns {Promise} - The promise which resolves to an object. * The decoded operation object has result and metadata field to get information from. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.create_stream.js * region_tag:datastream_v1alpha1_generated_Datastream_CreateStream_async */ checkCreateStreamProgress(name: string): Promise>; /** * Use this method to update the configuration of a stream. * * @param {Object} request * The request object that will be sent. * @param {google.protobuf.FieldMask} [request.updateMask] * 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. * @param {google.cloud.datastream.v1alpha1.Stream} request.stream * Required. The stream resource to update. * @param {string} [request.requestId] * 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). * @param {boolean} [request.validateOnly] * Optional. Only validate the stream with the changes, without actually updating it. * The default is false. * @param {boolean} [request.force] * Optional. Execute the update without validating it. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing * a long running operation. Its `promise()` method returns a promise * you can `await` for. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.update_stream.js * region_tag:datastream_v1alpha1_generated_Datastream_UpdateStream_async */ updateStream(request?: protos.google.cloud.datastream.v1alpha1.IUpdateStreamRequest, options?: CallOptions): Promise<[ LROperation, protos.google.longrunning.IOperation | undefined, {} | undefined ]>; updateStream(request: protos.google.cloud.datastream.v1alpha1.IUpdateStreamRequest, options: CallOptions, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; updateStream(request: protos.google.cloud.datastream.v1alpha1.IUpdateStreamRequest, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; /** * Check the status of the long running operation returned by `updateStream()`. * @param {String} name * The operation name that will be passed. * @returns {Promise} - The promise which resolves to an object. * The decoded operation object has result and metadata field to get information from. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.update_stream.js * region_tag:datastream_v1alpha1_generated_Datastream_UpdateStream_async */ checkUpdateStreamProgress(name: string): Promise>; /** * Use this method to delete a stream. * * @param {Object} request * The request object that will be sent. * @param {string} request.name * Required. The name of the stream resource to delete. * @param {string} [request.requestId] * 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). * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing * a long running operation. Its `promise()` method returns a promise * you can `await` for. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.delete_stream.js * region_tag:datastream_v1alpha1_generated_Datastream_DeleteStream_async */ deleteStream(request?: protos.google.cloud.datastream.v1alpha1.IDeleteStreamRequest, options?: CallOptions): Promise<[ LROperation, protos.google.longrunning.IOperation | undefined, {} | undefined ]>; deleteStream(request: protos.google.cloud.datastream.v1alpha1.IDeleteStreamRequest, options: CallOptions, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; deleteStream(request: protos.google.cloud.datastream.v1alpha1.IDeleteStreamRequest, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; /** * Check the status of the long running operation returned by `deleteStream()`. * @param {String} name * The operation name that will be passed. * @returns {Promise} - The promise which resolves to an object. * The decoded operation object has result and metadata field to get information from. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.delete_stream.js * region_tag:datastream_v1alpha1_generated_Datastream_DeleteStream_async */ checkDeleteStreamProgress(name: string): Promise>; /** * Use this method to fetch any errors associated with a stream. * * @param {Object} request * The request object that will be sent. * @param {string} request.stream * Name of the Stream resource for which to fetch any errors. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing * a long running operation. Its `promise()` method returns a promise * you can `await` for. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.fetch_errors.js * region_tag:datastream_v1alpha1_generated_Datastream_FetchErrors_async */ fetchErrors(request?: protos.google.cloud.datastream.v1alpha1.IFetchErrorsRequest, options?: CallOptions): Promise<[ LROperation, protos.google.longrunning.IOperation | undefined, {} | undefined ]>; fetchErrors(request: protos.google.cloud.datastream.v1alpha1.IFetchErrorsRequest, options: CallOptions, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; fetchErrors(request: protos.google.cloud.datastream.v1alpha1.IFetchErrorsRequest, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; /** * Check the status of the long running operation returned by `fetchErrors()`. * @param {String} name * The operation name that will be passed. * @returns {Promise} - The promise which resolves to an object. * The decoded operation object has result and metadata field to get information from. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.fetch_errors.js * region_tag:datastream_v1alpha1_generated_Datastream_FetchErrors_async */ checkFetchErrorsProgress(name: string): Promise>; /** * Use this method to create a private connectivity configuration. * * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of PrivateConnections. * @param {string} request.privateConnectionId * Required. The private connectivity identifier. * @param {google.cloud.datastream.v1alpha1.PrivateConnection} request.privateConnection * Required. The Private Connectivity resource to create. * @param {string} [request.requestId] * 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). * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing * a long running operation. Its `promise()` method returns a promise * you can `await` for. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.create_private_connection.js * region_tag:datastream_v1alpha1_generated_Datastream_CreatePrivateConnection_async */ createPrivateConnection(request?: protos.google.cloud.datastream.v1alpha1.ICreatePrivateConnectionRequest, options?: CallOptions): Promise<[ LROperation, protos.google.longrunning.IOperation | undefined, {} | undefined ]>; createPrivateConnection(request: protos.google.cloud.datastream.v1alpha1.ICreatePrivateConnectionRequest, options: CallOptions, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; createPrivateConnection(request: protos.google.cloud.datastream.v1alpha1.ICreatePrivateConnectionRequest, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; /** * Check the status of the long running operation returned by `createPrivateConnection()`. * @param {String} name * The operation name that will be passed. * @returns {Promise} - The promise which resolves to an object. * The decoded operation object has result and metadata field to get information from. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.create_private_connection.js * region_tag:datastream_v1alpha1_generated_Datastream_CreatePrivateConnection_async */ checkCreatePrivateConnectionProgress(name: string): Promise>; /** * Use this method to delete a private connectivity configuration. * * @param {Object} request * The request object that will be sent. * @param {string} request.name * Required. The name of the private connectivity configuration to delete. * @param {string} [request.requestId] * 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). * @param {boolean} [request.force] * Optional. If set to true, any child routes that belong to this PrivateConnection will * also be deleted. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing * a long running operation. Its `promise()` method returns a promise * you can `await` for. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.delete_private_connection.js * region_tag:datastream_v1alpha1_generated_Datastream_DeletePrivateConnection_async */ deletePrivateConnection(request?: protos.google.cloud.datastream.v1alpha1.IDeletePrivateConnectionRequest, options?: CallOptions): Promise<[ LROperation, protos.google.longrunning.IOperation | undefined, {} | undefined ]>; deletePrivateConnection(request: protos.google.cloud.datastream.v1alpha1.IDeletePrivateConnectionRequest, options: CallOptions, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; deletePrivateConnection(request: protos.google.cloud.datastream.v1alpha1.IDeletePrivateConnectionRequest, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; /** * Check the status of the long running operation returned by `deletePrivateConnection()`. * @param {String} name * The operation name that will be passed. * @returns {Promise} - The promise which resolves to an object. * The decoded operation object has result and metadata field to get information from. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.delete_private_connection.js * region_tag:datastream_v1alpha1_generated_Datastream_DeletePrivateConnection_async */ checkDeletePrivateConnectionProgress(name: string): Promise>; /** * Use this method to create a route for a private connectivity in a project * and location. * * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of Routes. * @param {string} request.routeId * Required. The Route identifier. * @param {google.cloud.datastream.v1alpha1.Route} request.route * Required. The Route resource to create. * @param {string} [request.requestId] * 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). * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing * a long running operation. Its `promise()` method returns a promise * you can `await` for. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.create_route.js * region_tag:datastream_v1alpha1_generated_Datastream_CreateRoute_async */ createRoute(request?: protos.google.cloud.datastream.v1alpha1.ICreateRouteRequest, options?: CallOptions): Promise<[ LROperation, protos.google.longrunning.IOperation | undefined, {} | undefined ]>; createRoute(request: protos.google.cloud.datastream.v1alpha1.ICreateRouteRequest, options: CallOptions, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; createRoute(request: protos.google.cloud.datastream.v1alpha1.ICreateRouteRequest, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; /** * Check the status of the long running operation returned by `createRoute()`. * @param {String} name * The operation name that will be passed. * @returns {Promise} - The promise which resolves to an object. * The decoded operation object has result and metadata field to get information from. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.create_route.js * region_tag:datastream_v1alpha1_generated_Datastream_CreateRoute_async */ checkCreateRouteProgress(name: string): Promise>; /** * Use this method to delete a route. * * @param {Object} request * The request object that will be sent. * @param {string} request.name * Required. The name of the Route resource to delete. * @param {string} [request.requestId] * 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). * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is an object representing * a long running operation. Its `promise()` method returns a promise * you can `await` for. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.delete_route.js * region_tag:datastream_v1alpha1_generated_Datastream_DeleteRoute_async */ deleteRoute(request?: protos.google.cloud.datastream.v1alpha1.IDeleteRouteRequest, options?: CallOptions): Promise<[ LROperation, protos.google.longrunning.IOperation | undefined, {} | undefined ]>; deleteRoute(request: protos.google.cloud.datastream.v1alpha1.IDeleteRouteRequest, options: CallOptions, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; deleteRoute(request: protos.google.cloud.datastream.v1alpha1.IDeleteRouteRequest, callback: Callback, protos.google.longrunning.IOperation | null | undefined, {} | null | undefined>): void; /** * Check the status of the long running operation returned by `deleteRoute()`. * @param {String} name * The operation name that will be passed. * @returns {Promise} - The promise which resolves to an object. * The decoded operation object has result and metadata field to get information from. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#long-running-operations | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.delete_route.js * region_tag:datastream_v1alpha1_generated_Datastream_DeleteRoute_async */ checkDeleteRouteProgress(name: string): Promise>; /** * Use this method to list connection profiles created in a project and * location. * * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of connection profiles. * @param {number} request.pageSize * 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. * @param {string} request.pageToken * 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. * @param {string} request.filter * Filter request. * @param {string} request.orderBy * Order by fields for the result. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is Array of {@link protos.google.cloud.datastream.v1alpha1.ConnectionProfile|ConnectionProfile}. * The client library will perform auto-pagination by default: it will call the API as many * times as needed and will merge results from all the pages into this array. * Note that it can affect your quota. * We recommend using `listConnectionProfilesAsync()` * method described below for async iteration which you can stop as needed. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. */ 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: protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesRequest, options: CallOptions, callback: PaginationCallback): void; listConnectionProfiles(request: protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesRequest, callback: PaginationCallback): void; /** * Equivalent to `listConnectionProfiles`, but returns a NodeJS Stream object. * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of connection profiles. * @param {number} request.pageSize * 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. * @param {string} request.pageToken * 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. * @param {string} request.filter * Filter request. * @param {string} request.orderBy * Order by fields for the result. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Stream} * An object stream which emits an object representing {@link protos.google.cloud.datastream.v1alpha1.ConnectionProfile|ConnectionProfile} on 'data' event. * The client library will perform auto-pagination by default: it will call the API as many * times as needed. Note that it can affect your quota. * We recommend using `listConnectionProfilesAsync()` * method described below for async iteration which you can stop as needed. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. */ listConnectionProfilesStream(request?: protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesRequest, options?: CallOptions): Transform; /** * Equivalent to `listConnectionProfiles`, but returns an iterable object. * * `for`-`await`-`of` syntax is used with the iterable to get response elements on-demand. * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of connection profiles. * @param {number} request.pageSize * 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. * @param {string} request.pageToken * 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. * @param {string} request.filter * Filter request. * @param {string} request.orderBy * Order by fields for the result. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Object} * An iterable Object that allows {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols | async iteration }. * When you iterate the returned iterable, each element will be an object representing * {@link protos.google.cloud.datastream.v1alpha1.ConnectionProfile|ConnectionProfile}. The API will be called under the hood as needed, once per the page, * so you can stop the iteration when you don't need more results. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.list_connection_profiles.js * region_tag:datastream_v1alpha1_generated_Datastream_ListConnectionProfiles_async */ listConnectionProfilesAsync(request?: protos.google.cloud.datastream.v1alpha1.IListConnectionProfilesRequest, options?: CallOptions): AsyncIterable; /** * Use this method to list streams in a project and location. * * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of streams. * @param {number} request.pageSize * 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. * @param {string} request.pageToken * 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. * @param {string} request.filter * Filter request. * @param {string} request.orderBy * Order by fields for the result. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is Array of {@link protos.google.cloud.datastream.v1alpha1.Stream|Stream}. * The client library will perform auto-pagination by default: it will call the API as many * times as needed and will merge results from all the pages into this array. * Note that it can affect your quota. * We recommend using `listStreamsAsync()` * method described below for async iteration which you can stop as needed. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. */ 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: protos.google.cloud.datastream.v1alpha1.IListStreamsRequest, options: CallOptions, callback: PaginationCallback): void; listStreams(request: protos.google.cloud.datastream.v1alpha1.IListStreamsRequest, callback: PaginationCallback): void; /** * Equivalent to `listStreams`, but returns a NodeJS Stream object. * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of streams. * @param {number} request.pageSize * 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. * @param {string} request.pageToken * 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. * @param {string} request.filter * Filter request. * @param {string} request.orderBy * Order by fields for the result. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Stream} * An object stream which emits an object representing {@link protos.google.cloud.datastream.v1alpha1.Stream|Stream} on 'data' event. * The client library will perform auto-pagination by default: it will call the API as many * times as needed. Note that it can affect your quota. * We recommend using `listStreamsAsync()` * method described below for async iteration which you can stop as needed. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. */ listStreamsStream(request?: protos.google.cloud.datastream.v1alpha1.IListStreamsRequest, options?: CallOptions): Transform; /** * Equivalent to `listStreams`, but returns an iterable object. * * `for`-`await`-`of` syntax is used with the iterable to get response elements on-demand. * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of streams. * @param {number} request.pageSize * 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. * @param {string} request.pageToken * 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. * @param {string} request.filter * Filter request. * @param {string} request.orderBy * Order by fields for the result. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Object} * An iterable Object that allows {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols | async iteration }. * When you iterate the returned iterable, each element will be an object representing * {@link protos.google.cloud.datastream.v1alpha1.Stream|Stream}. The API will be called under the hood as needed, once per the page, * so you can stop the iteration when you don't need more results. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.list_streams.js * region_tag:datastream_v1alpha1_generated_Datastream_ListStreams_async */ listStreamsAsync(request?: protos.google.cloud.datastream.v1alpha1.IListStreamsRequest, options?: CallOptions): AsyncIterable; /** * The FetchStaticIps API call exposes the static ips used by Datastream. * Typically, a request returns children data objects under * a parent data object that's optionally supplied in the request. * * @param {Object} request * The request object that will be sent. * @param {string} request.name * Required. The name resource of the Response type. Must be in the * format `projects/* /locations/*`. * @param {number} request.pageSize * Maximum number of Ips to return, will likely not be specified. * @param {string} request.pageToken * A page token, received from a previous `ListStaticIps` call. * will likely not be specified. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is Array of string. * The client library will perform auto-pagination by default: it will call the API as many * times as needed and will merge results from all the pages into this array. * Note that it can affect your quota. * We recommend using `fetchStaticIpsAsync()` * method described below for async iteration which you can stop as needed. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. */ 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: protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsRequest, options: CallOptions, callback: PaginationCallback): void; fetchStaticIps(request: protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsRequest, callback: PaginationCallback): void; /** * Equivalent to `fetchStaticIps`, but returns a NodeJS Stream object. * @param {Object} request * The request object that will be sent. * @param {string} request.name * Required. The name resource of the Response type. Must be in the * format `projects/* /locations/*`. * @param {number} request.pageSize * Maximum number of Ips to return, will likely not be specified. * @param {string} request.pageToken * A page token, received from a previous `ListStaticIps` call. * will likely not be specified. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Stream} * An object stream which emits an object representing string on 'data' event. * The client library will perform auto-pagination by default: it will call the API as many * times as needed. Note that it can affect your quota. * We recommend using `fetchStaticIpsAsync()` * method described below for async iteration which you can stop as needed. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. */ fetchStaticIpsStream(request?: protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsRequest, options?: CallOptions): Transform; /** * Equivalent to `fetchStaticIps`, but returns an iterable object. * * `for`-`await`-`of` syntax is used with the iterable to get response elements on-demand. * @param {Object} request * The request object that will be sent. * @param {string} request.name * Required. The name resource of the Response type. Must be in the * format `projects/* /locations/*`. * @param {number} request.pageSize * Maximum number of Ips to return, will likely not be specified. * @param {string} request.pageToken * A page token, received from a previous `ListStaticIps` call. * will likely not be specified. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Object} * An iterable Object that allows {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols | async iteration }. * When you iterate the returned iterable, each element will be an object representing * string. The API will be called under the hood as needed, once per the page, * so you can stop the iteration when you don't need more results. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.fetch_static_ips.js * region_tag:datastream_v1alpha1_generated_Datastream_FetchStaticIps_async */ fetchStaticIpsAsync(request?: protos.google.cloud.datastream.v1alpha1.IFetchStaticIpsRequest, options?: CallOptions): AsyncIterable; /** * Use this method to list private connectivity configurations in a project * and location. * * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of private connectivity configurations. * @param {number} request.pageSize * 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. * @param {string} request.pageToken * 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. * @param {string} request.filter * Filter request. * @param {string} request.orderBy * Order by fields for the result. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is Array of {@link protos.google.cloud.datastream.v1alpha1.PrivateConnection|PrivateConnection}. * The client library will perform auto-pagination by default: it will call the API as many * times as needed and will merge results from all the pages into this array. * Note that it can affect your quota. * We recommend using `listPrivateConnectionsAsync()` * method described below for async iteration which you can stop as needed. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. */ 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: protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsRequest, options: CallOptions, callback: PaginationCallback): void; listPrivateConnections(request: protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsRequest, callback: PaginationCallback): void; /** * Equivalent to `listPrivateConnections`, but returns a NodeJS Stream object. * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of private connectivity configurations. * @param {number} request.pageSize * 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. * @param {string} request.pageToken * 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. * @param {string} request.filter * Filter request. * @param {string} request.orderBy * Order by fields for the result. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Stream} * An object stream which emits an object representing {@link protos.google.cloud.datastream.v1alpha1.PrivateConnection|PrivateConnection} on 'data' event. * The client library will perform auto-pagination by default: it will call the API as many * times as needed. Note that it can affect your quota. * We recommend using `listPrivateConnectionsAsync()` * method described below for async iteration which you can stop as needed. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. */ listPrivateConnectionsStream(request?: protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsRequest, options?: CallOptions): Transform; /** * Equivalent to `listPrivateConnections`, but returns an iterable object. * * `for`-`await`-`of` syntax is used with the iterable to get response elements on-demand. * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of private connectivity configurations. * @param {number} request.pageSize * 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. * @param {string} request.pageToken * 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. * @param {string} request.filter * Filter request. * @param {string} request.orderBy * Order by fields for the result. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Object} * An iterable Object that allows {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols | async iteration }. * When you iterate the returned iterable, each element will be an object representing * {@link protos.google.cloud.datastream.v1alpha1.PrivateConnection|PrivateConnection}. The API will be called under the hood as needed, once per the page, * so you can stop the iteration when you don't need more results. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.list_private_connections.js * region_tag:datastream_v1alpha1_generated_Datastream_ListPrivateConnections_async */ listPrivateConnectionsAsync(request?: protos.google.cloud.datastream.v1alpha1.IListPrivateConnectionsRequest, options?: CallOptions): AsyncIterable; /** * Use this method to list routes created for a private connectivity in a * project and location. * * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of Routess. * @param {number} request.pageSize * 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. * @param {string} request.pageToken * 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. * @param {string} request.filter * Filter request. * @param {string} request.orderBy * Order by fields for the result. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Promise} - The promise which resolves to an array. * The first element of the array is Array of {@link protos.google.cloud.datastream.v1alpha1.Route|Route}. * The client library will perform auto-pagination by default: it will call the API as many * times as needed and will merge results from all the pages into this array. * Note that it can affect your quota. * We recommend using `listRoutesAsync()` * method described below for async iteration which you can stop as needed. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. */ 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: protos.google.cloud.datastream.v1alpha1.IListRoutesRequest, options: CallOptions, callback: PaginationCallback): void; listRoutes(request: protos.google.cloud.datastream.v1alpha1.IListRoutesRequest, callback: PaginationCallback): void; /** * Equivalent to `listRoutes`, but returns a NodeJS Stream object. * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of Routess. * @param {number} request.pageSize * 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. * @param {string} request.pageToken * 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. * @param {string} request.filter * Filter request. * @param {string} request.orderBy * Order by fields for the result. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Stream} * An object stream which emits an object representing {@link protos.google.cloud.datastream.v1alpha1.Route|Route} on 'data' event. * The client library will perform auto-pagination by default: it will call the API as many * times as needed. Note that it can affect your quota. * We recommend using `listRoutesAsync()` * method described below for async iteration which you can stop as needed. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. */ listRoutesStream(request?: protos.google.cloud.datastream.v1alpha1.IListRoutesRequest, options?: CallOptions): Transform; /** * Equivalent to `listRoutes`, but returns an iterable object. * * `for`-`await`-`of` syntax is used with the iterable to get response elements on-demand. * @param {Object} request * The request object that will be sent. * @param {string} request.parent * Required. The parent that owns the collection of Routess. * @param {number} request.pageSize * 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. * @param {string} request.pageToken * 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. * @param {string} request.filter * Filter request. * @param {string} request.orderBy * Order by fields for the result. * @param {object} [options] * Call options. See {@link https://googleapis.dev/nodejs/google-gax/latest/interfaces/CallOptions.html|CallOptions} for more details. * @returns {Object} * An iterable Object that allows {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols | async iteration }. * When you iterate the returned iterable, each element will be an object representing * {@link protos.google.cloud.datastream.v1alpha1.Route|Route}. The API will be called under the hood as needed, once per the page, * so you can stop the iteration when you don't need more results. * Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#auto-pagination | documentation } * for more details and examples. * @example include:samples/generated/v1alpha1/datastream.list_routes.js * region_tag:datastream_v1alpha1_generated_Datastream_ListRoutes_async */ listRoutesAsync(request?: protos.google.cloud.datastream.v1alpha1.IListRoutesRequest, options?: CallOptions): AsyncIterable; /** * Return a fully-qualified connectionProfile resource name string. * * @param {string} project * @param {string} location * @param {string} connection_profile * @returns {string} Resource name string. */ connectionProfilePath(project: string, location: string, connectionProfile: string): string; /** * Parse the project from ConnectionProfile resource. * * @param {string} connectionProfileName * A fully-qualified path representing ConnectionProfile resource. * @returns {string} A string representing the project. */ matchProjectFromConnectionProfileName(connectionProfileName: string): string | number; /** * Parse the location from ConnectionProfile resource. * * @param {string} connectionProfileName * A fully-qualified path representing ConnectionProfile resource. * @returns {string} A string representing the location. */ matchLocationFromConnectionProfileName(connectionProfileName: string): string | number; /** * Parse the connection_profile from ConnectionProfile resource. * * @param {string} connectionProfileName * A fully-qualified path representing ConnectionProfile resource. * @returns {string} A string representing the connection_profile. */ matchConnectionProfileFromConnectionProfileName(connectionProfileName: string): string | number; /** * Return a fully-qualified location resource name string. * * @param {string} project * @param {string} location * @returns {string} Resource name string. */ locationPath(project: string, location: string): string; /** * Parse the project from Location resource. * * @param {string} locationName * A fully-qualified path representing Location resource. * @returns {string} A string representing the project. */ matchProjectFromLocationName(locationName: string): string | number; /** * Parse the location from Location resource. * * @param {string} locationName * A fully-qualified path representing Location resource. * @returns {string} A string representing the location. */ matchLocationFromLocationName(locationName: string): string | number; /** * Return a fully-qualified privateConnection resource name string. * * @param {string} project * @param {string} location * @param {string} private_connection * @returns {string} Resource name string. */ privateConnectionPath(project: string, location: string, privateConnection: string): string; /** * Parse the project from PrivateConnection resource. * * @param {string} privateConnectionName * A fully-qualified path representing PrivateConnection resource. * @returns {string} A string representing the project. */ matchProjectFromPrivateConnectionName(privateConnectionName: string): string | number; /** * Parse the location from PrivateConnection resource. * * @param {string} privateConnectionName * A fully-qualified path representing PrivateConnection resource. * @returns {string} A string representing the location. */ matchLocationFromPrivateConnectionName(privateConnectionName: string): string | number; /** * Parse the private_connection from PrivateConnection resource. * * @param {string} privateConnectionName * A fully-qualified path representing PrivateConnection resource. * @returns {string} A string representing the private_connection. */ matchPrivateConnectionFromPrivateConnectionName(privateConnectionName: string): string | number; /** * Return a fully-qualified project resource name string. * * @param {string} project * @returns {string} Resource name string. */ projectPath(project: string): string; /** * Parse the project from Project resource. * * @param {string} projectName * A fully-qualified path representing Project resource. * @returns {string} A string representing the project. */ matchProjectFromProjectName(projectName: string): string | number; /** * Return a fully-qualified route resource name string. * * @param {string} project * @param {string} location * @param {string} private_connection * @param {string} route * @returns {string} Resource name string. */ routePath(project: string, location: string, privateConnection: string, route: string): string; /** * Parse the project from Route resource. * * @param {string} routeName * A fully-qualified path representing Route resource. * @returns {string} A string representing the project. */ matchProjectFromRouteName(routeName: string): string | number; /** * Parse the location from Route resource. * * @param {string} routeName * A fully-qualified path representing Route resource. * @returns {string} A string representing the location. */ matchLocationFromRouteName(routeName: string): string | number; /** * Parse the private_connection from Route resource. * * @param {string} routeName * A fully-qualified path representing Route resource. * @returns {string} A string representing the private_connection. */ matchPrivateConnectionFromRouteName(routeName: string): string | number; /** * Parse the route from Route resource. * * @param {string} routeName * A fully-qualified path representing Route resource. * @returns {string} A string representing the route. */ matchRouteFromRouteName(routeName: string): string | number; /** * Return a fully-qualified stream resource name string. * * @param {string} project * @param {string} location * @param {string} stream * @returns {string} Resource name string. */ streamPath(project: string, location: string, stream: string): string; /** * Parse the project from Stream resource. * * @param {string} streamName * A fully-qualified path representing Stream resource. * @returns {string} A string representing the project. */ matchProjectFromStreamName(streamName: string): string | number; /** * Parse the location from Stream resource. * * @param {string} streamName * A fully-qualified path representing Stream resource. * @returns {string} A string representing the location. */ matchLocationFromStreamName(streamName: string): string | number; /** * Parse the stream from Stream resource. * * @param {string} streamName * A fully-qualified path representing Stream resource. * @returns {string} A string representing the stream. */ matchStreamFromStreamName(streamName: string): string | number; /** * Terminate the gRPC channel and close the client. * * The client will no longer be usable and all future behavior is undefined. * @returns {Promise} A promise that resolves when the client is closed. */ close(): Promise; }