"use strict";
// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// ** This file is automatically generated by gapic-generator-typescript. **
// ** https://github.com/googleapis/gapic-generator-typescript **
// ** All changes to this file may be overwritten. **
Object.defineProperty(exports, "__esModule", { value: true });
exports.DatastreamClient = void 0;
const jsonProtos = require("../../protos/protos.json");
const google_gax_1 = require("google-gax");
/**
 * Client JSON configuration object, loaded from
 * `src/v1/datastream_client_config.json`.
 * This file defines retry strategy and timeouts for all API methods in this library.
 */
const gapicConfig = require("./datastream_client_config.json");
const version = require('../../../package.json').version;
/**
 *  Datastream service
 * @class
 * @memberof v1
 */
class DatastreamClient {
    _terminated = false;
    _opts;
    _providedCustomServicePath;
    _gaxModule;
    _gaxGrpc;
    _protos;
    _defaults;
    _universeDomain;
    _servicePath;
    _log = google_gax_1.loggingUtils.log('datastream');
    auth;
    descriptors = {
        page: {},
        stream: {},
        longrunning: {},
        batching: {},
    };
    warn;
    innerApiCalls;
    iamClient;
    locationsClient;
    pathTemplates;
    operationsClient;
    datastreamStub;
    /**
     * 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, gaxInstance) {
        // Ensure that options include all the required fields.
        const staticMembers = this.constructor;
        if (opts?.universe_domain &&
            opts?.universeDomain &&
            opts?.universe_domain !== opts?.universeDomain) {
            throw new Error('Please set either universe_domain or universeDomain, but not both.');
        }
        const universeDomainEnvVar = typeof process === 'object' && typeof process.env === 'object'
            ? process.env['GOOGLE_CLOUD_UNIVERSE_DOMAIN']
            : undefined;
        this._universeDomain =
            opts?.universeDomain ??
                opts?.universe_domain ??
                universeDomainEnvVar ??
                'googleapis.com';
        this._servicePath = 'datastream.' + this._universeDomain;
        const servicePath = opts?.servicePath || opts?.apiEndpoint || this._servicePath;
        this._providedCustomServicePath = !!(opts?.servicePath || opts?.apiEndpoint);
        const port = opts?.port || staticMembers.port;
        const clientConfig = opts?.clientConfig ?? {};
        const fallback = opts?.fallback ??
            (typeof window !== 'undefined' && typeof window?.fetch === 'function');
        opts = Object.assign({ servicePath, port, clientConfig, fallback }, opts);
        // Request numeric enum values if REST transport is used.
        opts.numericEnums = true;
        // If scopes are unset in options and we're connecting to a non-default endpoint, set scopes just in case.
        if (servicePath !== this._servicePath && !('scopes' in opts)) {
            opts['scopes'] = staticMembers.scopes;
        }
        // Load google-gax module synchronously if needed
        if (!gaxInstance) {
            gaxInstance = require('google-gax');
        }
        // Choose either gRPC or proto-over-HTTP implementation of google-gax.
        this._gaxModule = opts.fallback ? gaxInstance.fallback : gaxInstance;
        // Create a `gaxGrpc` object, with any grpc-specific options sent to the client.
        this._gaxGrpc = new this._gaxModule.GrpcClient(opts);
        // Save options to use in initialize() method.
        this._opts = opts;
        // Save the auth object to the client, for use by other methods.
        this.auth = this._gaxGrpc.auth;
        // Set useJWTAccessWithScope on the auth object.
        this.auth.useJWTAccessWithScope = true;
        // Set defaultServicePath on the auth object.
        this.auth.defaultServicePath = this._servicePath;
        // Set the default scopes in auth client if needed.
        if (servicePath === this._servicePath) {
            this.auth.defaultScopes = staticMembers.scopes;
        }
        this.iamClient = new this._gaxModule.IamClient(this._gaxGrpc, opts);
        this.locationsClient = new this._gaxModule.LocationsClient(this._gaxGrpc, opts);
        // Determine the client header string.
        const clientHeader = [`gax/${this._gaxModule.version}`, `gapic/${version}`];
        if (typeof process === 'object' && 'versions' in process) {
            clientHeader.push(`gl-node/${process.versions.node}`);
        }
        else {
            clientHeader.push(`gl-web/${this._gaxModule.version}`);
        }
        if (!opts.fallback) {
            clientHeader.push(`grpc/${this._gaxGrpc.grpcVersion}`);
        }
        else {
            clientHeader.push(`rest/${this._gaxGrpc.grpcVersion}`);
        }
        if (opts.libName && opts.libVersion) {
            clientHeader.push(`${opts.libName}/${opts.libVersion}`);
        }
        // Load the applicable protos.
        this._protos = this._gaxGrpc.loadProtoJSON(jsonProtos);
        // This API contains "path templates"; forward-slash-separated
        // identifiers to uniquely identify resources within the API.
        // Create useful helper objects for these.
        this.pathTemplates = {
            connectionProfilePathTemplate: new this._gaxModule.PathTemplate('projects/{project}/locations/{location}/connectionProfiles/{connection_profile}'),
            locationPathTemplate: new this._gaxModule.PathTemplate('projects/{project}/locations/{location}'),
            privateConnectionPathTemplate: new this._gaxModule.PathTemplate('projects/{project}/locations/{location}/privateConnections/{private_connection}'),
            projectPathTemplate: new this._gaxModule.PathTemplate('projects/{project}'),
            routePathTemplate: new this._gaxModule.PathTemplate('projects/{project}/locations/{location}/privateConnections/{private_connection}/routes/{route}'),
            streamPathTemplate: new this._gaxModule.PathTemplate('projects/{project}/locations/{location}/streams/{stream}'),
            streamObjectPathTemplate: new this._gaxModule.PathTemplate('projects/{project}/locations/{location}/streams/{stream}/objects/{object}'),
        };
        // Some of the methods on this service return "paged" results,
        // (e.g. 50 results at a time, with tokens to get subsequent
        // pages). Denote the keys used for pagination and results.
        this.descriptors.page = {
            listConnectionProfiles: new this._gaxModule.PageDescriptor('pageToken', 'nextPageToken', 'connectionProfiles'),
            listStreams: new this._gaxModule.PageDescriptor('pageToken', 'nextPageToken', 'streams'),
            listStreamObjects: new this._gaxModule.PageDescriptor('pageToken', 'nextPageToken', 'streamObjects'),
            fetchStaticIps: new this._gaxModule.PageDescriptor('pageToken', 'nextPageToken', 'staticIps'),
            listPrivateConnections: new this._gaxModule.PageDescriptor('pageToken', 'nextPageToken', 'privateConnections'),
            listRoutes: new this._gaxModule.PageDescriptor('pageToken', 'nextPageToken', 'routes'),
        };
        const protoFilesRoot = this._gaxModule.protobufFromJSON(jsonProtos);
        // This API contains "long-running operations", which return a
        // an Operation object that allows for tracking of the operation,
        // rather than holding a request open.
        const lroOptions = {
            auth: this.auth,
            grpc: 'grpc' in this._gaxGrpc ? this._gaxGrpc.grpc : undefined,
        };
        if (opts.fallback) {
            lroOptions.protoJson = protoFilesRoot;
            lroOptions.httpRules = [
                {
                    selector: 'google.cloud.location.Locations.GetLocation',
                    get: '/v1/{name=projects/*/locations/*}',
                },
                {
                    selector: 'google.cloud.location.Locations.ListLocations',
                    get: '/v1/{name=projects/*}/locations',
                },
                {
                    selector: 'google.longrunning.Operations.CancelOperation',
                    post: '/v1/{name=projects/*/locations/*/operations/*}:cancel',
                    body: '*',
                },
                {
                    selector: 'google.longrunning.Operations.DeleteOperation',
                    delete: '/v1/{name=projects/*/locations/*/operations/*}',
                },
                {
                    selector: 'google.longrunning.Operations.GetOperation',
                    get: '/v1/{name=projects/*/locations/*/operations/*}',
                },
                {
                    selector: 'google.longrunning.Operations.ListOperations',
                    get: '/v1/{name=projects/*/locations/*}/operations',
                },
            ];
        }
        this.operationsClient = this._gaxModule
            .lro(lroOptions)
            .operationsClient(opts);
        const createConnectionProfileResponse = protoFilesRoot.lookup('.google.cloud.datastream.v1.ConnectionProfile');
        const createConnectionProfileMetadata = protoFilesRoot.lookup('.google.cloud.datastream.v1.OperationMetadata');
        const updateConnectionProfileResponse = protoFilesRoot.lookup('.google.cloud.datastream.v1.ConnectionProfile');
        const updateConnectionProfileMetadata = protoFilesRoot.lookup('.google.cloud.datastream.v1.OperationMetadata');
        const deleteConnectionProfileResponse = protoFilesRoot.lookup('.google.protobuf.Empty');
        const deleteConnectionProfileMetadata = protoFilesRoot.lookup('.google.cloud.datastream.v1.OperationMetadata');
        const createStreamResponse = protoFilesRoot.lookup('.google.cloud.datastream.v1.Stream');
        const createStreamMetadata = protoFilesRoot.lookup('.google.cloud.datastream.v1.OperationMetadata');
        const updateStreamResponse = protoFilesRoot.lookup('.google.cloud.datastream.v1.Stream');
        const updateStreamMetadata = protoFilesRoot.lookup('.google.cloud.datastream.v1.OperationMetadata');
        const deleteStreamResponse = protoFilesRoot.lookup('.google.protobuf.Empty');
        const deleteStreamMetadata = protoFilesRoot.lookup('.google.cloud.datastream.v1.OperationMetadata');
        const runStreamResponse = protoFilesRoot.lookup('.google.cloud.datastream.v1.Stream');
        const runStreamMetadata = protoFilesRoot.lookup('.google.cloud.datastream.v1.OperationMetadata');
        const createPrivateConnectionResponse = protoFilesRoot.lookup('.google.cloud.datastream.v1.PrivateConnection');
        const createPrivateConnectionMetadata = protoFilesRoot.lookup('.google.cloud.datastream.v1.OperationMetadata');
        const deletePrivateConnectionResponse = protoFilesRoot.lookup('.google.protobuf.Empty');
        const deletePrivateConnectionMetadata = protoFilesRoot.lookup('.google.cloud.datastream.v1.OperationMetadata');
        const createRouteResponse = protoFilesRoot.lookup('.google.cloud.datastream.v1.Route');
        const createRouteMetadata = protoFilesRoot.lookup('.google.cloud.datastream.v1.OperationMetadata');
        const deleteRouteResponse = protoFilesRoot.lookup('.google.protobuf.Empty');
        const deleteRouteMetadata = protoFilesRoot.lookup('.google.cloud.datastream.v1.OperationMetadata');
        this.descriptors.longrunning = {
            createConnectionProfile: new this._gaxModule.LongrunningDescriptor(this.operationsClient, createConnectionProfileResponse.decode.bind(createConnectionProfileResponse), createConnectionProfileMetadata.decode.bind(createConnectionProfileMetadata)),
            updateConnectionProfile: new this._gaxModule.LongrunningDescriptor(this.operationsClient, updateConnectionProfileResponse.decode.bind(updateConnectionProfileResponse), updateConnectionProfileMetadata.decode.bind(updateConnectionProfileMetadata)),
            deleteConnectionProfile: new this._gaxModule.LongrunningDescriptor(this.operationsClient, deleteConnectionProfileResponse.decode.bind(deleteConnectionProfileResponse), deleteConnectionProfileMetadata.decode.bind(deleteConnectionProfileMetadata)),
            createStream: new this._gaxModule.LongrunningDescriptor(this.operationsClient, createStreamResponse.decode.bind(createStreamResponse), createStreamMetadata.decode.bind(createStreamMetadata)),
            updateStream: new this._gaxModule.LongrunningDescriptor(this.operationsClient, updateStreamResponse.decode.bind(updateStreamResponse), updateStreamMetadata.decode.bind(updateStreamMetadata)),
            deleteStream: new this._gaxModule.LongrunningDescriptor(this.operationsClient, deleteStreamResponse.decode.bind(deleteStreamResponse), deleteStreamMetadata.decode.bind(deleteStreamMetadata)),
            runStream: new this._gaxModule.LongrunningDescriptor(this.operationsClient, runStreamResponse.decode.bind(runStreamResponse), runStreamMetadata.decode.bind(runStreamMetadata)),
            createPrivateConnection: new this._gaxModule.LongrunningDescriptor(this.operationsClient, createPrivateConnectionResponse.decode.bind(createPrivateConnectionResponse), createPrivateConnectionMetadata.decode.bind(createPrivateConnectionMetadata)),
            deletePrivateConnection: new this._gaxModule.LongrunningDescriptor(this.operationsClient, deletePrivateConnectionResponse.decode.bind(deletePrivateConnectionResponse), deletePrivateConnectionMetadata.decode.bind(deletePrivateConnectionMetadata)),
            createRoute: new this._gaxModule.LongrunningDescriptor(this.operationsClient, createRouteResponse.decode.bind(createRouteResponse), createRouteMetadata.decode.bind(createRouteMetadata)),
            deleteRoute: new this._gaxModule.LongrunningDescriptor(this.operationsClient, deleteRouteResponse.decode.bind(deleteRouteResponse), deleteRouteMetadata.decode.bind(deleteRouteMetadata)),
        };
        // Put together the default options sent with requests.
        this._defaults = this._gaxGrpc.constructSettings('google.cloud.datastream.v1.Datastream', gapicConfig, opts.clientConfig || {}, { 'x-goog-api-client': clientHeader.join(' ') });
        // Set up a dictionary of "inner API calls"; the core implementation
        // of calling the API is handled in `google-gax`, with this code
        // merely providing the destination and request information.
        this.innerApiCalls = {};
        // Add a warn function to the client constructor so it can be easily tested.
        this.warn = this._gaxModule.warn;
    }
    /**
     * 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() {
        // If the client stub promise is already initialized, return immediately.
        if (this.datastreamStub) {
            return this.datastreamStub;
        }
        // Put together the "service stub" for
        // google.cloud.datastream.v1.Datastream.
        this.datastreamStub = this._gaxGrpc.createStub(this._opts.fallback
            ? this._protos.lookupService('google.cloud.datastream.v1.Datastream')
            : // eslint-disable-next-line @typescript-eslint/no-explicit-any
                this._protos.google.cloud.datastream.v1.Datastream, this._opts, this._providedCustomServicePath);
        // Iterate over each of the methods that the service provides
        // and create an API call method for each.
        const datastreamStubMethods = [
            'listConnectionProfiles',
            'getConnectionProfile',
            'createConnectionProfile',
            'updateConnectionProfile',
            'deleteConnectionProfile',
            'discoverConnectionProfile',
            'listStreams',
            'getStream',
            'createStream',
            'updateStream',
            'deleteStream',
            'runStream',
            'getStreamObject',
            'lookupStreamObject',
            'listStreamObjects',
            'startBackfillJob',
            'stopBackfillJob',
            'fetchStaticIps',
            'createPrivateConnection',
            'getPrivateConnection',
            'listPrivateConnections',
            'deletePrivateConnection',
            'createRoute',
            'getRoute',
            'listRoutes',
            'deleteRoute',
        ];
        for (const methodName of datastreamStubMethods) {
            const callPromise = this.datastreamStub.then((stub) => (...args) => {
                if (this._terminated) {
                    return Promise.reject('The client has already been closed.');
                }
                const func = stub[methodName];
                return func.apply(stub, args);
            }, (err) => () => {
                throw err;
            });
            const descriptor = this.descriptors.page[methodName] ||
                this.descriptors.longrunning[methodName] ||
                undefined;
            const apiCall = this._gaxModule.createApiCall(callPromise, this._defaults[methodName], descriptor, this._opts.fallback);
            this.innerApiCalls[methodName] = apiCall;
        }
        return this.datastreamStub;
    }
    /**
     * 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() {
        if (typeof process === 'object' &&
            typeof process.emitWarning === 'function') {
            process.emitWarning('Static servicePath is deprecated, please use the instance method instead.', 'DeprecationWarning');
        }
        return 'datastream.googleapis.com';
    }
    /**
     * 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() {
        if (typeof process === 'object' &&
            typeof process.emitWarning === 'function') {
            process.emitWarning('Static apiEndpoint is deprecated, please use the instance method instead.', 'DeprecationWarning');
        }
        return 'datastream.googleapis.com';
    }
    /**
     * The DNS address for this API service.
     * @returns {string} The DNS address for this service.
     */
    get apiEndpoint() {
        return this._servicePath;
    }
    get universeDomain() {
        return this._universeDomain;
    }
    /**
     * The port for this API service.
     * @returns {number} The default port for this service.
     */
    static get port() {
        return 443;
    }
    /**
     * The scopes needed to make gRPC calls for every method defined
     * in this service.
     * @returns {string[]} List of default scopes.
     */
    static get scopes() {
        return ['https://www.googleapis.com/auth/cloud-platform'];
    }
    /**
     * Return the project ID used by this class.
     * @returns {Promise} A promise that resolves to string containing the project ID.
     */
    getProjectId(callback) {
        if (callback) {
            this.auth.getProjectId(callback);
            return;
        }
        return this.auth.getProjectId();
    }
    getConnectionProfile(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('getConnectionProfile request %j', request);
        const wrappedCallback = callback
            ? (error, response, options, rawResponse) => {
                this._log.info('getConnectionProfile response %j', response);
                callback(error, response, options, rawResponse); // We verified callback above.
            }
            : undefined;
        return this.innerApiCalls
            .getConnectionProfile(request, options, wrappedCallback)
            ?.then(([response, options, rawResponse]) => {
            this._log.info('getConnectionProfile response %j', response);
            return [response, options, rawResponse];
        })
            .catch((error) => {
            if (error &&
                'statusDetails' in error &&
                error.statusDetails instanceof Array) {
                const protos = this._gaxModule.protobuf.Root.fromJSON(jsonProtos);
                error.statusDetails = (0, google_gax_1.decodeAnyProtosInArray)(error.statusDetails, protos);
            }
            throw error;
        });
    }
    discoverConnectionProfile(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('discoverConnectionProfile request %j', request);
        const wrappedCallback = callback
            ? (error, response, options, rawResponse) => {
                this._log.info('discoverConnectionProfile response %j', response);
                callback(error, response, options, rawResponse); // We verified callback above.
            }
            : undefined;
        return this.innerApiCalls
            .discoverConnectionProfile(request, options, wrappedCallback)
            ?.then(([response, options, rawResponse]) => {
            this._log.info('discoverConnectionProfile response %j', response);
            return [response, options, rawResponse];
        })
            .catch((error) => {
            if (error &&
                'statusDetails' in error &&
                error.statusDetails instanceof Array) {
                const protos = this._gaxModule.protobuf.Root.fromJSON(jsonProtos);
                error.statusDetails = (0, google_gax_1.decodeAnyProtosInArray)(error.statusDetails, protos);
            }
            throw error;
        });
    }
    getStream(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('getStream request %j', request);
        const wrappedCallback = callback
            ? (error, response, options, rawResponse) => {
                this._log.info('getStream response %j', response);
                callback(error, response, options, rawResponse); // We verified callback above.
            }
            : undefined;
        return this.innerApiCalls
            .getStream(request, options, wrappedCallback)
            ?.then(([response, options, rawResponse]) => {
            this._log.info('getStream response %j', response);
            return [response, options, rawResponse];
        })
            .catch((error) => {
            if (error &&
                'statusDetails' in error &&
                error.statusDetails instanceof Array) {
                const protos = this._gaxModule.protobuf.Root.fromJSON(jsonProtos);
                error.statusDetails = (0, google_gax_1.decodeAnyProtosInArray)(error.statusDetails, protos);
            }
            throw error;
        });
    }
    getStreamObject(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('getStreamObject request %j', request);
        const wrappedCallback = callback
            ? (error, response, options, rawResponse) => {
                this._log.info('getStreamObject response %j', response);
                callback(error, response, options, rawResponse); // We verified callback above.
            }
            : undefined;
        return this.innerApiCalls
            .getStreamObject(request, options, wrappedCallback)
            ?.then(([response, options, rawResponse]) => {
            this._log.info('getStreamObject response %j', response);
            return [response, options, rawResponse];
        })
            .catch((error) => {
            if (error &&
                'statusDetails' in error &&
                error.statusDetails instanceof Array) {
                const protos = this._gaxModule.protobuf.Root.fromJSON(jsonProtos);
                error.statusDetails = (0, google_gax_1.decodeAnyProtosInArray)(error.statusDetails, protos);
            }
            throw error;
        });
    }
    lookupStreamObject(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('lookupStreamObject request %j', request);
        const wrappedCallback = callback
            ? (error, response, options, rawResponse) => {
                this._log.info('lookupStreamObject response %j', response);
                callback(error, response, options, rawResponse); // We verified callback above.
            }
            : undefined;
        return this.innerApiCalls
            .lookupStreamObject(request, options, wrappedCallback)
            ?.then(([response, options, rawResponse]) => {
            this._log.info('lookupStreamObject response %j', response);
            return [response, options, rawResponse];
        })
            .catch((error) => {
            if (error &&
                'statusDetails' in error &&
                error.statusDetails instanceof Array) {
                const protos = this._gaxModule.protobuf.Root.fromJSON(jsonProtos);
                error.statusDetails = (0, google_gax_1.decodeAnyProtosInArray)(error.statusDetails, protos);
            }
            throw error;
        });
    }
    startBackfillJob(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                object: request.object ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('startBackfillJob request %j', request);
        const wrappedCallback = callback
            ? (error, response, options, rawResponse) => {
                this._log.info('startBackfillJob response %j', response);
                callback(error, response, options, rawResponse); // We verified callback above.
            }
            : undefined;
        return this.innerApiCalls
            .startBackfillJob(request, options, wrappedCallback)
            ?.then(([response, options, rawResponse]) => {
            this._log.info('startBackfillJob response %j', response);
            return [response, options, rawResponse];
        })
            .catch((error) => {
            if (error &&
                'statusDetails' in error &&
                error.statusDetails instanceof Array) {
                const protos = this._gaxModule.protobuf.Root.fromJSON(jsonProtos);
                error.statusDetails = (0, google_gax_1.decodeAnyProtosInArray)(error.statusDetails, protos);
            }
            throw error;
        });
    }
    stopBackfillJob(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                object: request.object ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('stopBackfillJob request %j', request);
        const wrappedCallback = callback
            ? (error, response, options, rawResponse) => {
                this._log.info('stopBackfillJob response %j', response);
                callback(error, response, options, rawResponse); // We verified callback above.
            }
            : undefined;
        return this.innerApiCalls
            .stopBackfillJob(request, options, wrappedCallback)
            ?.then(([response, options, rawResponse]) => {
            this._log.info('stopBackfillJob response %j', response);
            return [response, options, rawResponse];
        })
            .catch((error) => {
            if (error &&
                'statusDetails' in error &&
                error.statusDetails instanceof Array) {
                const protos = this._gaxModule.protobuf.Root.fromJSON(jsonProtos);
                error.statusDetails = (0, google_gax_1.decodeAnyProtosInArray)(error.statusDetails, protos);
            }
            throw error;
        });
    }
    getPrivateConnection(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('getPrivateConnection request %j', request);
        const wrappedCallback = callback
            ? (error, response, options, rawResponse) => {
                this._log.info('getPrivateConnection response %j', response);
                callback(error, response, options, rawResponse); // We verified callback above.
            }
            : undefined;
        return this.innerApiCalls
            .getPrivateConnection(request, options, wrappedCallback)
            ?.then(([response, options, rawResponse]) => {
            this._log.info('getPrivateConnection response %j', response);
            return [response, options, rawResponse];
        })
            .catch((error) => {
            if (error &&
                'statusDetails' in error &&
                error.statusDetails instanceof Array) {
                const protos = this._gaxModule.protobuf.Root.fromJSON(jsonProtos);
                error.statusDetails = (0, google_gax_1.decodeAnyProtosInArray)(error.statusDetails, protos);
            }
            throw error;
        });
    }
    getRoute(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('getRoute request %j', request);
        const wrappedCallback = callback
            ? (error, response, options, rawResponse) => {
                this._log.info('getRoute response %j', response);
                callback(error, response, options, rawResponse); // We verified callback above.
            }
            : undefined;
        return this.innerApiCalls
            .getRoute(request, options, wrappedCallback)
            ?.then(([response, options, rawResponse]) => {
            this._log.info('getRoute response %j', response);
            return [response, options, rawResponse];
        })
            .catch((error) => {
            if (error &&
                'statusDetails' in error &&
                error.statusDetails instanceof Array) {
                const protos = this._gaxModule.protobuf.Root.fromJSON(jsonProtos);
                error.statusDetails = (0, google_gax_1.decodeAnyProtosInArray)(error.statusDetails, protos);
            }
            throw error;
        });
    }
    createConnectionProfile(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, response, rawResponse, _) => {
                this._log.info('createConnectionProfile response %j', rawResponse);
                callback(error, response, rawResponse, _); // We verified callback above.
            }
            : undefined;
        this._log.info('createConnectionProfile request %j', request);
        return this.innerApiCalls
            .createConnectionProfile(request, options, wrappedCallback)
            ?.then(([response, rawResponse, _]) => {
            this._log.info('createConnectionProfile response %j', rawResponse);
            return [response, rawResponse, _];
        });
    }
    /**
     * 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 <caption>include:samples/generated/v1/datastream.create_connection_profile.js</caption>
     * region_tag:datastream_v1_generated_Datastream_CreateConnectionProfile_async
     */
    async checkCreateConnectionProfileProgress(name) {
        this._log.info('createConnectionProfile long-running');
        const request = new this._gaxModule.operationsProtos.google.longrunning.GetOperationRequest({ name });
        const [operation] = await this.operationsClient.getOperation(request);
        const decodeOperation = new this._gaxModule.Operation(operation, this.descriptors.longrunning.createConnectionProfile, this._gaxModule.createDefaultBackoffSettings());
        return decodeOperation;
    }
    updateConnectionProfile(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                'connection_profile.name': request.connectionProfile.name ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, response, rawResponse, _) => {
                this._log.info('updateConnectionProfile response %j', rawResponse);
                callback(error, response, rawResponse, _); // We verified callback above.
            }
            : undefined;
        this._log.info('updateConnectionProfile request %j', request);
        return this.innerApiCalls
            .updateConnectionProfile(request, options, wrappedCallback)
            ?.then(([response, rawResponse, _]) => {
            this._log.info('updateConnectionProfile response %j', rawResponse);
            return [response, rawResponse, _];
        });
    }
    /**
     * 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 <caption>include:samples/generated/v1/datastream.update_connection_profile.js</caption>
     * region_tag:datastream_v1_generated_Datastream_UpdateConnectionProfile_async
     */
    async checkUpdateConnectionProfileProgress(name) {
        this._log.info('updateConnectionProfile long-running');
        const request = new this._gaxModule.operationsProtos.google.longrunning.GetOperationRequest({ name });
        const [operation] = await this.operationsClient.getOperation(request);
        const decodeOperation = new this._gaxModule.Operation(operation, this.descriptors.longrunning.updateConnectionProfile, this._gaxModule.createDefaultBackoffSettings());
        return decodeOperation;
    }
    deleteConnectionProfile(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, response, rawResponse, _) => {
                this._log.info('deleteConnectionProfile response %j', rawResponse);
                callback(error, response, rawResponse, _); // We verified callback above.
            }
            : undefined;
        this._log.info('deleteConnectionProfile request %j', request);
        return this.innerApiCalls
            .deleteConnectionProfile(request, options, wrappedCallback)
            ?.then(([response, rawResponse, _]) => {
            this._log.info('deleteConnectionProfile response %j', rawResponse);
            return [response, rawResponse, _];
        });
    }
    /**
     * 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 <caption>include:samples/generated/v1/datastream.delete_connection_profile.js</caption>
     * region_tag:datastream_v1_generated_Datastream_DeleteConnectionProfile_async
     */
    async checkDeleteConnectionProfileProgress(name) {
        this._log.info('deleteConnectionProfile long-running');
        const request = new this._gaxModule.operationsProtos.google.longrunning.GetOperationRequest({ name });
        const [operation] = await this.operationsClient.getOperation(request);
        const decodeOperation = new this._gaxModule.Operation(operation, this.descriptors.longrunning.deleteConnectionProfile, this._gaxModule.createDefaultBackoffSettings());
        return decodeOperation;
    }
    createStream(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, response, rawResponse, _) => {
                this._log.info('createStream response %j', rawResponse);
                callback(error, response, rawResponse, _); // We verified callback above.
            }
            : undefined;
        this._log.info('createStream request %j', request);
        return this.innerApiCalls
            .createStream(request, options, wrappedCallback)
            ?.then(([response, rawResponse, _]) => {
            this._log.info('createStream response %j', rawResponse);
            return [response, rawResponse, _];
        });
    }
    /**
     * 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 <caption>include:samples/generated/v1/datastream.create_stream.js</caption>
     * region_tag:datastream_v1_generated_Datastream_CreateStream_async
     */
    async checkCreateStreamProgress(name) {
        this._log.info('createStream long-running');
        const request = new this._gaxModule.operationsProtos.google.longrunning.GetOperationRequest({ name });
        const [operation] = await this.operationsClient.getOperation(request);
        const decodeOperation = new this._gaxModule.Operation(operation, this.descriptors.longrunning.createStream, this._gaxModule.createDefaultBackoffSettings());
        return decodeOperation;
    }
    updateStream(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                'stream.name': request.stream.name ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, response, rawResponse, _) => {
                this._log.info('updateStream response %j', rawResponse);
                callback(error, response, rawResponse, _); // We verified callback above.
            }
            : undefined;
        this._log.info('updateStream request %j', request);
        return this.innerApiCalls
            .updateStream(request, options, wrappedCallback)
            ?.then(([response, rawResponse, _]) => {
            this._log.info('updateStream response %j', rawResponse);
            return [response, rawResponse, _];
        });
    }
    /**
     * 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 <caption>include:samples/generated/v1/datastream.update_stream.js</caption>
     * region_tag:datastream_v1_generated_Datastream_UpdateStream_async
     */
    async checkUpdateStreamProgress(name) {
        this._log.info('updateStream long-running');
        const request = new this._gaxModule.operationsProtos.google.longrunning.GetOperationRequest({ name });
        const [operation] = await this.operationsClient.getOperation(request);
        const decodeOperation = new this._gaxModule.Operation(operation, this.descriptors.longrunning.updateStream, this._gaxModule.createDefaultBackoffSettings());
        return decodeOperation;
    }
    deleteStream(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, response, rawResponse, _) => {
                this._log.info('deleteStream response %j', rawResponse);
                callback(error, response, rawResponse, _); // We verified callback above.
            }
            : undefined;
        this._log.info('deleteStream request %j', request);
        return this.innerApiCalls
            .deleteStream(request, options, wrappedCallback)
            ?.then(([response, rawResponse, _]) => {
            this._log.info('deleteStream response %j', rawResponse);
            return [response, rawResponse, _];
        });
    }
    /**
     * 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 <caption>include:samples/generated/v1/datastream.delete_stream.js</caption>
     * region_tag:datastream_v1_generated_Datastream_DeleteStream_async
     */
    async checkDeleteStreamProgress(name) {
        this._log.info('deleteStream long-running');
        const request = new this._gaxModule.operationsProtos.google.longrunning.GetOperationRequest({ name });
        const [operation] = await this.operationsClient.getOperation(request);
        const decodeOperation = new this._gaxModule.Operation(operation, this.descriptors.longrunning.deleteStream, this._gaxModule.createDefaultBackoffSettings());
        return decodeOperation;
    }
    runStream(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, response, rawResponse, _) => {
                this._log.info('runStream response %j', rawResponse);
                callback(error, response, rawResponse, _); // We verified callback above.
            }
            : undefined;
        this._log.info('runStream request %j', request);
        return this.innerApiCalls
            .runStream(request, options, wrappedCallback)
            ?.then(([response, rawResponse, _]) => {
            this._log.info('runStream response %j', rawResponse);
            return [response, rawResponse, _];
        });
    }
    /**
     * Check the status of the long running operation returned by `runStream()`.
     * @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 <caption>include:samples/generated/v1/datastream.run_stream.js</caption>
     * region_tag:datastream_v1_generated_Datastream_RunStream_async
     */
    async checkRunStreamProgress(name) {
        this._log.info('runStream long-running');
        const request = new this._gaxModule.operationsProtos.google.longrunning.GetOperationRequest({ name });
        const [operation] = await this.operationsClient.getOperation(request);
        const decodeOperation = new this._gaxModule.Operation(operation, this.descriptors.longrunning.runStream, this._gaxModule.createDefaultBackoffSettings());
        return decodeOperation;
    }
    createPrivateConnection(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, response, rawResponse, _) => {
                this._log.info('createPrivateConnection response %j', rawResponse);
                callback(error, response, rawResponse, _); // We verified callback above.
            }
            : undefined;
        this._log.info('createPrivateConnection request %j', request);
        return this.innerApiCalls
            .createPrivateConnection(request, options, wrappedCallback)
            ?.then(([response, rawResponse, _]) => {
            this._log.info('createPrivateConnection response %j', rawResponse);
            return [response, rawResponse, _];
        });
    }
    /**
     * 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 <caption>include:samples/generated/v1/datastream.create_private_connection.js</caption>
     * region_tag:datastream_v1_generated_Datastream_CreatePrivateConnection_async
     */
    async checkCreatePrivateConnectionProgress(name) {
        this._log.info('createPrivateConnection long-running');
        const request = new this._gaxModule.operationsProtos.google.longrunning.GetOperationRequest({ name });
        const [operation] = await this.operationsClient.getOperation(request);
        const decodeOperation = new this._gaxModule.Operation(operation, this.descriptors.longrunning.createPrivateConnection, this._gaxModule.createDefaultBackoffSettings());
        return decodeOperation;
    }
    deletePrivateConnection(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, response, rawResponse, _) => {
                this._log.info('deletePrivateConnection response %j', rawResponse);
                callback(error, response, rawResponse, _); // We verified callback above.
            }
            : undefined;
        this._log.info('deletePrivateConnection request %j', request);
        return this.innerApiCalls
            .deletePrivateConnection(request, options, wrappedCallback)
            ?.then(([response, rawResponse, _]) => {
            this._log.info('deletePrivateConnection response %j', rawResponse);
            return [response, rawResponse, _];
        });
    }
    /**
     * 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 <caption>include:samples/generated/v1/datastream.delete_private_connection.js</caption>
     * region_tag:datastream_v1_generated_Datastream_DeletePrivateConnection_async
     */
    async checkDeletePrivateConnectionProgress(name) {
        this._log.info('deletePrivateConnection long-running');
        const request = new this._gaxModule.operationsProtos.google.longrunning.GetOperationRequest({ name });
        const [operation] = await this.operationsClient.getOperation(request);
        const decodeOperation = new this._gaxModule.Operation(operation, this.descriptors.longrunning.deletePrivateConnection, this._gaxModule.createDefaultBackoffSettings());
        return decodeOperation;
    }
    createRoute(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, response, rawResponse, _) => {
                this._log.info('createRoute response %j', rawResponse);
                callback(error, response, rawResponse, _); // We verified callback above.
            }
            : undefined;
        this._log.info('createRoute request %j', request);
        return this.innerApiCalls
            .createRoute(request, options, wrappedCallback)
            ?.then(([response, rawResponse, _]) => {
            this._log.info('createRoute response %j', rawResponse);
            return [response, rawResponse, _];
        });
    }
    /**
     * 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 <caption>include:samples/generated/v1/datastream.create_route.js</caption>
     * region_tag:datastream_v1_generated_Datastream_CreateRoute_async
     */
    async checkCreateRouteProgress(name) {
        this._log.info('createRoute long-running');
        const request = new this._gaxModule.operationsProtos.google.longrunning.GetOperationRequest({ name });
        const [operation] = await this.operationsClient.getOperation(request);
        const decodeOperation = new this._gaxModule.Operation(operation, this.descriptors.longrunning.createRoute, this._gaxModule.createDefaultBackoffSettings());
        return decodeOperation;
    }
    deleteRoute(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, response, rawResponse, _) => {
                this._log.info('deleteRoute response %j', rawResponse);
                callback(error, response, rawResponse, _); // We verified callback above.
            }
            : undefined;
        this._log.info('deleteRoute request %j', request);
        return this.innerApiCalls
            .deleteRoute(request, options, wrappedCallback)
            ?.then(([response, rawResponse, _]) => {
            this._log.info('deleteRoute response %j', rawResponse);
            return [response, rawResponse, _];
        });
    }
    /**
     * 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 <caption>include:samples/generated/v1/datastream.delete_route.js</caption>
     * region_tag:datastream_v1_generated_Datastream_DeleteRoute_async
     */
    async checkDeleteRouteProgress(name) {
        this._log.info('deleteRoute long-running');
        const request = new this._gaxModule.operationsProtos.google.longrunning.GetOperationRequest({ name });
        const [operation] = await this.operationsClient.getOperation(request);
        const decodeOperation = new this._gaxModule.Operation(operation, this.descriptors.longrunning.deleteRoute, this._gaxModule.createDefaultBackoffSettings());
        return decodeOperation;
    }
    listConnectionProfiles(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, values, nextPageRequest, rawResponse) => {
                this._log.info('listConnectionProfiles values %j', values);
                callback(error, values, nextPageRequest, rawResponse); // We verified callback above.
            }
            : undefined;
        this._log.info('listConnectionProfiles request %j', request);
        return this.innerApiCalls
            .listConnectionProfiles(request, options, wrappedCallback)
            ?.then(([response, input, output]) => {
            this._log.info('listConnectionProfiles values %j', response);
            return [response, input, output];
        });
    }
    /**
     * 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.v1.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, options) {
        request = request || {};
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        const defaultCallSettings = this._defaults['listConnectionProfiles'];
        const callSettings = defaultCallSettings.merge(options);
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('listConnectionProfiles stream %j', request);
        return this.descriptors.page.listConnectionProfiles.createStream(this.innerApiCalls.listConnectionProfiles, request, callSettings);
    }
    /**
     * 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.v1.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 <caption>include:samples/generated/v1/datastream.list_connection_profiles.js</caption>
     * region_tag:datastream_v1_generated_Datastream_ListConnectionProfiles_async
     */
    listConnectionProfilesAsync(request, options) {
        request = request || {};
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        const defaultCallSettings = this._defaults['listConnectionProfiles'];
        const callSettings = defaultCallSettings.merge(options);
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('listConnectionProfiles iterate %j', request);
        return this.descriptors.page.listConnectionProfiles.asyncIterate(this.innerApiCalls['listConnectionProfiles'], request, callSettings);
    }
    listStreams(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, values, nextPageRequest, rawResponse) => {
                this._log.info('listStreams values %j', values);
                callback(error, values, nextPageRequest, rawResponse); // We verified callback above.
            }
            : undefined;
        this._log.info('listStreams request %j', request);
        return this.innerApiCalls
            .listStreams(request, options, wrappedCallback)
            ?.then(([response, input, output]) => {
            this._log.info('listStreams values %j', response);
            return [response, input, output];
        });
    }
    /**
     * 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.v1.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, options) {
        request = request || {};
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        const defaultCallSettings = this._defaults['listStreams'];
        const callSettings = defaultCallSettings.merge(options);
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('listStreams stream %j', request);
        return this.descriptors.page.listStreams.createStream(this.innerApiCalls.listStreams, request, callSettings);
    }
    /**
     * 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.v1.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 <caption>include:samples/generated/v1/datastream.list_streams.js</caption>
     * region_tag:datastream_v1_generated_Datastream_ListStreams_async
     */
    listStreamsAsync(request, options) {
        request = request || {};
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        const defaultCallSettings = this._defaults['listStreams'];
        const callSettings = defaultCallSettings.merge(options);
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('listStreams iterate %j', request);
        return this.descriptors.page.listStreams.asyncIterate(this.innerApiCalls['listStreams'], request, callSettings);
    }
    listStreamObjects(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, values, nextPageRequest, rawResponse) => {
                this._log.info('listStreamObjects values %j', values);
                callback(error, values, nextPageRequest, rawResponse); // We verified callback above.
            }
            : undefined;
        this._log.info('listStreamObjects request %j', request);
        return this.innerApiCalls
            .listStreamObjects(request, options, wrappedCallback)
            ?.then(([response, input, output]) => {
            this._log.info('listStreamObjects values %j', response);
            return [response, input, output];
        });
    }
    /**
     * Equivalent to `listStreamObjects`, but returns a NodeJS Stream object.
     * @param {Object} request
     *   The request object that will be sent.
     * @param {string} request.parent
     *   Required. The parent stream that owns the collection of objects.
     * @param {number} request.pageSize
     *   Maximum number of objects to return. Default is 50.
     *   The maximum value is 1000; values above 1000 will be coerced to 1000.
     * @param {string} request.pageToken
     *   Page token received from a previous `ListStreamObjectsRequest` call.
     *   Provide this to retrieve the subsequent page.
     *
     *   When paginating, all other parameters provided to
     *   `ListStreamObjectsRequest` must match the call that provided the page
     *   token.
     * @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.v1.StreamObject|StreamObject} 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 `listStreamObjectsAsync()`
     *   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.
     */
    listStreamObjectsStream(request, options) {
        request = request || {};
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        const defaultCallSettings = this._defaults['listStreamObjects'];
        const callSettings = defaultCallSettings.merge(options);
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('listStreamObjects stream %j', request);
        return this.descriptors.page.listStreamObjects.createStream(this.innerApiCalls.listStreamObjects, request, callSettings);
    }
    /**
     * Equivalent to `listStreamObjects`, 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 stream that owns the collection of objects.
     * @param {number} request.pageSize
     *   Maximum number of objects to return. Default is 50.
     *   The maximum value is 1000; values above 1000 will be coerced to 1000.
     * @param {string} request.pageToken
     *   Page token received from a previous `ListStreamObjectsRequest` call.
     *   Provide this to retrieve the subsequent page.
     *
     *   When paginating, all other parameters provided to
     *   `ListStreamObjectsRequest` must match the call that provided the page
     *   token.
     * @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.v1.StreamObject|StreamObject}. 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 <caption>include:samples/generated/v1/datastream.list_stream_objects.js</caption>
     * region_tag:datastream_v1_generated_Datastream_ListStreamObjects_async
     */
    listStreamObjectsAsync(request, options) {
        request = request || {};
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        const defaultCallSettings = this._defaults['listStreamObjects'];
        const callSettings = defaultCallSettings.merge(options);
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('listStreamObjects iterate %j', request);
        return this.descriptors.page.listStreamObjects.asyncIterate(this.innerApiCalls['listStreamObjects'], request, callSettings);
    }
    fetchStaticIps(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, values, nextPageRequest, rawResponse) => {
                this._log.info('fetchStaticIps values %j', values);
                callback(error, values, nextPageRequest, rawResponse); // We verified callback above.
            }
            : undefined;
        this._log.info('fetchStaticIps request %j', request);
        return this.innerApiCalls
            .fetchStaticIps(request, options, wrappedCallback)
            ?.then(([response, input, output]) => {
            this._log.info('fetchStaticIps values %j', response);
            return [response, input, output];
        });
    }
    /**
     * 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 resource name for the location for which static IPs should be
     *   returned. 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, options) {
        request = request || {};
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        const defaultCallSettings = this._defaults['fetchStaticIps'];
        const callSettings = defaultCallSettings.merge(options);
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('fetchStaticIps stream %j', request);
        return this.descriptors.page.fetchStaticIps.createStream(this.innerApiCalls.fetchStaticIps, request, callSettings);
    }
    /**
     * 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 resource name for the location for which static IPs should be
     *   returned. 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 <caption>include:samples/generated/v1/datastream.fetch_static_ips.js</caption>
     * region_tag:datastream_v1_generated_Datastream_FetchStaticIps_async
     */
    fetchStaticIpsAsync(request, options) {
        request = request || {};
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        const defaultCallSettings = this._defaults['fetchStaticIps'];
        const callSettings = defaultCallSettings.merge(options);
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('fetchStaticIps iterate %j', request);
        return this.descriptors.page.fetchStaticIps.asyncIterate(this.innerApiCalls['fetchStaticIps'], request, callSettings);
    }
    listPrivateConnections(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, values, nextPageRequest, rawResponse) => {
                this._log.info('listPrivateConnections values %j', values);
                callback(error, values, nextPageRequest, rawResponse); // We verified callback above.
            }
            : undefined;
        this._log.info('listPrivateConnections request %j', request);
        return this.innerApiCalls
            .listPrivateConnections(request, options, wrappedCallback)
            ?.then(([response, input, output]) => {
            this._log.info('listPrivateConnections values %j', response);
            return [response, input, output];
        });
    }
    /**
     * 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.v1.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, options) {
        request = request || {};
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        const defaultCallSettings = this._defaults['listPrivateConnections'];
        const callSettings = defaultCallSettings.merge(options);
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('listPrivateConnections stream %j', request);
        return this.descriptors.page.listPrivateConnections.createStream(this.innerApiCalls.listPrivateConnections, request, callSettings);
    }
    /**
     * 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.v1.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 <caption>include:samples/generated/v1/datastream.list_private_connections.js</caption>
     * region_tag:datastream_v1_generated_Datastream_ListPrivateConnections_async
     */
    listPrivateConnectionsAsync(request, options) {
        request = request || {};
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        const defaultCallSettings = this._defaults['listPrivateConnections'];
        const callSettings = defaultCallSettings.merge(options);
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('listPrivateConnections iterate %j', request);
        return this.descriptors.page.listPrivateConnections.asyncIterate(this.innerApiCalls['listPrivateConnections'], request, callSettings);
    }
    listRoutes(request, optionsOrCallback, callback) {
        request = request || {};
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        this.initialize().catch((err) => {
            throw err;
        });
        const wrappedCallback = callback
            ? (error, values, nextPageRequest, rawResponse) => {
                this._log.info('listRoutes values %j', values);
                callback(error, values, nextPageRequest, rawResponse); // We verified callback above.
            }
            : undefined;
        this._log.info('listRoutes request %j', request);
        return this.innerApiCalls
            .listRoutes(request, options, wrappedCallback)
            ?.then(([response, input, output]) => {
            this._log.info('listRoutes values %j', response);
            return [response, input, output];
        });
    }
    /**
     * 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.v1.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, options) {
        request = request || {};
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        const defaultCallSettings = this._defaults['listRoutes'];
        const callSettings = defaultCallSettings.merge(options);
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('listRoutes stream %j', request);
        return this.descriptors.page.listRoutes.createStream(this.innerApiCalls.listRoutes, request, callSettings);
    }
    /**
     * 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.v1.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 <caption>include:samples/generated/v1/datastream.list_routes.js</caption>
     * region_tag:datastream_v1_generated_Datastream_ListRoutes_async
     */
    listRoutesAsync(request, options) {
        request = request || {};
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                parent: request.parent ?? '',
            });
        const defaultCallSettings = this._defaults['listRoutes'];
        const callSettings = defaultCallSettings.merge(options);
        this.initialize().catch((err) => {
            throw err;
        });
        this._log.info('listRoutes iterate %j', request);
        return this.descriptors.page.listRoutes.asyncIterate(this.innerApiCalls['listRoutes'], request, callSettings);
    }
    /**
     * Gets the access control policy for a resource. Returns an empty policy
     * if the resource exists and does not have a policy set.
     *
     * @param {Object} request
     *   The request object that will be sent.
     * @param {string} request.resource
     *   REQUIRED: The resource for which the policy is being requested.
     *   See the operation documentation for the appropriate value for this field.
     * @param {Object} [request.options]
     *   OPTIONAL: A `GetPolicyOptions` object for specifying options to
     *   `GetIamPolicy`. This field is only used by Cloud IAM.
     *
     *   This object should have the same structure as {@link google.iam.v1.GetPolicyOptions | GetPolicyOptions}.
     * @param {Object} [options]
     *   Optional parameters. You can override the default settings for this call, e.g, timeout,
     *   retries, paginations, etc. See {@link https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html | gax.CallOptions} for the details.
     * @param {function(?Error, ?Object)} [callback]
     *   The function which will be called with the result of the API call.
     *
     *   The second parameter to the callback is an object representing {@link google.iam.v1.Policy | Policy}.
     * @returns {Promise} - The promise which resolves to an array.
     *   The first element of the array is an object representing {@link google.iam.v1.Policy | Policy}.
     *   The promise has a method named "cancel" which cancels the ongoing API call.
     */
    getIamPolicy(request, options, callback) {
        return this.iamClient.getIamPolicy(request, options, callback);
    }
    /**
     * Returns permissions that a caller has on the specified resource. If the
     * resource does not exist, this will return an empty set of
     * permissions, not a NOT_FOUND error.
     *
     * Note: This operation is designed to be used for building
     * permission-aware UIs and command-line tools, not for authorization
     * checking. This operation may "fail open" without warning.
     *
     * @param {Object} request
     *   The request object that will be sent.
     * @param {string} request.resource
     *   REQUIRED: The resource for which the policy detail is being requested.
     *   See the operation documentation for the appropriate value for this field.
     * @param {string[]} request.permissions
     *   The set of permissions to check for the `resource`. Permissions with
     *   wildcards (such as '*' or 'storage.*') are not allowed. For more
     *   information see {@link https://cloud.google.com/iam/docs/overview#permissions | IAM Overview }.
     * @param {Object} [options]
     *   Optional parameters. You can override the default settings for this call, e.g, timeout,
     *   retries, paginations, etc. See {@link https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html | gax.CallOptions} for the details.
     * @param {function(?Error, ?Object)} [callback]
     *   The function which will be called with the result of the API call.
     *
     *   The second parameter to the callback is an object representing {@link google.iam.v1.TestIamPermissionsResponse | TestIamPermissionsResponse}.
     * @returns {Promise} - The promise which resolves to an array.
     *   The first element of the array is an object representing {@link google.iam.v1.TestIamPermissionsResponse | TestIamPermissionsResponse}.
     *   The promise has a method named "cancel" which cancels the ongoing API call.
     */
    setIamPolicy(request, options, callback) {
        return this.iamClient.setIamPolicy(request, options, callback);
    }
    /**
     * Returns permissions that a caller has on the specified resource. If the
     * resource does not exist, this will return an empty set of
     * permissions, not a NOT_FOUND error.
     *
     * Note: This operation is designed to be used for building
     * permission-aware UIs and command-line tools, not for authorization
     * checking. This operation may "fail open" without warning.
     *
     * @param {Object} request
     *   The request object that will be sent.
     * @param {string} request.resource
     *   REQUIRED: The resource for which the policy detail is being requested.
     *   See the operation documentation for the appropriate value for this field.
     * @param {string[]} request.permissions
     *   The set of permissions to check for the `resource`. Permissions with
     *   wildcards (such as '*' or 'storage.*') are not allowed. For more
     *   information see {@link https://cloud.google.com/iam/docs/overview#permissions | IAM Overview }.
     * @param {Object} [options]
     *   Optional parameters. You can override the default settings for this call, e.g, timeout,
     *   retries, paginations, etc. See {@link https://googleapis.github.io/gax-nodejs/interfaces/CallOptions.html | gax.CallOptions} for the details.
     * @param {function(?Error, ?Object)} [callback]
     *   The function which will be called with the result of the API call.
     *
     *   The second parameter to the callback is an object representing {@link google.iam.v1.TestIamPermissionsResponse | TestIamPermissionsResponse}.
     * @returns {Promise} - The promise which resolves to an array.
     *   The first element of the array is an object representing {@link google.iam.v1.TestIamPermissionsResponse | TestIamPermissionsResponse}.
     *   The promise has a method named "cancel" which cancels the ongoing API call.
     *
     */
    testIamPermissions(request, options, callback) {
        return this.iamClient.testIamPermissions(request, options, callback);
    }
    /**
     * Gets information about a location.
     *
     * @param {Object} request
     *   The request object that will be sent.
     * @param {string} request.name
     *   Resource name for the location.
     * @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 google.cloud.location.Location | Location}.
     *   Please see the {@link https://github.com/googleapis/gax-nodejs/blob/master/client-libraries.md#regular-methods | documentation }
     *   for more details and examples.
     * @example
     * ```
     * const [response] = await client.getLocation(request);
     * ```
     */
    getLocation(request, options, callback) {
        return this.locationsClient.getLocation(request, options, callback);
    }
    /**
     * Lists information about the supported locations for this service. 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
     *   The resource that owns the locations collection, if applicable.
     * @param {string} request.filter
     *   The standard list filter.
     * @param {number} request.pageSize
     *   The standard list page size.
     * @param {string} request.pageToken
     *   The standard list page token.
     * @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 google.cloud.location.Location | Location}. 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
     * ```
     * const iterable = client.listLocationsAsync(request);
     * for await (const response of iterable) {
     *   // process response
     * }
     * ```
     */
    listLocationsAsync(request, options) {
        return this.locationsClient.listLocationsAsync(request, options);
    }
    /**
     * Gets the latest state of a long-running operation.  Clients can use this
     * method to poll the operation result at intervals as recommended by the API
     * service.
     *
     * @param {Object} request - The request object that will be sent.
     * @param {string} request.name - The name of the operation resource.
     * @param {Object=} options
     *   Optional parameters. You can override the default settings for this call,
     *   e.g, timeout, retries, paginations, etc. See {@link
     *   https://googleapis.github.io/gax-nodejs/global.html#CallOptions | gax.CallOptions}
     *   for the details.
     * @param {function(?Error, ?Object)=} callback
     *   The function which will be called with the result of the API call.
     *
     *   The second parameter to the callback is an object representing
     *   {@link google.longrunning.Operation | google.longrunning.Operation}.
     * @return {Promise} - The promise which resolves to an array.
     *   The first element of the array is an object representing
     * {@link google.longrunning.Operation | google.longrunning.Operation}.
     * The promise has a method named "cancel" which cancels the ongoing API call.
     *
     * @example
     * ```
     * const client = longrunning.operationsClient();
     * const name = '';
     * const [response] = await client.getOperation({name});
     * // doThingsWith(response)
     * ```
     */
    getOperation(request, optionsOrCallback, callback) {
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        return this.operationsClient.getOperation(request, options, callback);
    }
    /**
     * Lists operations that match the specified filter in the request. If the
     * server doesn't support this method, it returns `UNIMPLEMENTED`. Returns an iterable object.
     *
     * For-await-of syntax is used with the iterable to recursively get response element on-demand.
     *
     * @param {Object} request - The request object that will be sent.
     * @param {string} request.name - The name of the operation collection.
     * @param {string} request.filter - The standard list filter.
     * @param {number=} request.pageSize -
     *   The maximum number of resources contained in the underlying API
     *   response. If page streaming is performed per-resource, this
     *   parameter does not affect the return value. If page streaming is
     *   performed per-page, this determines the maximum number of
     *   resources in a page.
     * @param {Object=} options
     *   Optional parameters. You can override the default settings for this call,
     *   e.g, timeout, retries, paginations, etc. See {@link
     *   https://googleapis.github.io/gax-nodejs/global.html#CallOptions | gax.CallOptions} for the
     *   details.
     * @returns {Object}
     *   An iterable Object that conforms to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols | iteration protocols}.
     *
     * @example
     * ```
     * const client = longrunning.operationsClient();
     * for await (const response of client.listOperationsAsync(request));
     * // doThingsWith(response)
     * ```
     */
    listOperationsAsync(request, options) {
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        return this.operationsClient.listOperationsAsync(request, options);
    }
    /**
     * Starts asynchronous cancellation on a long-running operation.  The server
     * makes a best effort to cancel the operation, but success is not
     * guaranteed.  If the server doesn't support this method, it returns
     * `google.rpc.Code.UNIMPLEMENTED`.  Clients can use
     * {@link Operations.GetOperation} or
     * other methods to check whether the cancellation succeeded or whether the
     * operation completed despite cancellation. On successful cancellation,
     * the operation is not deleted; instead, it becomes an operation with
     * an {@link Operation.error} value with a {@link google.rpc.Status.code} of
     * 1, corresponding to `Code.CANCELLED`.
     *
     * @param {Object} request - The request object that will be sent.
     * @param {string} request.name - The name of the operation resource to be cancelled.
     * @param {Object=} options
     *   Optional parameters. You can override the default settings for this call,
     * e.g, timeout, retries, paginations, etc. See {@link
     * https://googleapis.github.io/gax-nodejs/global.html#CallOptions | gax.CallOptions} for the
     * details.
     * @param {function(?Error)=} callback
     *   The function which will be called with the result of the API call.
     * @return {Promise} - The promise which resolves when API call finishes.
     *   The promise has a method named "cancel" which cancels the ongoing API
     * call.
     *
     * @example
     * ```
     * const client = longrunning.operationsClient();
     * await client.cancelOperation({name: ''});
     * ```
     */
    cancelOperation(request, optionsOrCallback, callback) {
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        return this.operationsClient.cancelOperation(request, options, callback);
    }
    /**
     * Deletes a long-running operation. This method indicates that the client is
     * no longer interested in the operation result. It does not cancel the
     * operation. If the server doesn't support this method, it returns
     * `google.rpc.Code.UNIMPLEMENTED`.
     *
     * @param {Object} request - The request object that will be sent.
     * @param {string} request.name - The name of the operation resource to be deleted.
     * @param {Object=} options
     *   Optional parameters. You can override the default settings for this call,
     * e.g, timeout, retries, paginations, etc. See {@link
     * https://googleapis.github.io/gax-nodejs/global.html#CallOptions | gax.CallOptions}
     * for the details.
     * @param {function(?Error)=} callback
     *   The function which will be called with the result of the API call.
     * @return {Promise} - The promise which resolves when API call finishes.
     *   The promise has a method named "cancel" which cancels the ongoing API
     * call.
     *
     * @example
     * ```
     * const client = longrunning.operationsClient();
     * await client.deleteOperation({name: ''});
     * ```
     */
    deleteOperation(request, optionsOrCallback, callback) {
        let options;
        if (typeof optionsOrCallback === 'function' && callback === undefined) {
            callback = optionsOrCallback;
            options = {};
        }
        else {
            options = optionsOrCallback;
        }
        options = options || {};
        options.otherArgs = options.otherArgs || {};
        options.otherArgs.headers = options.otherArgs.headers || {};
        options.otherArgs.headers['x-goog-request-params'] =
            this._gaxModule.routingHeader.fromParams({
                name: request.name ?? '',
            });
        return this.operationsClient.deleteOperation(request, options, callback);
    }
    // --------------------
    // -- Path templates --
    // --------------------
    /**
     * 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, location, connectionProfile) {
        return this.pathTemplates.connectionProfilePathTemplate.render({
            project: project,
            location: location,
            connection_profile: connectionProfile,
        });
    }
    /**
     * 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) {
        return this.pathTemplates.connectionProfilePathTemplate.match(connectionProfileName).project;
    }
    /**
     * 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) {
        return this.pathTemplates.connectionProfilePathTemplate.match(connectionProfileName).location;
    }
    /**
     * 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) {
        return this.pathTemplates.connectionProfilePathTemplate.match(connectionProfileName).connection_profile;
    }
    /**
     * Return a fully-qualified location resource name string.
     *
     * @param {string} project
     * @param {string} location
     * @returns {string} Resource name string.
     */
    locationPath(project, location) {
        return this.pathTemplates.locationPathTemplate.render({
            project: project,
            location: location,
        });
    }
    /**
     * 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) {
        return this.pathTemplates.locationPathTemplate.match(locationName).project;
    }
    /**
     * 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) {
        return this.pathTemplates.locationPathTemplate.match(locationName).location;
    }
    /**
     * 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, location, privateConnection) {
        return this.pathTemplates.privateConnectionPathTemplate.render({
            project: project,
            location: location,
            private_connection: privateConnection,
        });
    }
    /**
     * 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) {
        return this.pathTemplates.privateConnectionPathTemplate.match(privateConnectionName).project;
    }
    /**
     * 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) {
        return this.pathTemplates.privateConnectionPathTemplate.match(privateConnectionName).location;
    }
    /**
     * 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) {
        return this.pathTemplates.privateConnectionPathTemplate.match(privateConnectionName).private_connection;
    }
    /**
     * Return a fully-qualified project resource name string.
     *
     * @param {string} project
     * @returns {string} Resource name string.
     */
    projectPath(project) {
        return this.pathTemplates.projectPathTemplate.render({
            project: project,
        });
    }
    /**
     * 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) {
        return this.pathTemplates.projectPathTemplate.match(projectName).project;
    }
    /**
     * 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, location, privateConnection, route) {
        return this.pathTemplates.routePathTemplate.render({
            project: project,
            location: location,
            private_connection: privateConnection,
            route: route,
        });
    }
    /**
     * 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) {
        return this.pathTemplates.routePathTemplate.match(routeName).project;
    }
    /**
     * 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) {
        return this.pathTemplates.routePathTemplate.match(routeName).location;
    }
    /**
     * 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) {
        return this.pathTemplates.routePathTemplate.match(routeName)
            .private_connection;
    }
    /**
     * 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) {
        return this.pathTemplates.routePathTemplate.match(routeName).route;
    }
    /**
     * Return a fully-qualified stream resource name string.
     *
     * @param {string} project
     * @param {string} location
     * @param {string} stream
     * @returns {string} Resource name string.
     */
    streamPath(project, location, stream) {
        return this.pathTemplates.streamPathTemplate.render({
            project: project,
            location: location,
            stream: stream,
        });
    }
    /**
     * 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) {
        return this.pathTemplates.streamPathTemplate.match(streamName).project;
    }
    /**
     * 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) {
        return this.pathTemplates.streamPathTemplate.match(streamName).location;
    }
    /**
     * 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) {
        return this.pathTemplates.streamPathTemplate.match(streamName).stream;
    }
    /**
     * Return a fully-qualified streamObject resource name string.
     *
     * @param {string} project
     * @param {string} location
     * @param {string} stream
     * @param {string} object
     * @returns {string} Resource name string.
     */
    streamObjectPath(project, location, stream, object) {
        return this.pathTemplates.streamObjectPathTemplate.render({
            project: project,
            location: location,
            stream: stream,
            object: object,
        });
    }
    /**
     * Parse the project from StreamObject resource.
     *
     * @param {string} streamObjectName
     *   A fully-qualified path representing StreamObject resource.
     * @returns {string} A string representing the project.
     */
    matchProjectFromStreamObjectName(streamObjectName) {
        return this.pathTemplates.streamObjectPathTemplate.match(streamObjectName)
            .project;
    }
    /**
     * Parse the location from StreamObject resource.
     *
     * @param {string} streamObjectName
     *   A fully-qualified path representing StreamObject resource.
     * @returns {string} A string representing the location.
     */
    matchLocationFromStreamObjectName(streamObjectName) {
        return this.pathTemplates.streamObjectPathTemplate.match(streamObjectName)
            .location;
    }
    /**
     * Parse the stream from StreamObject resource.
     *
     * @param {string} streamObjectName
     *   A fully-qualified path representing StreamObject resource.
     * @returns {string} A string representing the stream.
     */
    matchStreamFromStreamObjectName(streamObjectName) {
        return this.pathTemplates.streamObjectPathTemplate.match(streamObjectName)
            .stream;
    }
    /**
     * Parse the object from StreamObject resource.
     *
     * @param {string} streamObjectName
     *   A fully-qualified path representing StreamObject resource.
     * @returns {string} A string representing the object.
     */
    matchObjectFromStreamObjectName(streamObjectName) {
        return this.pathTemplates.streamObjectPathTemplate.match(streamObjectName)
            .object;
    }
    /**
     * 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() {
        if (this.datastreamStub && !this._terminated) {
            return this.datastreamStub.then((stub) => {
                this._log.info('ending gRPC channel');
                this._terminated = true;
                stub.close();
                this.iamClient.close().catch((err) => {
                    throw err;
                });
                this.locationsClient.close().catch((err) => {
                    throw err;
                });
                void this.operationsClient.close();
            });
        }
        return Promise.resolve();
    }
}
exports.DatastreamClient = DatastreamClient;
//# sourceMappingURL=datastream_client.js.map