@googleapis/datastream/v1alpha1.ts

datastream

// Copyright 2020 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
//
//    http://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.

/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/no-unused-vars */
/* eslint-disable @typescript-eslint/no-empty-interface */
/* eslint-disable @typescript-eslint/no-namespace */
/* eslint-disable no-irregular-whitespace */

import {
  OAuth2Client,
  JWT,
  Compute,
  UserRefreshClient,
  BaseExternalAccountClient,
  GaxiosResponseWithHTTP2,
  GoogleConfigurable,
  createAPIRequest,
  MethodOptions,
  StreamMethodOptions,
  GlobalOptions,
  GoogleAuth,
  BodyResponseCallback,
  APIRequestContext,
} from 'googleapis-common';
import {Readable} from 'stream';

export namespace datastream_v1alpha1 {
  export interface Options extends GlobalOptions {
    version: 'v1alpha1';
  }

  interface StandardParameters {
    /**
     * Auth client or API Key for the request
     */
    auth?:
      | string
      | OAuth2Client
      | JWT
      | Compute
      | UserRefreshClient
      | BaseExternalAccountClient
      | GoogleAuth;

    /**
     * V1 error format.
     */
    '$.xgafv'?: string;
    /**
     * OAuth access token.
     */
    access_token?: string;
    /**
     * Data format for response.
     */
    alt?: string;
    /**
     * JSONP
     */
    callback?: string;
    /**
     * Selector specifying which fields to include in a partial response.
     */
    fields?: string;
    /**
     * API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
     */
    key?: string;
    /**
     * OAuth 2.0 token for the current user.
     */
    oauth_token?: string;
    /**
     * Returns response with indentations and line breaks.
     */
    prettyPrint?: boolean;
    /**
     * Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
     */
    quotaUser?: string;
    /**
     * Legacy upload protocol for media (e.g. "media", "multipart").
     */
    uploadType?: string;
    /**
     * Upload protocol for media (e.g. "raw", "multipart").
     */
    upload_protocol?: string;
  }

  /**
   * Datastream API
   *
   *
   *
   * @example
   * ```js
   * const {google} = require('googleapis');
   * const datastream = google.datastream('v1alpha1');
   * ```
   */
  export class Datastream {
    context: APIRequestContext;
    projects: Resource$Projects;

    constructor(options: GlobalOptions, google?: GoogleConfigurable) {
      this.context = {
        _options: options || {},
        google,
      };

      this.projects = new Resource$Projects(this.context);
    }
  }

