googleapis
Version:
Google APIs Client Library for Node.js
1,239 lines • 237 kB
TypeScript
/// <reference types="node" />
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { Readable } from 'stream';
export declare namespace datamigration_v1 {
export interface Options extends GlobalOptions {
version: 'v1';
}
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;
}
/**
* Database Migration API
*
* Manage Cloud Database Migration Service resources on Google Cloud Platform.
*
* @example
* ```js
* const {google} = require('googleapis');
* const datamigration = google.datamigration('v1');
* ```
*/
export class Datamigration {
context: APIRequestContext;
projects: Resource$Projects;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* Specifies required connection parameters, and the parameters required to create an AlloyDB destination cluster.
*/
export interface Schema$AlloyDbConnectionProfile {
/**
* Required. The AlloyDB cluster ID that this connection profile is associated with.
*/
clusterId?: string | null;
/**
* Immutable. Metadata used to create the destination AlloyDB cluster.
*/
settings?: Schema$AlloyDbSettings;
}
/**
* Settings for creating an AlloyDB cluster.
*/
export interface Schema$AlloyDbSettings {
/**
* Optional. The encryption config can be specified to encrypt the data disks and other persistent data resources of a cluster with a customer-managed encryption key (CMEK). When this field is not specified, the cluster will then use default encryption scheme to protect the user data.
*/
encryptionConfig?: Schema$EncryptionConfig;
/**
* Required. Input only. Initial user to setup during cluster creation. Required.
*/
initialUser?: Schema$UserPassword;
/**
* Labels for the AlloyDB cluster created by DMS. An object containing a list of 'key', 'value' pairs.
*/
labels?: {
[key: string]: string;
} | null;
primaryInstanceSettings?: Schema$PrimaryInstanceSettings;
/**
* Required. The resource link for the VPC network in which cluster resources are created and from which they are accessible via Private IP. The network must belong to the same project as the cluster. It is specified in the form: "projects/{project_number\}/global/networks/{network_id\}". This is required to create a cluster.
*/
vpcNetwork?: string | null;
}
/**
* Request message for 'ApplyConversionWorkspace' request.
*/
export interface Schema$ApplyConversionWorkspaceRequest {
/**
* Optional. Specifies whether the conversion workspace is to be committed automatically after the apply.
*/
autoCommit?: boolean | null;
/**
* Optional. Fully qualified (Uri) name of the destination connection profile.
*/
connectionProfile?: string | null;
/**
* Optional. Only validates the apply process, but doesn't change the destination database. Only works for PostgreSQL destination connection profile.
*/
dryRun?: boolean | null;
/**
* Filter which entities to apply. Leaving this field empty will apply all of the entities. Supports Google AIP 160 based filtering.
*/
filter?: string | null;
}
/**
* Apply a hash function on the value.
*/
export interface Schema$ApplyHash {
/**
* Optional. Generate UUID from the data's byte array
*/
uuidFromBytes?: Schema$Empty;
}
/**
* Details regarding an Apply background job.
*/
export interface Schema$ApplyJobDetails {
/**
* Output only. The connection profile which was used for the apply job.
*/
connectionProfile?: string | null;
/**
* Output only. AIP-160 based filter used to specify the entities to apply
*/
filter?: string | null;
}
/**
* Set to a specific value (value is converted to fit the target data type)
*/
export interface Schema$AssignSpecificValue {
/**
* Required. Specific value to be assigned
*/
value?: string | null;
}
/**
* Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices", "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] \}, { "log_type": "DATA_WRITE" \}, { "log_type": "ADMIN_READ" \} ] \}, { "service": "sampleservice.googleapis.com", "audit_log_configs": [ { "log_type": "DATA_READ" \}, { "log_type": "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] \} ] \} ] \} For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts `jose@example.com` from DATA_READ logging, and `aliya@example.com` from DATA_WRITE logging.
*/
export interface Schema$AuditConfig {
/**
* The configuration for logging of each type of permission.
*/
auditLogConfigs?: Schema$AuditLogConfig[];
/**
* Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.
*/
service?: string | null;
}
/**
* Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] \}, { "log_type": "DATA_WRITE" \} ] \} This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.
*/
export interface Schema$AuditLogConfig {
/**
* Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.
*/
exemptedMembers?: string[] | null;
/**
* The log type that this config enables.
*/
logType?: string | null;
}
/**
* Execution log of a background job.
*/
export interface Schema$BackgroundJobLogEntry {
/**
* Output only. Apply job details.
*/
applyJobDetails?: Schema$ApplyJobDetails;
/**
* Output only. Job completion comment, such as how many entities were seeded, how many warnings were found during conversion, and similar information.
*/
completionComment?: string | null;
/**
* Output only. Job completion state, i.e. the final state after the job completed.
*/
completionState?: string | null;
/**
* Output only. Convert job details.
*/
convertJobDetails?: Schema$ConvertJobDetails;
/**
* The timestamp when the background job was finished.
*/
finishTime?: string | null;
/**
* The background job log entry ID.
*/
id?: string | null;
/**
* Output only. Import rules job details.
*/
importRulesJobDetails?: Schema$ImportRulesJobDetails;
/**
* The type of job that was executed.
*/
jobType?: string | null;
/**
* Output only. Whether the client requested the conversion workspace to be committed after a successful completion of the job.
*/
requestAutocommit?: boolean | null;
/**
* Output only. Seed job details.
*/
seedJobDetails?: Schema$SeedJobDetails;
/**
* The timestamp when the background job was started.
*/
startTime?: string | null;
}
/**
* Associates `members`, or principals, with a `role`.
*/
export interface Schema$Binding {
/**
* The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
*/
condition?: Schema$Expr;
/**
* Specifies the principals requesting access for a Google Cloud resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. Does not include identities that come from external identity providers (IdPs) through identity federation. * `user:{emailid\}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid\}`: An email address that represents a Google service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `serviceAccount:{projectid\}.svc.id.goog[{namespace\}/{kubernetes-sa\}]`: An identifier for a [Kubernetes service account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts). For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * `group:{emailid\}`: An email address that represents a Google group. For example, `admins@example.com`. * `domain:{domain\}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. * `deleted:user:{emailid\}?uid={uniqueid\}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid\}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid\}?uid={uniqueid\}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid\}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid\}?uid={uniqueid\}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid\}` and the recovered group retains the role in the binding.
*/
members?: string[] | null;
/**
* Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
*/
role?: string | null;
}
/**
* The request message for Operations.CancelOperation.
*/
export interface Schema$CancelOperationRequest {
}
/**
* Specifies required connection parameters, and, optionally, the parameters required to create a Cloud SQL destination database instance.
*/
export interface Schema$CloudSqlConnectionProfile {
/**
* Output only. The Cloud SQL database instance's additional (outgoing) public IP. Used when the Cloud SQL database availability type is REGIONAL (i.e. multiple zones / highly available).
*/
additionalPublicIp?: string | null;
/**
* Output only. The Cloud SQL instance ID that this connection profile is associated with.
*/
cloudSqlId?: string | null;
/**
* Output only. The Cloud SQL database instance's private IP.
*/
privateIp?: string | null;
/**
* Output only. The Cloud SQL database instance's public IP.
*/
publicIp?: string | null;
/**
* Immutable. Metadata used to create the destination Cloud SQL database.
*/
settings?: Schema$CloudSqlSettings;
}
/**
* Settings for creating a Cloud SQL database instance.
*/
export interface Schema$CloudSqlSettings {
/**
* The activation policy specifies when the instance is activated; it is applicable only when the instance state is 'RUNNABLE'. Valid values: 'ALWAYS': The instance is on, and remains so even in the absence of connection requests. `NEVER`: The instance is off; it is not activated, even if a connection request arrives.
*/
activationPolicy?: string | null;
/**
* [default: ON] If you enable this setting, Cloud SQL checks your available storage every 30 seconds. If the available storage falls below a threshold size, Cloud SQL automatically adds additional storage capacity. If the available storage repeatedly falls below the threshold size, Cloud SQL continues to add storage until it reaches the maximum of 30 TB.
*/
autoStorageIncrease?: boolean | null;
/**
* Optional. Availability type. Potential values: * `ZONAL`: The instance serves data from only one zone. Outages in that zone affect data availability. * `REGIONAL`: The instance can serve data from more than one zone in a region (it is highly available).
*/
availabilityType?: string | null;
/**
* The KMS key name used for the csql instance.
*/
cmekKeyName?: string | null;
/**
* The Cloud SQL default instance level collation.
*/
collation?: string | null;
/**
* The database flags passed to the Cloud SQL instance at startup. An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" \}.
*/
databaseFlags?: {
[key: string]: string;
} | null;
/**
* The database engine type and version.
*/
databaseVersion?: string | null;
/**
* The storage capacity available to the database, in GB. The minimum (and default) size is 10GB.
*/
dataDiskSizeGb?: string | null;
/**
* The type of storage: `PD_SSD` (default) or `PD_HDD`.
*/
dataDiskType?: string | null;
/**
* Optional. The edition of the given Cloud SQL instance.
*/
edition?: string | null;
/**
* The settings for IP Management. This allows to enable or disable the instance IP and manage which external networks can connect to the instance. The IPv4 address cannot be disabled.
*/
ipConfig?: Schema$SqlIpConfig;
/**
* Input only. Initial root password.
*/
rootPassword?: string | null;
/**
* Output only. Indicates If this connection profile root password is stored.
*/
rootPasswordSet?: boolean | null;
/**
* Optional. The Google Cloud Platform zone where the failover Cloud SQL database instance is located. Used when the Cloud SQL database availability type is REGIONAL (i.e. multiple zones / highly available).
*/
secondaryZone?: string | null;
/**
* The Database Migration Service source connection profile ID, in the format: `projects/my_project_name/locations/us-central1/connectionProfiles/connection_profile_ID`
*/
sourceId?: string | null;
/**
* The maximum size to which storage capacity can be automatically increased. The default value is 0, which specifies that there is no limit.
*/
storageAutoResizeLimit?: string | null;
/**
* The tier (or machine type) for this instance, for example: `db-n1-standard-1` (MySQL instances) or `db-custom-1-3840` (PostgreSQL instances). For more information, see [Cloud SQL Instance Settings](https://cloud.google.com/sql/docs/mysql/instance-settings).
*/
tier?: string | null;
/**
* The resource labels for a Cloud SQL instance to use to annotate any related underlying resources such as Compute Engine VMs. An object containing a list of "key": "value" pairs. Example: `{ "name": "wrench", "mass": "18kg", "count": "3" \}`.
*/
userLabels?: {
[key: string]: string;
} | null;
/**
* The Google Cloud Platform zone where your Cloud SQL database instance is located.
*/
zone?: string | null;
}
/**
* Column is not used as an independent entity, it is retrieved as part of a Table entity.
*/
export interface Schema$ColumnEntity {
/**
* Is the column of array type.
*/
array?: boolean | null;
/**
* If the column is array, of which length.
*/
arrayLength?: number | null;
/**
* Is the column auto-generated/identity.
*/
autoGenerated?: boolean | null;
/**
* Charset override - instead of table level charset.
*/
charset?: string | null;
/**
* Collation override - instead of table level collation.
*/
collation?: string | null;
/**
* Comment associated with the column.
*/
comment?: string | null;
/**
* Custom engine specific features.
*/
customFeatures?: {
[key: string]: any;
} | null;
/**
* Column data type.
*/
dataType?: string | null;
/**
* Default value of the column.
*/
defaultValue?: string | null;
/**
* Column fractional second precision - used for timestamp based datatypes.
*/
fractionalSecondsPrecision?: number | null;
/**
* Column length - e.g. varchar (50).
*/
length?: string | null;
/**
* Column name.
*/
name?: string | null;
/**
* Is the column nullable.
*/
nullable?: boolean | null;
/**
* Column order in the table.
*/
ordinalPosition?: number | null;
/**
* Column precision - when relevant.
*/
precision?: number | null;
/**
* Column scale - when relevant.
*/
scale?: number | null;
/**
* Specifies the list of values allowed in the column. Only used for set data type.
*/
setValues?: string[] | null;
/**
* Is the column a UDT.
*/
udt?: boolean | null;
}
/**
* Request message for 'CommitConversionWorkspace' request.
*/
export interface Schema$CommitConversionWorkspaceRequest {
/**
* Optional. Optional name of the commit.
*/
commitName?: string | null;
}
/**
* Options to configure rule type ConditionalColumnSetValue. The rule is used to transform the data which is being replicated/migrated. The rule filter field can refer to one or more entities. The rule scope can be one of: Column.
*/
export interface Schema$ConditionalColumnSetValue {
/**
* Optional. Custom engine specific features.
*/
customFeatures?: {
[key: string]: any;
} | null;
/**
* Optional. Optional filter on source column precision and scale. Used for fixed point numbers such as NUMERIC/NUMBER data types.
*/
sourceNumericFilter?: Schema$SourceNumericFilter;
/**
* Optional. Optional filter on source column length. Used for text based data types like varchar.
*/
sourceTextFilter?: Schema$SourceTextFilter;
/**
* Required. Description of data transformation during migration.
*/
valueTransformation?: Schema$ValueTransformation;
}
/**
* A connection profile definition.
*/
export interface Schema$ConnectionProfile {
/**
* An AlloyDB cluster connection profile.
*/
alloydb?: Schema$AlloyDbConnectionProfile;
/**
* A CloudSQL database connection profile.
*/
cloudsql?: Schema$CloudSqlConnectionProfile;
/**
* Output only. The timestamp when the resource was created. A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds. Example: "2014-10-02T15:01:23.045123456Z".
*/
createTime?: string | null;
/**
* The connection profile display name.
*/
displayName?: string | null;
/**
* Output only. The error details in case of state FAILED.
*/
error?: Schema$Status;
/**
* The resource labels for connection profile to use to annotate any related underlying resources such as Compute Engine VMs. An object containing a list of "key": "value" pairs. Example: `{ "name": "wrench", "mass": "1.3kg", "count": "3" \}`.
*/
labels?: {
[key: string]: string;
} | null;
/**
* A MySQL database connection profile.
*/
mysql?: Schema$MySqlConnectionProfile;
/**
* The name of this connection profile resource in the form of projects/{project\}/locations/{location\}/connectionProfiles/{connectionProfile\}.
*/
name?: string | null;
/**
* An Oracle database connection profile.
*/
oracle?: Schema$OracleConnectionProfile;
/**
* A PostgreSQL database connection profile.
*/
postgresql?: Schema$PostgreSqlConnectionProfile;
/**
* The database provider.
*/
provider?: string | null;
/**
* The current connection profile state (e.g. DRAFT, READY, or FAILED).
*/
state?: string | null;
/**
* Output only. The timestamp when the resource was last updated. A timestamp in RFC3339 UTC "Zulu" format, accurate to nanoseconds. Example: "2014-10-02T15:01:23.045123456Z".
*/
updateTime?: string | null;
}
/**
* Constraint is not used as an independent entity, it is retrieved as part of another entity such as Table or View.
*/
export interface Schema$ConstraintEntity {
/**
* Custom engine specific features.
*/
customFeatures?: {
[key: string]: any;
} | null;
/**
* The name of the table constraint.
*/
name?: string | null;
/**
* Reference columns which may be associated with the constraint. For example, if the constraint is a FOREIGN_KEY, this represents the list of full names of referenced columns by the foreign key.
*/
referenceColumns?: string[] | null;
/**
* Reference table which may be associated with the constraint. For example, if the constraint is a FOREIGN_KEY, this represents the list of full name of the referenced table by the foreign key.
*/
referenceTable?: string | null;
/**
* Table columns used as part of the Constraint, for example primary key constraint should list the columns which constitutes the key.
*/
tableColumns?: string[] | null;
/**
* Table which is associated with the constraint. In case the constraint is defined on a table, this field is left empty as this information is stored in parent_name. However, if constraint is defined on a view, this field stores the table name on which the view is defined.
*/
tableName?: string | null;
/**
* Type of constraint, for example unique, primary key, foreign key (currently only primary key is supported).
*/
type?: string | null;
}
/**
* The main conversion workspace resource entity.
*/
export interface Schema$ConversionWorkspace {
/**
* Output only. The timestamp when the workspace resource was created.
*/
createTime?: string | null;
/**
* Required. The destination engine details.
*/
destination?: Schema$DatabaseEngineInfo;
/**
* Optional. The display name for the workspace.
*/
displayName?: string | null;
/**
* Optional. A generic list of settings for the workspace. The settings are database pair dependant and can indicate default behavior for the mapping rules engine or turn on or off specific features. Such examples can be: convert_foreign_key_to_interleave=true, skip_triggers=false, ignore_non_table_synonyms=true
*/
globalSettings?: {
[key: string]: string;
} | null;
/**
* Output only. Whether the workspace has uncommitted changes (changes which were made after the workspace was committed).
*/
hasUncommittedChanges?: boolean | null;
/**
* Output only. The latest commit ID.
*/
latestCommitId?: string | null;
/**
* Output only. The timestamp when the workspace was committed.
*/
latestCommitTime?: string | null;
/**
* Full name of the workspace resource, in the form of: projects/{project\}/locations/{location\}/conversionWorkspaces/{conversion_workspace\}.
*/
name?: string | null;
/**
* Required. The source engine details.
*/
source?: Schema$DatabaseEngineInfo;
/**
* Output only. The timestamp when the workspace resource was last updated.
*/
updateTime?: string | null;
}
/**
* A conversion workspace's version.
*/
export interface Schema$ConversionWorkspaceInfo {
/**
* The commit ID of the conversion workspace.
*/
commitId?: string | null;
/**
* The resource name (URI) of the conversion workspace.
*/
name?: string | null;
}
/**
* Request message for 'ConvertConversionWorkspace' request.
*/
export interface Schema$ConvertConversionWorkspaceRequest {
/**
* Optional. Specifies whether the conversion workspace is to be committed automatically after the conversion.
*/
autoCommit?: boolean | null;
/**
* Optional. Automatically convert the full entity path for each entity specified by the filter. For example, if the filter specifies a table, that table schema (and database if there is one) will also be converted.
*/
convertFullPath?: boolean | null;
/**
* Optional. Filter the entities to convert. Leaving this field empty will convert all of the entities. Supports Google AIP-160 style filtering.
*/
filter?: string | null;
}
/**
* Details regarding a Convert background job.
*/
export interface Schema$ConvertJobDetails {
/**
* Output only. AIP-160 based filter used to specify the entities to convert
*/
filter?: string | null;
}
/**
* Options to configure rule type ConvertROWIDToColumn. The rule is used to add column rowid to destination tables based on an Oracle rowid function/property. The rule filter field can refer to one or more entities. The rule scope can be one of: Table. This rule requires additional filter to be specified beyond the basic rule filter field, which is whether or not to work on tables which already have a primary key defined.
*/
export interface Schema$ConvertRowIdToColumn {
/**
* Required. Only work on tables without primary key defined
*/
onlyIfNoPrimaryKey?: boolean | null;
}
/**
* The type and version of a source or destination database.
*/
export interface Schema$DatabaseEngineInfo {
/**
* Required. Engine type.
*/
engine?: string | null;
/**
* Required. Engine named version, for example 12.c.1.
*/
version?: string | null;
}
/**
* The base entity type for all the database related entities. The message contains the entity name, the name of its parent, the entity type, and the specific details per entity type.
*/
export interface Schema$DatabaseEntity {
/**
* Database.
*/
database?: Schema$DatabaseInstanceEntity;
/**
* Function.
*/
databaseFunction?: Schema$FunctionEntity;
/**
* Package.
*/
databasePackage?: Schema$PackageEntity;
/**
* Details about the entity DDL script. Multiple DDL scripts are provided for child entities such as a table entity will have one DDL for the table with additional DDLs for each index, constraint and such.
*/
entityDdl?: Schema$EntityDdl[];
/**
* The type of the database entity (table, view, index, ...).
*/
entityType?: string | null;
/**
* Details about the various issues found for the entity.
*/
issues?: Schema$EntityIssue[];
/**
* Details about entity mappings. For source tree entities, this holds the draft entities which were generated by the mapping rules. For draft tree entities, this holds the source entities which were converted to form the draft entity. Destination entities will have no mapping details.
*/
mappings?: Schema$EntityMapping[];
/**
* Materialized view.
*/
materializedView?: Schema$MaterializedViewEntity;
/**
* The full name of the parent entity (e.g. schema name).
*/
parentEntity?: string | null;
/**
* Schema.
*/
schema?: Schema$SchemaEntity;
/**
* Sequence.
*/
sequence?: Schema$SequenceEntity;
/**
* The short name (e.g. table name) of the entity.
*/
shortName?: string | null;
/**
* Stored procedure.
*/
storedProcedure?: Schema$StoredProcedureEntity;
/**
* Synonym.
*/
synonym?: Schema$SynonymEntity;
/**
* Table.
*/
table?: Schema$TableEntity;
/**
* The type of tree the entity belongs to.
*/
tree?: string | null;
/**
* UDT.
*/
udt?: Schema$UDTEntity;
/**
* View.
*/
view?: Schema$ViewEntity;
}
/**
* DatabaseInstance acts as a parent entity to other database entities.
*/
export interface Schema$DatabaseInstanceEntity {
/**
* Custom engine specific features.
*/
customFeatures?: {
[key: string]: any;
} | null;
}
/**
* A message defining the database engine and provider.
*/
export interface Schema$DatabaseType {
/**
* The database engine.
*/
engine?: string | null;
/**
* The database provider.
*/
provider?: string | null;
}
/**
* Response message for 'DescribeConversionWorkspaceRevisions' request.
*/
export interface Schema$DescribeConversionWorkspaceRevisionsResponse {
/**
* The list of conversion workspace revisions.
*/
revisions?: Schema$ConversionWorkspace[];
}
/**
* Response message for 'DescribeDatabaseEntities' request.
*/
export interface Schema$DescribeDatabaseEntitiesResponse {
/**
* The list of database entities for the conversion workspace.
*/
databaseEntities?: Schema$DatabaseEntity[];
/**
* 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;
}
/**
* Filter based on relation between source value and compare value of type double in ConditionalColumnSetValue
*/
export interface Schema$DoubleComparisonFilter {
/**
* Required. Double compare value to be used
*/
value?: number | null;
/**
* Required. Relation between source value and compare value
*/
valueComparison?: string | null;
}
/**
* Dump flag definition.
*/
export interface Schema$DumpFlag {
/**
* The name of the flag
*/
name?: string | null;
/**
* The value of the flag.
*/
value?: string | null;
}
/**
* Dump flags definition.
*/
export interface Schema$DumpFlags {
/**
* The flags for the initial dump.
*/
dumpFlags?: Schema$DumpFlag[];
}
/**
* 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 {
}
/**
* EncryptionConfig describes the encryption config of a cluster that is encrypted with a CMEK (customer-managed encryption key).
*/
export interface Schema$EncryptionConfig {
/**
* The fully-qualified resource name of the KMS key. Each Cloud KMS key is regionalized and has the following format: projects/[PROJECT]/locations/[REGION]/keyRings/[RING]/cryptoKeys/[KEY_NAME]
*/
kmsKeyName?: string | null;
}
/**
* A single DDL statement for a specific entity
*/
export interface Schema$EntityDdl {
/**
* The actual ddl code.
*/
ddl?: string | null;
/**
* Type of DDL (Create, Alter).
*/
ddlType?: string | null;
/**
* The name of the database entity the ddl refers to.
*/
entity?: string | null;
/**
* The entity type (if the DDL is for a sub entity).
*/
entityType?: string | null;
/**
* EntityIssues found for this ddl.
*/
issueId?: string[] | null;
}
/**
* Issue related to the entity.
*/
export interface Schema$EntityIssue {
/**
* Error/Warning code
*/
code?: string | null;
/**
* The ddl which caused the issue, if relevant.
*/
ddl?: string | null;
/**
* The entity type (if the DDL is for a sub entity).
*/
entityType?: string | null;
/**
* Unique Issue ID.
*/
id?: string | null;
/**
* Issue detailed message
*/
message?: string | null;
/**
* The position of the issue found, if relevant.
*/
position?: Schema$Position;
/**
* Severity of the issue
*/
severity?: string | null;
/**
* The type of the issue.
*/
type?: string | null;
}
/**
* Details of the mappings of a database entity.
*/
export interface Schema$EntityMapping {
/**
* Target entity full name. The draft entity can also include a column, index or constraint using the same naming notation schema.table.column.
*/
draftEntity?: string | null;
/**
* Type of draft entity.
*/
draftType?: string | null;
/**
* Entity mapping log entries. Multiple rules can be effective and contribute changes to a converted entity, such as a rule can handle the entity name, another rule can handle an entity type. In addition, rules which did not change the entity are also logged along with the reason preventing them to do so.
*/
mappingLog?: Schema$EntityMappingLogEntry[];
/**
* Source entity full name. The source entity can also be a column, index or constraint using the same naming notation schema.table.column.
*/
sourceEntity?: string | null;
/**
* Type of source entity.
*/
sourceType?: string | null;
}
/**
* A single record of a rule which was used for a mapping.
*/
export interface Schema$EntityMappingLogEntry {
/**
* Comment.
*/
mappingComment?: string | null;
/**
* Which rule caused this log entry.
*/
ruleId?: string | null;
/**
* Rule revision ID.
*/
ruleRevisionId?: string | null;
}
/**
* Options to configure rule type EntityMove. The rule is used to move an entity to a new schema. The rule filter field can refer to one or more entities. The rule scope can be one of: Table, Column, Constraint, Index, View, Function, Stored Procedure, Materialized View, Sequence, UDT
*/
export interface Schema$EntityMove {
/**
* Required. The new schema
*/
newSchema?: string | null;
}
/**
* Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.
*/
export interface Schema$Expr {
/**
* Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
*/
description?: string | null;
/**
* Textual representation of an expression in Common Expression Language syntax.
*/
expression?: string | null;
/**
* Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
*/
location?: string | null;
/**
* Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
*/
title?: string | null;
}
/**
* Response message for a 'FetchStaticIps' request.
*/
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.
*/
staticIps?: string[] | null;
}
/**
* Options to configure rule type FilterTableColumns. The rule is used to filter the list of columns to include or exclude from a table. The rule filter field can refer to one entity. The rule scope can be: Table Only one of the two lists can be specified for the rule.
*/
export interface Schema$FilterTableColumns {
/**
* Optional. List of columns to be excluded for a particular table.
*/
excludeColumns?: string[] | null;
/**
* Optional. List of columns to be included for a particular table.
*/
includeColumns?: 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;
}
/**
* Function's parent is a schema.
*/
export interface Schema$FunctionEntity {
/**
* Custom engine specific features.
*/
customFeatures?: {
[key: string]: any;
} | null;
/**
* The SQL code which creates the function.
*/
sqlCode?: string | null;
}
/**
* Request message for 'GenerateSshScript' request.
*/
export interface Schema$GenerateSshScriptRequest {
/**
* Required. Bastion VM Instance name to use or to create.
*/
vm?: string | null;
/**
* The VM creation configuration
*/
vmCreationConfig?: Schema$VmCreationConfig;
/**
* The port that will be open on the bastion host.
*/
vmPort?: number | null;
/**
* The VM selection configuration
*/
vmSelectionConfig?: Schema$VmSelectionConfig;
}
/**
* Request message for 'GenerateTcpProxyScript' request.
*/
export interface Schema$GenerateTcpProxyScriptRequest {
/**
* Required. The type of the Compute instance that will host the proxy.
*/
vmMachineType?: string | null;
/**
* Required. The name of the Compute instance that will host the proxy.
*/
vmName?: string | null;
/**
* Required. The name of the subnet the Compute instance will use for private connectivity. Must be supplied in the form of projects/{project\}/regions/{region\}/subnetworks/{subnetwork\}. Note: the region for the subnet must match the Compute instance region.
*/
vmSubnet?: string | null;
/**
* Optional. The Google Cloud Platform zone to create the VM in. The fully qualified name of the zone must be specified, including the region name, for example "us-central1-b". If not specified, uses the "-b" zone of the destination Connection Profile's region.
*/
vmZone?: string | null;
}
/**
* Represents the metadata of the long-running operation.
*/
export interface Schema$GoogleCloudClouddmsV1OperationMetadata {
/**
* 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 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. Name of the verb executed by the operation.
*/
verb?: string | null;
}
/**
* Request message for 'ImportMappingRules' request.
*/
export interface Schema$ImportMappingRulesRequest {
/**
* Required. Should the conversion workspace be committed automatically after the import operation.
*/
autoCommit?: boolean | null;
/**
* Required. One or more rules files.
*/
rulesFiles?: Schema$RulesFile[];
/**
* Required. The format of the rules content file.
*/
rulesFormat?: string | null;
}
/**
* Details regarding an Import Rules background job.
*/
export interface Schema$ImportRulesJobDetails {
/**
* Output only. The requested file format.
*/
fileFormat?: string | null;
/**
* Output only. File names used for the import rules job.
*/
files?: string[] | null;
}
/**
* Index is not used as an independent entity, it is retrieved as part of a Table entity.
*/
export interface Schema$IndexEntity {
/**
* Custom engine specific features.
*/
customFeatures?: {
[key: string]: any;
} | null;
/**
* The name of the index.
*/
name?: string | null;
/**
* Table columns used as part of the Index, for example B-TREE index should list the columns which constitutes the index.
*/
tableColumns?: string[] | null;
/**
* Type of index, for example B-TREE.
*/
type?: string | null;
/**
* Boolean value indicating whether the index is unique.
*/
unique?: boolean | null;
}
/**
* Filter based on relation between source value and compare value of type integer in ConditionalColumnSetValue
*/
export interface Schema$IntComparisonFilter {
/**
* Required. Integer compare value to be used
*/
value?: string | null;
/**
* Required. Relation between source value and compare value
*/
valueComparison?: string | null;
}
/**
* Response message for 'ListConnectionProfiles' request.
*/
export interface Schema$ListConnectionProfilesResponse {
/**
* The response 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;
}
/**
* Response message for 'ListConversionWorkspaces' request.
*/
export interface Schema$ListConversionWorkspacesResponse {
/**
* The list of conversion workspace objects.
*/
conversionWorkspaces?: Schema$ConversionWorkspace[];
/**
* 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