  /**
   * AVRO file format configuration.
   */
  export interface Schema$AvroFileFormat {}
  /**
   * Backfill strategy to automatically backfill the Stream's objects. Specific objects can be excluded.
   */
  export interface Schema$BackfillAllStrategy {
    /**
     * MySQL data source objects to avoid backfilling.
     */
    mysqlExcludedObjects?: Schema$MysqlRdbms;
    /**
     * Oracle data source objects to avoid backfilling.
     */
    oracleExcludedObjects?: Schema$OracleRdbms;
  }
  /**
   * Represents a backfill job on a specific stream object.
   */
  export interface Schema$BackfillJob {
    /**
     * Output only. Errors which caused the backfill job to fail.
     */
    errors?: Schema$Error[];
    /**
     * Output only. Backfill job's end time.
     */
    lastEndTime?: string | null;
    /**
     * Output only. Backfill job's start time.
     */
    lastStartTime?: string | null;
    /**
     * Backfill job state.
     */
    state?: string | null;
    /**
     * Backfill job's triggering reason.
     */
    trigger?: string | null;
  }
  /**
   * Backfill strategy to disable automatic backfill for the Stream's objects.
   */
  export interface Schema$BackfillNoneStrategy {}
  /**
   * The request message for Operations.CancelOperation.
   */
  export interface Schema$CancelOperationRequest {}
  export interface Schema$ConnectionProfile {
    /**
     * Output only. The create time of the resource.
     */
    createTime?: string | null;
    /**
     * Required. Display name.
     */
    displayName?: string | null;
    /**
     * Forward SSH tunnel connectivity.
     */
    forwardSshConnectivity?: Schema$ForwardSshTunnelConnectivity;
    /**
     * Cloud Storage ConnectionProfile configuration.
     */
    gcsProfile?: Schema$GcsProfile;
    /**
     * Labels.
     */
    labels?: {[key: string]: string} | null;
    /**
     * MySQL ConnectionProfile configuration.
     */
    mysqlProfile?: Schema$MysqlProfile;
    /**
     * Output only. The resource's name.
     */
    name?: string | null;
    /**
     * No connectivity option chosen.
     */
    noConnectivity?: Schema$NoConnectivitySettings;
    /**
     * Oracle ConnectionProfile configuration.
     */
    oracleProfile?: Schema$OracleProfile;
    /**
     * Private connectivity.
     */
    privateConnectivity?: Schema$PrivateConnectivity;
    /**
     * Static Service IP connectivity.
     */
    staticServiceIpConnectivity?: Schema$StaticServiceIpConnectivity;
    /**
     * Output only. The update time of the resource.
     */
    updateTime?: string | null;
  }
  /**
   * The configuration of the stream destination.
   */
  export interface Schema$DestinationConfig {
    /**
     * Required. Destination connection profile identifier.
     */
    destinationConnectionProfileName?: string | null;
    /**
     * GCS destination configuration.
     */
    gcsDestinationConfig?: Schema$GcsDestinationConfig;
  }
  /**
   * Request message for 'discover' ConnectionProfile request.
   */
  export interface Schema$DiscoverConnectionProfileRequest {
    /**
     * An ad-hoc ConnectionProfile configuration.
     */
    connectionProfile?: Schema$ConnectionProfile;
    /**
     * A reference to an existing ConnectionProfile.
     */
    connectionProfileName?: string | null;
    /**
     * MySQL RDBMS to enrich with child data objects and metadata.
     */
    mysqlRdbms?: Schema$MysqlRdbms;
    /**
     * Oracle RDBMS to enrich with child data objects and metadata.
     */
    oracleRdbms?: Schema$OracleRdbms;
    /**
     * The number of hierarchy levels below the current level to be retrieved.
     */
    recursionDepth?: number | null;
    /**
     * Whether to retrieve the full hierarchy of data objects (TRUE) or only the current level (FALSE).
     */
    recursive?: boolean | null;
  }
  export interface Schema$DiscoverConnectionProfileResponse {
    /**
     * Enriched MySQL RDBMS object.
     */
    mysqlRdbms?: Schema$MysqlRdbms;
    /**
     * Enriched Oracle RDBMS object.
     */
    oracleRdbms?: Schema$OracleRdbms;
  }
  /**
   * Configuration to drop large object values.
   */
  export interface Schema$DropLargeObjects {}
  /**
   * A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); \}
   */
  export interface Schema$Empty {}
  /**
   * Represent a user-facing Error.
   */
  export interface Schema$Error {
    /**
     * Additional information about the error.
     */
    details?: {[key: string]: string} | null;
    /**
     * The time when the error occurred.
     */
    errorTime?: string | null;
    /**
     * A unique identifier for this specific error, allowing it to be traced throughout the system in logs and API responses.
     */
    errorUuid?: string | null;
    /**
     * A message containing more information about the error that occurred.
     */
    message?: string | null;
    /**
     * A title that explains the reason for the error.
     */
    reason?: string | null;
  }
  /**
   * Request message for 'FetchErrors' request.
   */
  export interface Schema$FetchErrorsRequest {}
  /**
   * Response message for a 'FetchErrors' response.
   */
  export interface Schema$FetchErrorsResponse {
    /**
     * The list of errors on the Stream.
     */
    errors?: Schema$Error[];
  }
  /**
   * Response message for a 'FetchStaticIps' response.
   */
  export interface Schema$FetchStaticIpsResponse {
    /**
     * A token that can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
     */
    nextPageToken?: string | null;
    /**
     * list of static ips by account
     */
    staticIps?: string[] | null;
  }
  /**
   * Forward SSH Tunnel connectivity.
   */
  export interface Schema$ForwardSshTunnelConnectivity {
    /**
     * Required. Hostname for the SSH tunnel.
     */
    hostname?: string | null;
    /**
     * Input only. SSH password.
     */
    password?: string | null;
    /**
     * Port for the SSH tunnel, default value is 22.
     */
    port?: number | null;
    /**
     * Input only. SSH private key.
     */
    privateKey?: string | null;
    /**
     * Required. Username for the SSH tunnel.
     */
    username?: string | null;
  }
  /**
   * Google Cloud Storage destination configuration
   */
  export interface Schema$GcsDestinationConfig {
    /**
     * AVRO file format configuration.
     */
    avroFileFormat?: Schema$AvroFileFormat;
    /**
     * The maximum duration for which new events are added before a file is closed and a new file is created.
     */
    fileRotationInterval?: string | null;
    /**
     * The maximum file size to be saved in the bucket.
     */
    fileRotationMb?: number | null;
    /**
     * File format that data should be written in. Deprecated field (b/169501737) - use file_format instead.
     */
    gcsFileFormat?: string | null;
    /**
     * JSON file format configuration.
     */
    jsonFileFormat?: Schema$JsonFileFormat;
    /**
     * Path inside the Cloud Storage bucket to write data to.
     */
    path?: string | null;
  }
  /**
   * Cloud Storage bucket profile.
   */
  export interface Schema$GcsProfile {
    /**
     * Required. The full project and resource path for Cloud Storage bucket including the name.
     */
    bucketName?: string | null;
    /**
     * The root path inside the Cloud Storage bucket.
     */
    rootPath?: string | null;
  }
  /**
   * JSON file format configuration.
   */
  export interface Schema$JsonFileFormat {
    /**
     * Compression of the loaded JSON file.
     */
    compression?: string | null;
    /**
     * The schema file format along JSON data files.
     */
    schemaFileFormat?: string | null;
  }
  export interface Schema$ListConnectionProfilesResponse {
    /**
     * List of connection profiles.
     */
    connectionProfiles?: Schema$ConnectionProfile[];
    /**
     * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
     */
    nextPageToken?: string | null;
    /**
     * Locations that could not be reached.
     */
    unreachable?: string[] | null;
  }
  /**
   * The response message for Locations.ListLocations.
   */
  export interface Schema$ListLocationsResponse {
    /**
     * A list of locations that matches the specified filter in the request.
     */
    locations?: Schema$Location[];
    /**
     * The standard List next-page token.
     */
    nextPageToken?: string | null;
  }
  /**
   * The response message for Operations.ListOperations.
   */
  export interface Schema$ListOperationsResponse {
    /**
     * The standard List next-page token.
     */
    nextPageToken?: string | null;
    /**
     * A list of operations that matches the specified filter in the request.
     */
    operations?: Schema$Operation[];
  }
  export interface Schema$ListPrivateConnectionsResponse {
    /**
     * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
     */
    nextPageToken?: string | null;
    /**
     * List of private connectivity configurations.
     */
    privateConnections?: Schema$PrivateConnection[];
    /**
     * Locations that could not be reached.
     */
    unreachable?: string[] | null;
  }
  /**
   * route list response
   */
  export interface Schema$ListRoutesResponse {
    /**
     * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
     */
    nextPageToken?: string | null;
    /**
     * List of Routes.
     */
    routes?: Schema$Route[];
    /**
     * Locations that could not be reached.
     */
    unreachable?: string[] | null;
  }
  /**
   * Response containing the objects for a stream.
   */
  export interface Schema$ListStreamObjectsResponse {
    /**
     * A token, which can be sent as `page_token` to retrieve the next page.
     */
    nextPageToken?: string | null;
    /**
     * List of stream objects.
     */
    streamObjects?: Schema$StreamObject[];
  }
  export interface Schema$ListStreamsResponse {
    /**
     * A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
     */
    nextPageToken?: string | null;
    /**
     * List of streams
     */
    streams?: Schema$Stream[];
    /**
     * Locations that could not be reached.
     */
    unreachable?: string[] | null;
  }
  /**
   * A resource that represents a Google Cloud location.
   */
  export interface Schema$Location {
    /**
     * The friendly name for this location, typically a nearby city name. For example, "Tokyo".
     */
    displayName?: string | null;
    /**
     * Cross-service attributes for the location. For example {"cloud.googleapis.com/region": "us-east1"\}
     */
    labels?: {[key: string]: string} | null;
    /**
     * The canonical id for this location. For example: `"us-east1"`.
     */
    locationId?: string | null;
    /**
     * Service-specific metadata. For example the available capacity at the given location.
     */
    metadata?: {[key: string]: any} | null;
    /**
     * Resource name for the location, which may vary between implementations. For example: `"projects/example-project/locations/us-east1"`
     */
    name?: string | null;
  }
  /**
   * MySQL Column.
   */
  export interface Schema$MysqlColumn {
    /**
     * Column collation.
     */
    collation?: string | null;
    /**
     * Column name.
     */
    columnName?: string | null;
    /**
     * The MySQL data type. Full data types list can be found here: https://dev.mysql.com/doc/refman/8.0/en/data-types.html
     */
    dataType?: string | null;
    /**
     * Column length.
     */
    length?: number | null;
    /**
     * Whether or not the column can accept a null value.
     */
    nullable?: boolean | null;
    /**
     * The ordinal position of the column in the table.
     */
    ordinalPosition?: number | null;
    /**
     * Whether or not the column represents a primary key.
     */
    primaryKey?: boolean | null;
  }
  /**
   * MySQL database.
   */
  export interface Schema$MysqlDatabase {
    /**
     * Database name.
     */
    databaseName?: string | null;
    /**
     * Tables in the database.
     */
    mysqlTables?: Schema$MysqlTable[];
  }
  /**
   * Mysql data source object identifier.
   */
  export interface Schema$MysqlObjectIdentifier {
    /**
     * Required. The database name.
     */
    database?: string | null;
    /**
     * Required. The table name.
     */
    table?: string | null;
  }
  /**
   * MySQL database profile.
   */
  export interface Schema$MysqlProfile {
    /**
     * Required. Hostname for the MySQL connection.
     */
    hostname?: string | null;
    /**
     * Required. Input only. Password for the MySQL connection.
     */
    password?: string | null;
    /**
     * Port for the MySQL connection, default value is 3306.
     */
    port?: number | null;
    /**
     * SSL configuration for the MySQL connection.
     */
    sslConfig?: Schema$MysqlSslConfig;
    /**
     * Required. Username for the MySQL connection.
     */
    username?: string | null;
  }
  /**
   * MySQL database structure
   */
  export interface Schema$MysqlRdbms {
    /**
     * Mysql databases on the server
     */
    mysqlDatabases?: Schema$MysqlDatabase[];
  }
  /**
   * MySQL source configuration
   */
  export interface Schema$MysqlSourceConfig {
    /**
     * MySQL objects to retrieve from the source.
     */
    allowlist?: Schema$MysqlRdbms;
    /**
     * MySQL objects to exclude from the stream.
     */
    rejectlist?: Schema$MysqlRdbms;
  }
  /**
   * MySQL SSL configuration information.
   */
  export interface Schema$MysqlSslConfig {
    /**
     * Input only. PEM-encoded certificate of the CA that signed the source database server's certificate.
     */
    caCertificate?: string | null;
    /**
     * Output only. Indicates whether the ca_certificate field is set.
     */
    caCertificateSet?: boolean | null;
    /**
     * Input only. PEM-encoded certificate that will be used by the replica to authenticate against the source database server. If this field is used then the 'client_key' and the 'ca_certificate' fields are mandatory.
     */
    clientCertificate?: string | null;
    /**
     * Output only. Indicates whether the client_certificate field is set.
     */
    clientCertificateSet?: boolean | null;
    /**
     * Input only. PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' and the 'ca_certificate' fields are mandatory.
     */
    clientKey?: string | null;
    /**
     * Output only. Indicates whether the client_key field is set.
     */
    clientKeySet?: boolean | null;
  }
  /**
   * MySQL table.
   */
  export interface Schema$MysqlTable {
    /**
     * MySQL columns in the database. When unspecified as part of include/exclude lists, includes/excludes everything.
     */
    mysqlColumns?: Schema$MysqlColumn[];
    /**
     * Table name.
     */
    tableName?: string | null;
  }
  /**
   * No connectivity settings.
   */
  export interface Schema$NoConnectivitySettings {}
  /**
   * This resource represents a long-running operation that is the result of a network API call.
   */
  export interface Schema$Operation {
    /**
     * If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.
     */
    done?: boolean | null;
    /**
     * The error result of the operation in case of failure or cancellation.
     */
    error?: Schema$Status;
    /**
     * Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.
     */
    metadata?: {[key: string]: any} | null;
    /**
     * The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id\}`.
     */
    name?: string | null;
    /**
     * The normal, successful response of the operation. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
     */
    response?: {[key: string]: any} | null;
  }
  /**
   * Represents the metadata of the long-running operation.
   */
  export interface Schema$OperationMetadata {
    /**
     * Output only. API version used to start the operation.
     */
    apiVersion?: string | null;
    /**
     * Output only. The time the operation was created.
     */
    createTime?: string | null;
    /**
     * Output only. The time the operation finished running.
     */
    endTime?: string | null;
    /**
     * Output only. Identifies whether the user has requested cancellation of the operation. Operations that have successfully been cancelled have google.longrunning.Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.
     */
    requestedCancellation?: boolean | null;
    /**
     * Output only. Human-readable status of the operation, if any.
     */
    statusMessage?: string | null;
    /**
     * Output only. Server-defined resource path for the target of the operation.
     */
    target?: string | null;
    /**
     * Output only. Results of executed validations if there are any.
     */
    validationResult?: Schema$ValidationResult;
    /**
     * Output only. Name of the verb executed by the operation.
     */
    verb?: string | null;
  }
  /**
   * Oracle Column.
   */
  export interface Schema$OracleColumn {
    /**
     * Column name.
     */
    columnName?: string | null;
    /**
     * The Oracle data type.
     */
    dataType?: string | null;
    /**
     * Column encoding.
     */
    encoding?: string | null;
    /**
     * Column length.
     */
    length?: number | null;
    /**
     * Whether or not the column can accept a null value.
     */
    nullable?: boolean | null;
    /**
     * The ordinal position of the column in the table.
     */
    ordinalPosition?: number | null;
    /**
     * Column precision.
     */
    precision?: number | null;
    /**
     * Whether or not the column represents a primary key.
     */
    primaryKey?: boolean | null;
    /**
     * Column scale.
     */
    scale?: number | null;
  }
  /**
   * Oracle data source object identifier.
   */
  export interface Schema$OracleObjectIdentifier {
    /**
     * Required. The schema name.
     */
    schema?: string | null;
    /**
     * Required. The table name.
     */
    table?: string | null;
  }
  /**
   * Oracle database profile.
   */
  export interface Schema$OracleProfile {
    /**
     * Connection string attributes
     */
    connectionAttributes?: {[key: string]: string} | null;
    /**
     * Required. Database for the Oracle connection.
     */
    databaseService?: string | null;
    /**
     * Required. Hostname for the Oracle connection.
     */
    hostname?: string | null;
    /**
     * Required. Password for the Oracle connection.
     */
    password?: string | null;
    /**
     * Port for the Oracle connection, default value is 1521.
     */
    port?: number | null;
    /**
     * Required. Username for the Oracle connection.
     */
    username?: string | null;
  }
  /**
   * Oracle database structure.
   */
  export interface Schema$OracleRdbms {
    /**
     * Oracle schemas/databases in the database server.
     */
    oracleSchemas?: Schema$OracleSchema[];
  }
  /**
   * Oracle schema.
   */
  export interface Schema$OracleSchema {
    /**
     * Tables in the schema.
     */
    oracleTables?: Schema$OracleTable[];
    /**
     * Schema name.
     */
    schemaName?: string | null;
  }
  /**
   * Oracle data source configuration
   */
  export interface Schema$OracleSourceConfig {
    /**
     * Oracle objects to include in the stream.
     */
    allowlist?: Schema$OracleRdbms;
    /**
     * Drop large object values.
     */
    dropLargeObjects?: Schema$DropLargeObjects;
    /**
     * Oracle objects to exclude from the stream.
     */
    rejectlist?: Schema$OracleRdbms;
  }
  /**
   * Oracle table.
   */
  export interface Schema$OracleTable {
    /**
     * Oracle columns in the schema. When unspecified as part of inclue/exclude lists, includes/excludes everything.
     */
    oracleColumns?: Schema$OracleColumn[];
    /**
     * Table name.
     */
    tableName?: string | null;
  }
  /**
   * The PrivateConnection resource is used to establish private connectivity between Datastream and a customer's network.
   */
  export interface Schema$PrivateConnection {
    /**
     * Output only. The create time of the resource.
     */
    createTime?: string | null;
    /**
     * Required. Display name.
     */
    displayName?: string | null;
    /**
     * Output only. In case of error, the details of the error in a user-friendly format.
     */
    error?: Schema$Error;
    /**
     * Labels.
     */
    labels?: {[key: string]: string} | null;
    /**
     * Output only. The resource's name.
     */
    name?: string | null;
    /**
     * Output only. The state of the Private Connection.
     */
    state?: string | null;
    /**
     * Output only. The update time of the resource.
     */
    updateTime?: string | null;
    /**
     * VPC Peering Config
     */
    vpcPeeringConfig?: Schema$VpcPeeringConfig;
  }
  /**
   * Private Connectivity
   */
  export interface Schema$PrivateConnectivity {
    privateConnectionName?: string | null;
  }
  /**
   * The Route resource is the child of the PrivateConnection resource. It used to define a route for a PrivateConnection setup.
   */
  export interface Schema$Route {
    /**
     * Output only. The create time of the resource.
     */
    createTime?: string | null;
    /**
     * Required. Destination address for connection
     */
    destinationAddress?: string | null;
    /**
     * Destination port for connection
     */
    destinationPort?: number | null;
    /**
     * Required. Display name.
     */
    displayName?: string | null;
    /**
     * Labels.
     */
    labels?: {[key: string]: string} | null;
    /**
     * Output only. The resource's name.
     */
    name?: string | null;
    /**
     * Output only. The update time of the resource.
     */
    updateTime?: string | null;
  }
  /**
   * The configuration of the stream source.
   */
  export interface Schema$SourceConfig {
    /**
     * MySQL data source configuration
     */
    mysqlSourceConfig?: Schema$MysqlSourceConfig;
    /**
     * Oracle data source configuration
     */
    oracleSourceConfig?: Schema$OracleSourceConfig;
    /**
     * Required. Source connection profile identifier.
     */
    sourceConnectionProfileName?: string | null;
  }
  /**
   * Represents an identifier of an object in the data source.
   */
  export interface Schema$SourceObjectIdentifier {
    /**
     * Mysql data source object identifier.
     */
    mysqlIdentifier?: Schema$MysqlObjectIdentifier;
    /**
     * Oracle data source object identifier.
     */
    oracleIdentifier?: Schema$OracleObjectIdentifier;
  }
  /**
   * Response for manually initiating a backfill job for a specific stream object.
   */
  export interface Schema$StartBackfillJobResponse {
    /**
     * The stream object resource a backfill job was started for.
     */
    object?: Schema$StreamObject;
  }
  /**
   * Static IP address connectivity.
   */
  export interface Schema$StaticServiceIpConnectivity {}
  /**
   * The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).
   */
  export interface Schema$Status {
    /**
     * The status code, which should be an enum value of google.rpc.Code.
     */
    code?: number | null;
    /**
     * A list of messages that carry the error details. There is a common set of message types for APIs to use.
     */
    details?: Array<{[key: string]: any}> | null;
    /**
     * A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.
     */
    message?: string | null;
  }
  /**
   * Response for manually stop a backfill job for a specific stream object.
   */
  export interface Schema$StopBackfillJobResponse {
    /**
     * The stream object resource the backfill job was stopped for.
     */
    object?: Schema$StreamObject;
  }
  export interface Schema$Stream {
    /**
     * Automatically backfill objects included in the stream source configuration. Specific objects can be excluded.
     */
    backfillAll?: Schema$BackfillAllStrategy;
    /**
     * Do not automatically backfill any objects.
     */
    backfillNone?: Schema$BackfillNoneStrategy;
    /**
     * Output only. The creation time of the stream.
     */
    createTime?: string | null;
    /**
     * Immutable. A reference to a KMS encryption key. If provided, it will be used to encrypt the data. If left blank, data will be encrypted using an internal Stream-specific encryption key provisioned through KMS.
     */
    customerManagedEncryptionKey?: string | null;
    /**
     * Required. Destination connection profile configuration.
     */
    destinationConfig?: Schema$DestinationConfig;
    /**
     * Required. Display name.
     */
    displayName?: string | null;
    /**
     * Output only. Errors on the Stream.
     */
    errors?: Schema$Error[];
    /**
     * Labels.
     */
    labels?: {[key: string]: string} | null;
    /**
     * Output only. The stream's name.
     */
    name?: string | null;
    /**
     * Required. Source connection profile configuration.
     */
    sourceConfig?: Schema$SourceConfig;
    /**
     * The state of the stream.
     */
    state?: string | null;
    /**
     * Output only. The last update time of the stream.
     */
    updateTime?: string | null;
  }
  /**
   * A specific stream object (e.g a specific DB table).
   */
  export interface Schema$StreamObject {
    /**
     * The latest backfill job that was initiated for the stream object.
     */
    backfillJob?: Schema$BackfillJob;
    /**
     * Output only. The creation time of the object.
     */
    createTime?: string | null;
    /**
     * Required. Display name.
     */
    displayName?: string | null;
    /**
     * Output only. Active errors on the object.
     */
    errors?: Schema$Error[];
    /**
     * Output only. The object's name.
     */
    name?: string | null;
    /**
     * The object identifier in the data source.
     */
    sourceObject?: Schema$SourceObjectIdentifier;
    /**
     * Output only. The last update time of the object.
     */
    updateTime?: string | null;
  }
  export interface Schema$Validation {
    /**
     * A custom code identifying this validation.
     */
    code?: string | null;
    /**
     * A short description of the validation.
     */
    description?: string | null;
    /**
     * Messages reflecting the validation results.
     */
    message?: Schema$ValidationMessage[];
    /**
     * Validation execution status.
     */
    status?: string | null;
  }
  /**
   * Represent user-facing validation result message.
   */
  export interface Schema$ValidationMessage {
    /**
     * A custom code identifying this specific message.
     */
    code?: string | null;
    /**
     * Message severity level (warning or error).
     */
    level?: string | null;
    /**
     * The result of the validation.
     */
    message?: string | null;
    /**
     * Additional metadata related to the result.
     */
    metadata?: {[key: string]: string} | null;
  }
  /**
   * Contains the current validation results.
   */
  export interface Schema$ValidationResult {
    /**
     * A list of validations (includes both executed as well as not executed validations).
     */
    validations?: Schema$Validation[];
  }
  /**
   * The VPC Peering configuration is used to create VPC peering between Datastream and the consumer's VPC.
   */
  export interface Schema$VpcPeeringConfig {
    /**
     * Required. A free subnet for peering. (CIDR of /29)
     */
    subnet?: string | null;
    /**
     * Required. fully qualified name of the VPC Datastream will peer to.
     */
    vpcName?: string | null;
  }

  export class Resource$Projects {
    context: APIRequestContext;
    locations: Resource$Projects$Locations;
    constructor(context: APIRequestContext) {
      this.context = context;
      this.locations = new Resource$Projects$Locations(this.context);
    }
  }

  export class Resource$Projects$Locations {
    context: APIRequestContext;
    connectionProfiles: Resource$Projects$Locations$Connectionprofiles;
    operations: Resource$Projects$Locations$Operations;
    privateConnections: Resource$Projects$Locations$Privateconnections;
    streams: Resource$Projects$Locations$Streams;
    constructor(context: APIRequestContext) {
      this.context = context;
      this.connectionProfiles =
        new Resource$Projects$Locations$Connectionprofiles(this.context);
      this.operations = new Resource$Projects$Locations$Operations(
        this.context
      );
      this.privateConnections =
        new Resource$Projects$Locations$Privateconnections(this.context);
      this.streams = new Resource$Projects$Locations$Streams(this.context);
    }

    /**
     * The FetchStaticIps API call exposes the static IP addresses used by Datastream.
     * @example
     * ```js
     * // Before running the sample:
     * // - Enable the API at:
     * //   https://console.developers.google.com/apis/api/datastream.googleapis.com
     * // - Login into gcloud by running:
     * //   ```sh
     * //   $ gcloud auth application-default login
     * //   ```
     * // - Install the npm module by running:
     * //   ```sh
     * //   $ npm install googleapis
     * //   ```
     *
     * const {google} = require('googleapis');
     * const datastream = google.datastream('v1alpha1');
     *
     * async function main() {
     *   const auth = new google.auth.GoogleAuth({
     *     // Scopes can be specified either as an array or as a single, space-delimited string.
     *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
     *   });
     *
     *   // Acquire an auth client, and bind it to all future calls
     *   const authClient = await auth.getClient();
     *   google.options({auth: authClient});
     *
     *   // Do the magic
     *   const res = await datastream.projects.locations.fetchStaticIps({
     *     // Required. The name resource of the Response type. Must be in the format `projects/x/locations/x`.
     *     name: 'projects/my-project/locations/my-location',
     *     // Maximum number of Ips to return, will likely not be specified.
     *     pageSize: 'placeholder-value',
     *     // A page token, received from a previous `ListStaticIps` call. will likely not be specified.
     *     pageToken: 'placeholder-value',
     *   });
     *   console.log(res.data);
     *
     *   // Example response
     *   // {
     *   //   "nextPageToken": "my_nextPageToken",
     *   //   "staticIps": []
     *   // }
     * }
     *
     * main().catch(e => {
     *   console.error(e);
     *   throw e;
     * });
     *
     * ```
     *
     * @param params - Parameters for request
     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param callback - Optional callback that handles the response.
     * @returns A promise if used with async/await, or void if used with a callback.
     */
    fetchStaticIps(
      params: Params$Resource$Projects$Locations$Fetchstaticips,
      options: StreamMethodOptions
    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
    fetchStaticIps(
      params?: Params$Resource$Projects$Locations$Fetchstaticips,
      options?: MethodOptions
    ): Promise<GaxiosResponseWithHTTP2<Schema$FetchStaticIpsResponse>>;
    fetchStaticIps(
      params: Params$Resource$Projects$Locations$Fetchstaticips,
      options: StreamMethodOptions | BodyResponseCallback<Readable>,
      callback: BodyResponseCallback<Readable>
    ): void;
    fetchStaticIps(
      params: Params$Resource$Projects$Locations$Fetchstaticips,
      options:
        | MethodOptions
        | BodyResponseCallback<Schema$FetchStaticIpsResponse>,
      callback: BodyResponseCallback<Schema$FetchStaticIpsResponse>
    ): void;
    fetchStaticIps(
      params: Params$Resource$Projects$Locations$Fetchstaticips,
      callback: BodyResponseCallback<Schema$FetchStaticIpsResponse>
    ): void;
    fetchStaticIps(
      callback: BodyResponseCallback<Schema$FetchStaticIpsResponse>
    ): void;
    fetchStaticIps(
      paramsOrCallback?:
        | Params$Resource$Projects$Locations$Fetchstaticips
        | BodyResponseCallback<Schema$FetchStaticIpsResponse>
        | BodyResponseCallback<Readable>,
      optionsOrCallback?:
        | MethodOptions
        | StreamMethodOptions
        | BodyResponseCallback<Schema$FetchStaticIpsResponse>
        | BodyResponseCallback<Readable>,
      callback?:
        | BodyResponseCallback<Schema$FetchStaticIpsResponse>
        | BodyResponseCallback<Readable>
    ):
      | void
      | Promise<GaxiosResponseWithHTTP2<Schema$FetchStaticIpsResponse>>
      | Promise<GaxiosResponseWithHTTP2<Readable>> {
      let params = (paramsOrCallback ||
        {}) as Params$Resource$Projects$Locations$Fetchstaticips;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Projects$Locations$Fetchstaticips;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://datastream.googleapis.com/';
      const parameters = {
        options: Object.assign(
          {
            url: (rootUrl + '/v1alpha1/{+name}:fetchStaticIps').replace(
              /([^:]\/)\/+/g,
              '$1'
            ),
            method: 'GET',
            apiVersion: '',
          },
          options
        ),
        params,
        requiredParams: ['name'],
        pathParams: ['name'],
        context: this.context,
      };
      if (callback) {
        createAPIRequest<Schema$FetchStaticIpsResponse>(
          parameters,
          callback as BodyResponseCallback<unknown>
        );
      } else {
        return createAPIRequest<Schema$FetchStaticIpsResponse>(parameters);
      }
    }

    /**
     * Gets information about a location.
     * @example
     * ```js
     * // Before running the sample:
     * // - Enable the API at:
     * //   https://console.developers.google.com/apis/api/datastream.googleapis.com
     * // - Login into gcloud by running:
     * //   ```sh
     * //   $ gcloud auth application-default login
     * //   ```
     * // - Install the npm module by running:
     * //   ```sh
     * //   $ npm install googleapis
     * //   ```
     *
     * const {google} = require('googleapis');
     * const datastream = google.datastream('v1alpha1');
     *
     * async function main() {
     *   const auth = new google.auth.GoogleAuth({
     *     // Scopes can be specified either as an array or as a single, space-delimited string.
     *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
     *   });
     *
     *   // Acquire an auth client, and bind it to all future calls
     *   const authClient = await auth.getClient();
     *   google.options({auth: authClient});
     *
     *   // Do the magic
     *   const res = await datastream.projects.locations.get({
     *     // Resource name for the location.
     *     name: 'projects/my-project/locations/my-location',
     *   });
     *   console.log(res.data);
     *
     *   // Example response
     *   // {
     *   //   "displayName": "my_displayName",
     *   //   "labels": {},
     *   //   "locationId": "my_locationId",
     *   //   "metadata": {},
     *   //   "name": "my_name"
     *   // }
     * }
     *
     * main().catch(e => {
     *   console.error(e);
     *   throw e;
     * });
     *
     * ```
     *
     * @param params - Parameters for request
     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param callback - Optional callback that handles the response.
     * @returns A promise if used with async/await, or void if used with a callback.
     */
    get(
      params: Params$Resource$Projects$Locations$Get,
      options: StreamMethodOptions
    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
    get(
      params?: Params$Resource$Projects$Locations$Get,
      options?: MethodOptions
    ): Promise<GaxiosResponseWithHTTP2<Schema$Location>>;
    get(
      params: Params$Resource$Projects$Locations$Get,
      options: StreamMethodOptions | BodyResponseCallback<Readable>,
      callback: BodyResponseCallback<Readable>
    ): void;
    get(
      params: Params$Resource$Projects$Locations$Get,
      options: MethodOptions | BodyResponseCallback<Schema$Location>,
      callback: BodyResponseCallback<Schema$Location>
    ): void;
    get(
      params: Params$Resource$Projects$Locations$Get,
      callback: BodyResponseCallback<Schema$Location>
    ): void;
    get(callback: BodyResponseCallback<Schema$Location>): void;
    get(
      paramsOrCallback?:
        | Params$Resource$Projects$Locations$Get
        | BodyResponseCallback<Schema$Location>
        | BodyResponseCallback<Readable>,
      optionsOrCallback?:
        | MethodOptions
        | StreamMethodOptions
        | BodyResponseCallback<Schema$Location>
        | BodyResponseCallback<Readable>,
      callback?:
        | BodyResponseCallback<Schema$Location>
        | BodyResponseCallback<Readable>
    ):
      | void
      | Promise<GaxiosResponseWithHTTP2<Schema$Location>>
      | Promise<GaxiosResponseWithHTTP2<Readable>> {
      let params = (paramsOrCallback ||
        {}) as Params$Resource$Projects$Locations$Get;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Projects$Locations$Get;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://datastream.googleapis.com/';
      const parameters = {
        options: Object.assign(
          {
            url: (rootUrl + '/v1alpha1/{+name}').replace(/([^:]\/)\/+/g, '$1'),
            method: 'GET',
            apiVersion: '',
          },
          options
        ),
        params,
        requiredParams: ['name'],
        pathParams: ['name'],
        context: this.context,
      };
      if (callback) {
        createAPIRequest<Schema$Location>(
          parameters,
          callback as BodyResponseCallback<unknown>
        );
      } else {
        return createAPIRequest<Schema$Location>(parameters);
      }
    }

    /**
     * Lists information about the supported locations for this service.
     * @example
     * ```js
     * // Before running the sample:
     * // - Enable the API at:
     * //   https://console.developers.google.com/apis/api/datastream.googleapis.com
     * // - Login into gcloud by running:
     * //   ```sh
     * //   $ gcloud auth application-default login
     * //   ```
     * // - Install the npm module by running:
     * //   ```sh
     * //   $ npm install googleapis
     * //   ```
     *
     * const {google} = require('googleapis');
     * const datastream = google.datastream('v1alpha1');
     *
     * async function main() {
     *   const auth = new google.auth.GoogleAuth({
     *     // Scopes can be specified either as an array or as a single, space-delimited string.
     *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
     *   });
     *
     *   // Acquire an auth client, and bind it to all future calls
     *   const authClient = await auth.getClient();
     *   google.options({auth: authClient});
     *
     *   // Do the magic
     *   const res = await datastream.projects.locations.list({
     *     // Optional. Do not use this field. It is unsupported and is ignored unless explicitly documented otherwise. This is primarily for internal usage.
     *     extraLocationTypes: 'placeholder-value',
     *     // A filter to narrow down results to a preferred subset. The filtering language accepts strings like `"displayName=tokyo"`, and is documented in more detail in [AIP-160](https://google.aip.dev/160).
     *     filter: 'placeholder-value',
     *     // The resource that owns the locations collection, if applicable.
     *     name: 'projects/my-project',
     *     // The maximum number of results to return. If not set, the service selects a default.
     *     pageSize: 'placeholder-value',
     *     // A page token received from the `next_page_token` field in the response. Send that page token to receive the subsequent page.
     *     pageToken: 'placeholder-value',
     *   });
     *   console.log(res.data);
     *
     *   // Example response
     *   // {
     *   //   "locations": [],
     *   //   "nextPageToken": "my_nextPageToken"
     *   // }
     * }
     *
     * main().catch(e => {
     *   console.error(e);
     *   throw e;
     * });
     *
     * ```
     *
     * @param params - Parameters for request
     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param callback - Optional callback that handles the response.
     * @returns A promise if used with async/await, or void if used with a callback.
     */
    list(
      params: Params$Resource$Projects$Locations$List,
      options: StreamMethodOptions
    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
    list(
      params?: Params$Resource$Projects$Locations$List,
      options?: MethodOptions
    ): Promise<GaxiosResponseWithHTTP2<Schema$ListLocationsResponse>>;
    list(
      params: Params$Resource$Projects$Locations$List,
      options: StreamMethodOptions | BodyResponseCallback<Readable>,
      callback: BodyResponseCallback<Readable>
    ): void;
    list(
      params: Params$Resource$Projects$Locations$List,
      options:
        | MethodOptions
        | BodyResponseCallback<Schema$ListLocationsResponse>,
      callback: BodyResponseCallback<Schema$ListLocationsResponse>
    ): void;
    list(
      params: Params$Resource$Projects$Locations$List,
      callback: BodyResponseCallback<Schema$ListLocationsResponse>
    ): void;
    list(callback: BodyResponseCallback<Schema$ListLocationsResponse>): void;
    list(
      paramsOrCallback?:
        | Params$Resource$Projects$Locations$List
        | BodyResponseCallback<Schema$ListLocationsResponse>
        | BodyResponseCallback<Readable>,
      optionsOrCallback?:
        | MethodOptions
        | StreamMethodOptions
        | BodyResponseCallback<Schema$ListLocationsResponse>
        | BodyResponseCallback<Readable>,
      callback?:
        | BodyResponseCallback<Schema$ListLocationsResponse>
        | BodyResponseCallback<Readable>
    ):
      | void
      | Promise<GaxiosResponseWithHTTP2<Schema$ListLocationsResponse>>
      | Promise<GaxiosResponseWithHTTP2<Readable>> {
      let params = (paramsOrCallback ||
        {}) as Params$Resource$Projects$Locations$List;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Projects$Locations$List;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://datastream.googleapis.com/';
      const parameters = {
        options: Object.assign(
          {
            url: (rootUrl + '/v1alpha1/{+name}/locations').replace(
              /([^:]\/)\/+/g,
              '$1'
            ),
            method: 'GET',
            apiVersion: '',
          },
          options
        ),
        params,
        requiredParams: ['name'],
        pathParams: ['name'],
        context: this.context,
      };
      if (callback) {
        createAPIRequest<Schema$ListLocationsResponse>(
          parameters,
          callback as BodyResponseCallback<unknown>
        );
      } else {
        return createAPIRequest<Schema$ListLocationsResponse>(parameters);
      }
    }
  }

  export interface Params$Resource$Projects$Locations$Fetchstaticips
    extends StandardParameters {
    /**
     * Required. The name resource of the Response type. Must be in the format `projects/x/locations/x`.
     */
    name?: string;
    /**
     * Maximum number of Ips to return, will likely not be specified.
     */
    pageSize?: number;
    /**
     * A page token, received from a previous `ListStaticIps` call. will likely not be specified.
     */
    pageToken?: string;
  }
  export interface Params$Resource$Projects$Locations$Get
    extends StandardParameters {
    /**
     * Resource name for the location.
     */
    name?: string;
  }
  export interface Params$Resource$Projects$Locations$List
    extends StandardParameters {
    /**
     * Optional. Do not use this field. It is unsupporte