googleapis
Version:
Google APIs Client Library for Node.js
1,549 lines • 438 kB
TypeScript
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { Readable } from 'stream';
export declare namespace migrationcenter_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;
}
/**
* Migration Center API
*
* A unified platform that helps you accelerate your end-to-end cloud journey from your current on-premises or cloud environments to Google Cloud.
*
* @example
* ```js
* const {google} = require('googleapis');
* const migrationcenter = google.migrationcenter('v1');
* ```
*/
export class Migrationcenter {
context: APIRequestContext;
projects: Resource$Projects;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* A request to add assets to a group.
*/
export interface Schema$AddAssetsToGroupRequest {
/**
* Optional. When this value is set to `false` and one of the given assets is already an existing member of the group, the operation fails with an `Already Exists` error. When set to `true` this situation is silently ignored by the server. Default value is `false`.
*/
allowExisting?: boolean | null;
/**
* Required. List of assets to be added. The maximum number of assets that can be added in a single request is 2000.
*/
assets?: Schema$AssetList;
/**
* Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes after the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).
*/
requestId?: string | null;
}
/**
* A request to aggregate one or more values.
*/
export interface Schema$AggregateAssetsValuesRequest {
/**
* Array of aggregations to perform. Up to 25 aggregations can be defined.
*/
aggregations?: Schema$Aggregation[];
/**
* Optional. The aggregation will be performed on assets that match the provided filter.
*/
filter?: string | null;
/**
* Optional. When this value is set to 'true' the response will include all assets, including those that are hidden.
*/
showHidden?: boolean | null;
}
/**
* A response to a request to aggregated assets values.
*/
export interface Schema$AggregateAssetsValuesResponse {
/**
* The aggregation results.
*/
results?: Schema$AggregationResult[];
}
/**
* Message describing an aggregation. The message includes the aggregation type, parameters, and the field on which to perform the aggregation.
*/
export interface Schema$Aggregation {
/**
* Count the number of matching objects.
*/
count?: Schema$AggregationCount;
/**
* The name of the field on which to aggregate.
*/
field?: string | null;
/**
* Creates a frequency distribution of all field values.
*/
frequency?: Schema$AggregationFrequency;
/**
* Creates a bucketed histogram of field values.
*/
histogram?: Schema$AggregationHistogram;
/**
* Sum over a numeric field.
*/
sum?: Schema$AggregationSum;
}
/**
* Object count.
*/
export interface Schema$AggregationCount {
}
/**
* Frequency distribution of all field values.
*/
export interface Schema$AggregationFrequency {
}
/**
* Histogram of bucketed assets counts by field value.
*/
export interface Schema$AggregationHistogram {
/**
* Lower bounds of buckets. The response will contain `n+1` buckets for `n` bounds. The first bucket will count all assets for which the field value is smaller than the first bound. Subsequent buckets will count assets for which the field value is greater or equal to a lower bound and smaller than the next one. The last bucket will count assets for which the field value is greater or equal to the final lower bound. You can define up to 20 lower bounds.
*/
lowerBounds?: number[] | null;
}
/**
* Message describing a result of an aggregation.
*/
export interface Schema$AggregationResult {
count?: Schema$AggregationResultCount;
field?: string | null;
frequency?: Schema$AggregationResultFrequency;
histogram?: Schema$AggregationResultHistogram;
sum?: Schema$AggregationResultSum;
}
/**
* The result of a count aggregation.
*/
export interface Schema$AggregationResultCount {
value?: string | null;
}
/**
* The result of a frequency distribution aggregation.
*/
export interface Schema$AggregationResultFrequency {
values?: {
[key: string]: string;
} | null;
}
/**
* The result of a bucketed histogram aggregation.
*/
export interface Schema$AggregationResultHistogram {
/**
* Buckets in the histogram. There will be `n+1` buckets matching `n` lower bounds in the request. The first bucket will be from -infinity to the first bound. Subsequent buckets will be between one bound and the next. The final bucket will be from the final bound to infinity.
*/
buckets?: Schema$AggregationResultHistogramBucket[];
}
/**
* A histogram bucket with a lower and upper bound, and a count of items with a field value between those bounds. The lower bound is inclusive and the upper bound is exclusive. Lower bound may be -infinity and upper bound may be infinity.
*/
export interface Schema$AggregationResultHistogramBucket {
/**
* Count of items in the bucket.
*/
count?: string | null;
/**
* Lower bound - inclusive.
*/
lowerBound?: number | null;
/**
* Upper bound - exclusive.
*/
upperBound?: number | null;
}
/**
* The result of a sum aggregation.
*/
export interface Schema$AggregationResultSum {
value?: number | null;
}
/**
* Sum of field values.
*/
export interface Schema$AggregationSum {
}
/**
* An asset represents a resource in your environment. Asset types include virtual machines and databases.
*/
export interface Schema$Asset {
/**
* Output only. The list of groups that the asset is assigned to.
*/
assignedGroups?: string[] | null;
/**
* Generic asset attributes.
*/
attributes?: {
[key: string]: string;
} | null;
/**
* Output only. The timestamp when the asset was created.
*/
createTime?: string | null;
/**
* Output only. Asset information specific for database deployments.
*/
databaseDeploymentDetails?: Schema$DatabaseDeploymentDetails;
/**
* Output only. Asset information specific for logical databases.
*/
databaseDetails?: Schema$DatabaseDetails;
/**
* Optional. Indicates if the asset is hidden.
*/
hidden?: boolean | null;
/**
* Optional. An optional reason for marking this asset as hidden.
*/
hideReason?: string | null;
/**
* Output only. The timestamp when the asset was marked as hidden.
*/
hideTime?: string | null;
/**
* Output only. The list of insights associated with the asset.
*/
insightList?: Schema$InsightList;
/**
* Labels as key value pairs.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Output only. Asset information specific for virtual and physical machines.
*/
machineDetails?: Schema$MachineDetails;
/**
* Output only. The full name of the asset.
*/
name?: string | null;
/**
* Output only. Performance data for the asset.
*/
performanceData?: Schema$AssetPerformanceData;
/**
* Output only. The list of sources contributing to the asset.
*/
sources?: string[] | null;
/**
* Output only. Server generated human readable name of the asset.
*/
title?: string | null;
/**
* Output only. The timestamp when the asset was last updated.
*/
updateTime?: string | null;
}
/**
* Contains data reported from an inventory source on an asset.
*/
export interface Schema$AssetFrame {
/**
* Generic asset attributes.
*/
attributes?: {
[key: string]: string;
} | null;
/**
* Optional. Frame collection type, if not specified the collection type will be based on the source type of the source the frame was reported on.
*/
collectionType?: string | null;
/**
* Asset information specific for database deployments.
*/
databaseDeploymentDetails?: Schema$DatabaseDeploymentDetails;
/**
* Asset information specific for logical databases.
*/
databaseDetails?: Schema$DatabaseDetails;
/**
* Labels as key value pairs.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Asset information specific for virtual machines.
*/
machineDetails?: Schema$MachineDetails;
/**
* Asset performance data samples. Samples that are from more than 40 days ago or after tomorrow are ignored.
*/
performanceSamples?: Schema$PerformanceSample[];
/**
* The time the data was reported.
*/
reportTime?: string | null;
/**
* Optional. Trace token is optionally provided to assist with debugging and traceability.
*/
traceToken?: string | null;
}
/**
* Lists the asset IDs of all assets.
*/
export interface Schema$AssetList {
/**
* Required. A list of asset IDs
*/
assetIds?: string[] | null;
}
/**
* Performance data for an asset.
*/
export interface Schema$AssetPerformanceData {
/**
* Daily resource usage aggregations. Contains all of the data available for an asset, up to the last 420 days. Aggregations are sorted from oldest to most recent.
*/
dailyResourceUsageAggregations?: Schema$DailyResourceUsageAggregation[];
}
/**
* Assets export job message.
*/
export interface Schema$AssetsExportJob {
/**
* Optional. Conditions for selecting assets to export.
*/
condition?: Schema$AssetsExportJobExportCondition;
/**
* Output only. Resource creation time.
*/
createTime?: string | null;
/**
* Export asset inventory details.
*/
inventory?: Schema$AssetsExportJobInventory;
/**
* Optional. Labels as key value pairs. Labels must meet the following constraints: * Keys and values can contain only lowercase letters, numeric characters, underscores, and dashes. * All characters must use UTF-8 encoding, and international characters are allowed. * Keys must start with a lowercase letter or international character. * Each resource is limited to a maximum of 64 labels. Both keys and values are additionally constrained to be <= 128 bytes.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Output only. Identifier. Resource name.
*/
name?: string | null;
/**
* Export data regarding asset network dependencies.
*/
networkDependencies?: Schema$AssetsExportJobNetworkDependencies;
/**
* Export asset with performance data.
*/
performanceData?: Schema$AssetsExportJobPerformanceData;
/**
* Output only. Recent non expired executions of the job.
*/
recentExecutions?: Schema$AssetsExportJobExecution[];
/**
* Optional. When this value is set to 'true' the response will include all assets, including those that are hidden.
*/
showHidden?: boolean | null;
/**
* Export to Cloud Storage files downloadable using signed URIs.
*/
signedUriDestination?: Schema$SignedUriDestination;
/**
* Output only. Resource update time.
*/
updateTime?: string | null;
}
/**
* Execution status of assets export job.
*/
export interface Schema$AssetsExportJobExecution {
/**
* Output only. Completion time of the export.
*/
endTime?: string | null;
/**
* Output only. Globally unique identifier of the execution.
*/
executionId?: string | null;
/**
* Output only. Expiration time for the export and artifacts.
*/
expireTime?: string | null;
/**
* Output only. Number of assets requested for export after resolving the requested filters.
*/
requestedAssetCount?: number | null;
/**
* Output only. Result of the export execution.
*/
result?: Schema$AssetsExportJobExecutionResult;
/**
* Output only. Execution timestamp.
*/
startTime?: string | null;
}
/**
* Contains the result of the assets export.
*/
export interface Schema$AssetsExportJobExecutionResult {
/**
* Output only. Error encountered during export.
*/
error?: Schema$Status;
/**
* Output only. List of output files.
*/
outputFiles?: Schema$OutputFileList;
/**
* Output only. Signed URLs for downloading export artifacts.
*/
signedUris?: Schema$SignedUris;
}
/**
* Conditions for selecting assets to export.
*/
export interface Schema$AssetsExportJobExportCondition {
/**
* Optional. Assets filter, supports the same syntax as asset listing.
*/
filter?: string | null;
}
/**
* Configuration for asset inventory details exports.
*/
export interface Schema$AssetsExportJobInventory {
}
/**
* Configuration for network dependencies exports.
*/
export interface Schema$AssetsExportJobNetworkDependencies {
}
/**
* Configuration for performance data exports.
*/
export interface Schema$AssetsExportJobPerformanceData {
/**
* Optional. When this value is set to a positive integer, performance data will be returned for the most recent days for which data is available. When this value is unset (or set to zero), all available data is returned. The maximum value is 420; values above 420 will be coerced to 420. If unset (0 value) a default value of 40 will be used.
*/
maxDays?: number | null;
}
/**
* AWS EC2 specific details.
*/
export interface Schema$AwsEc2PlatformDetails {
/**
* Optional. Whether the machine is hyperthreaded.
*/
hyperthreading?: string | null;
/**
* The location of the machine in the AWS format.
*/
location?: string | null;
/**
* AWS platform's machine type label.
*/
machineTypeLabel?: string | null;
}
/**
* Specific details for an AWS RDS database deployment.
*/
export interface Schema$AwsRds {
}
/**
* Azure VM specific details.
*/
export interface Schema$AzureVmPlatformDetails {
/**
* Whether the machine is hyperthreaded.
*/
hyperthreading?: string | null;
/**
* The location of the machine in the Azure format.
*/
location?: string | null;
/**
* Azure platform's machine type label.
*/
machineTypeLabel?: string | null;
/**
* Azure platform's provisioning state.
*/
provisioningState?: string | null;
}
/**
* A request to delete a list of asset.
*/
export interface Schema$BatchDeleteAssetsRequest {
/**
* Optional. When this value is set to `true` the request is a no-op for non-existing assets. See https://google.aip.dev/135#delete-if-existing for additional details. Default value is `false`.
*/
allowMissing?: boolean | null;
/**
* Optional. Optional cascading rules for deleting related assets.
*/
cascadingRules?: Schema$CascadingRule[];
/**
* Required. The IDs of the assets to delete. A maximum of 1000 assets can be deleted in a batch. Format: projects/{project\}/locations/{location\}/assets/{name\}.
*/
names?: string[] | null;
}
/**
* A request to update a list of assets.
*/
export interface Schema$BatchUpdateAssetsRequest {
/**
* Required. The request message specifying the resources to update. A maximum of 1000 assets can be modified in a batch.
*/
requests?: Schema$UpdateAssetRequest[];
}
/**
* Response for updating a list of assets.
*/
export interface Schema$BatchUpdateAssetsResponse {
/**
* Update asset content. The content only includes values after field mask being applied.
*/
assets?: Schema$Asset[];
}
/**
* Details about the BIOS.
*/
export interface Schema$BiosDetails {
/**
* BIOS name. This fields is deprecated. Please use the `id` field instead.
*/
biosName?: string | null;
/**
* BIOS ID.
*/
id?: string | null;
/**
* BIOS manufacturer.
*/
manufacturer?: string | null;
/**
* BIOS release date.
*/
releaseDate?: Schema$Date;
/**
* SMBIOS UUID.
*/
smbiosUuid?: string | null;
/**
* BIOS version.
*/
version?: string | null;
}
/**
* The request message for Operations.CancelOperation.
*/
export interface Schema$CancelOperationRequest {
}
/**
* Cascading rule for related logical DBs.
*/
export interface Schema$CascadeLogicalDBsRule {
}
/**
* Specifies cascading rules for traversing relations.
*/
export interface Schema$CascadingRule {
/**
* Cascading rule for related logical DBs.
*/
cascadeLogicalDbs?: Schema$CascadeLogicalDBsRule;
}
/**
* Compute engine migration target.
*/
export interface Schema$ComputeEngineMigrationTarget {
/**
* Description of the suggested shape for the migration target.
*/
shape?: Schema$ComputeEngineShapeDescriptor;
}
/**
* The user preferences relating to Compute Engine target platform.
*/
export interface Schema$ComputeEnginePreferences {
/**
* License type to consider when calculating costs for virtual machine insights and recommendations. If unspecified, costs are calculated based on the default licensing plan.
*/
licenseType?: string | null;
/**
* Preferences concerning the machine types to consider on Compute Engine.
*/
machinePreferences?: Schema$MachinePreferences;
/**
* Persistent disk type to use. If unspecified (default), all types are considered, based on available usage data.
*/
persistentDiskType?: string | null;
}
/**
* Compute Engine target shape descriptor.
*/
export interface Schema$ComputeEngineShapeDescriptor {
/**
* Output only. Number of logical cores.
*/
logicalCoreCount?: number | null;
/**
* Output only. Compute Engine machine type.
*/
machineType?: string | null;
/**
* Memory in mebibytes.
*/
memoryMb?: number | null;
/**
* Number of physical cores.
*/
physicalCoreCount?: number | null;
/**
* Output only. Compute Engine machine series.
*/
series?: string | null;
/**
* Output only. Compute Engine storage. Never empty.
*/
storage?: Schema$ComputeStorageDescriptor[];
}
/**
* Compute Engine storage option descriptor.
*/
export interface Schema$ComputeStorageDescriptor {
/**
* Output only. Disk size in GiB.
*/
sizeGb?: number | null;
/**
* Output only. Disk type backing the storage.
*/
type?: string | null;
}
/**
* CPU usage sample.
*/
export interface Schema$CpuUsageSample {
/**
* Percentage of total CPU capacity utilized. Must be in the interval [0, 100]. On most systems can be calculated using 100 - idle percentage.
*/
utilizedPercentage?: number | null;
}
/**
* Contains a single output file of type CSV.
*/
export interface Schema$CsvOutputFile {
/**
* Output only. Number of columns in the file.
*/
columnsCount?: number | null;
/**
* Output only. Number of rows in the file.
*/
rowCount?: number | null;
/**
* Output only. Signed URI destination.
*/
signedUri?: Schema$SignedUri;
}
/**
* Usage data aggregation for a single day.
*/
export interface Schema$DailyResourceUsageAggregation {
/**
* CPU usage.
*/
cpu?: Schema$DailyResourceUsageAggregationCPU;
/**
* Aggregation date. Day boundaries are at midnight UTC.
*/
date?: Schema$Date;
/**
* Disk usage.
*/
disk?: Schema$DailyResourceUsageAggregationDisk;
/**
* Memory usage.
*/
memory?: Schema$DailyResourceUsageAggregationMemory;
/**
* Network usage.
*/
network?: Schema$DailyResourceUsageAggregationNetwork;
}
/**
* Statistical aggregation of CPU usage.
*/
export interface Schema$DailyResourceUsageAggregationCPU {
/**
* CPU utilization percentage.
*/
utilizationPercentage?: Schema$DailyResourceUsageAggregationStats;
}
/**
* Statistical aggregation of disk usage.
*/
export interface Schema$DailyResourceUsageAggregationDisk {
/**
* Optional. Disk I/O operations per second.
*/
iops?: Schema$DailyResourceUsageAggregationStats;
/**
* Optional. Disk read I/O operations per second.
*/
readIops?: Schema$DailyResourceUsageAggregationStats;
/**
* Optional. Disk write I/O operations per second.
*/
writeIops?: Schema$DailyResourceUsageAggregationStats;
}
/**
* Statistical aggregation of memory usage.
*/
export interface Schema$DailyResourceUsageAggregationMemory {
/**
* Memory utilization percentage.
*/
utilizationPercentage?: Schema$DailyResourceUsageAggregationStats;
}
/**
* Statistical aggregation of network usage.
*/
export interface Schema$DailyResourceUsageAggregationNetwork {
/**
* Network egress in B/s.
*/
egressBps?: Schema$DailyResourceUsageAggregationStats;
/**
* Network ingress in B/s.
*/
ingressBps?: Schema$DailyResourceUsageAggregationStats;
}
/**
* Statistical aggregation of samples for a single resource usage.
*/
export interface Schema$DailyResourceUsageAggregationStats {
/**
* Average usage value.
*/
average?: number | null;
/**
* Median usage value.
*/
median?: number | null;
/**
* 95th percentile usage value.
*/
ninteyFifthPercentile?: number | null;
/**
* Peak usage value.
*/
peak?: number | null;
}
/**
* The details of a database deployment asset.
*/
export interface Schema$DatabaseDeploymentDetails {
/**
* Output only. Aggregated stats for the database deployment.
*/
aggregatedStats?: Schema$DatabaseDeploymentDetailsAggregatedStats;
/**
* Optional. Details of an AWS RDS instance.
*/
awsRds?: Schema$AwsRds;
/**
* Optional. The database deployment edition.
*/
edition?: string | null;
/**
* Optional. The database deployment generated ID.
*/
generatedId?: string | null;
/**
* Optional. A manual unique ID set by the user.
*/
manualUniqueId?: string | null;
/**
* Optional. Details of a MYSQL database deployment.
*/
mysql?: Schema$MysqlDatabaseDeployment;
/**
* Optional. Details of a PostgreSQL database deployment.
*/
postgresql?: Schema$PostgreSqlDatabaseDeployment;
/**
* Optional. Details of a Microsoft SQL Server database deployment.
*/
sqlServer?: Schema$SqlServerDatabaseDeployment;
/**
* Optional. Details of the database deployment topology.
*/
topology?: Schema$DatabaseDeploymentTopology;
/**
* Optional. The database deployment version.
*/
version?: string | null;
}
/**
* Aggregated stats for the database deployment.
*/
export interface Schema$DatabaseDeploymentDetailsAggregatedStats {
/**
* Output only. The number of databases in the deployment.
*/
databaseCount?: number | null;
}
/**
* Details of database deployment's topology.
*/
export interface Schema$DatabaseDeploymentTopology {
/**
* Optional. Number of total logical cores.
*/
coreCount?: number | null;
/**
* Optional. Number of total logical cores limited by db deployment.
*/
coreLimit?: number | null;
/**
* Optional. Disk allocated in bytes.
*/
diskAllocatedBytes?: string | null;
/**
* Optional. Disk used in bytes.
*/
diskUsedBytes?: string | null;
/**
* Optional. List of database instances.
*/
instances?: Schema$DatabaseInstance[];
/**
* Optional. Total memory in bytes.
*/
memoryBytes?: string | null;
/**
* Optional. Total memory in bytes limited by db deployment.
*/
memoryLimitBytes?: string | null;
/**
* Optional. Number of total physical cores.
*/
physicalCoreCount?: number | null;
/**
* Optional. Number of total physical cores limited by db deployment.
*/
physicalCoreLimit?: number | null;
}
/**
* Details of a logical database.
*/
export interface Schema$DatabaseDetails {
/**
* Optional. The allocated storage for the database in bytes.
*/
allocatedStorageBytes?: string | null;
/**
* Required. The name of the database.
*/
databaseName?: string | null;
/**
* Required. The parent database deployment that contains the logical database.
*/
parentDatabaseDeployment?: Schema$DatabaseDetailsParentDatabaseDeployment;
/**
* Optional. The database schemas.
*/
schemas?: Schema$DatabaseSchema[];
}
/**
* The identifiers of the parent database deployment.
*/
export interface Schema$DatabaseDetailsParentDatabaseDeployment {
/**
* Optional. The parent database deployment generated ID.
*/
generatedId?: string | null;
/**
* Optional. The parent database deployment optional manual unique ID set by the user.
*/
manualUniqueId?: string | null;
}
/**
* Details of a database instance.
*/
export interface Schema$DatabaseInstance {
/**
* Optional. The instance's name.
*/
instanceName?: string | null;
/**
* Optional. Networking details.
*/
network?: Schema$DatabaseInstanceNetwork;
/**
* Optional. The instance role in the database engine.
*/
role?: string | null;
}
/**
* Network details of a database instance.
*/
export interface Schema$DatabaseInstanceNetwork {
/**
* Optional. The instance's host names.
*/
hostNames?: string[] | null;
/**
* Optional. The instance's IP addresses.
*/
ipAddresses?: string[] | null;
/**
* Optional. The instance's primary MAC address.
*/
primaryMacAddress?: string | null;
}
/**
* Details of a group of database objects.
*/
export interface Schema$DatabaseObjects {
/**
* Optional. The category of the objects.
*/
category?: string | null;
/**
* Optional. The number of objects.
*/
count?: string | null;
}
/**
* Details of a database schema.
*/
export interface Schema$DatabaseSchema {
/**
* Optional. Details of a Mysql schema.
*/
mysql?: Schema$MySqlSchemaDetails;
/**
* Optional. List of details of objects by category.
*/
objects?: Schema$DatabaseObjects[];
/**
* Optional. Details of a PostgreSql schema.
*/
postgresql?: Schema$PostgreSqlSchemaDetails;
/**
* Required. The name of the schema.
*/
schemaName?: string | null;
/**
* Optional. Details of a SqlServer schema.
*/
sqlServer?: Schema$SqlServerSchemaDetails;
/**
* Optional. The total size of tables in bytes.
*/
tablesSizeBytes?: string | null;
}
/**
* Represents a whole or partial calendar date, such as a birthday. The time of day and time zone are either specified elsewhere or are insignificant. The date is relative to the Gregorian Calendar. This can represent one of the following: * A full date, with non-zero year, month, and day values. * A month and day, with a zero year (for example, an anniversary). * A year on its own, with a zero month and a zero day. * A year and month, with a zero day (for example, a credit card expiration date). Related types: * google.type.TimeOfDay * google.type.DateTime * google.protobuf.Timestamp
*/
export interface Schema$Date {
/**
* Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
*/
day?: number | null;
/**
* Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
*/
month?: number | null;
/**
* Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.
*/
year?: number | null;
}
/**
* Represents an installed Migration Center Discovery Client instance.
*/
export interface Schema$DiscoveryClient {
/**
* Output only. Time when the discovery client was first created.
*/
createTime?: string | null;
/**
* Optional. Free text description. Maximum length is 1000 characters.
*/
description?: string | null;
/**
* Optional. Free text display name. Maximum length is 63 characters.
*/
displayName?: string | null;
/**
* Output only. Errors affecting client functionality.
*/
errors?: Schema$Status[];
/**
* Optional. Client expiration time in UTC. If specified, the backend will not accept new frames after this time.
*/
expireTime?: string | null;
/**
* Output only. Last heartbeat time. Healthy clients are expected to send heartbeats regularly (normally every few minutes).
*/
heartbeatTime?: string | null;
/**
* Optional. Labels as key value pairs.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Output only. Identifier. Full name of this discovery client.
*/
name?: string | null;
/**
* Required. Service account used by the discovery client for various operation.
*/
serviceAccount?: string | null;
/**
* Output only. This field is intended for internal use.
*/
signalsEndpoint?: string | null;
/**
* Required. Immutable. Full name of the source object associated with this discovery client.
*/
source?: string | null;
/**
* Output only. Current state of the discovery client.
*/
state?: string | null;
/**
* Optional. Input only. Client time-to-live. If specified, the backend will not accept new frames after this time. This field is input only. The derived expiration time is provided as output through the `expire_time` field.
*/
ttl?: string | null;
/**
* Output only. Time when the discovery client was last updated. This value is not updated by heartbeats, to view the last heartbeat time please refer to the `heartbeat_time` field.
*/
updateTime?: string | null;
/**
* Output only. Client version, as reported in recent heartbeat.
*/
version?: string | null;
}
/**
* Single disk entry.
*/
export interface Schema$DiskEntry {
/**
* Disk capacity.
*/
capacityBytes?: string | null;
/**
* Disk label.
*/
diskLabel?: string | null;
/**
* Disk label type (e.g. BIOS/GPT)
*/
diskLabelType?: string | null;
/**
* Disk free space.
*/
freeBytes?: string | null;
/**
* Disk hardware address (e.g. 0:1 for SCSI).
*/
hwAddress?: string | null;
/**
* Disks interface type.
*/
interfaceType?: string | null;
/**
* Partition layout.
*/
partitions?: Schema$DiskPartitionList;
/**
* VMware disk details.
*/
vmware?: Schema$VmwareDiskConfig;
}
/**
* VM disks.
*/
export interface Schema$DiskEntryList {
/**
* Disk entries.
*/
entries?: Schema$DiskEntry[];
}
/**
* Disk Partition details.
*/
export interface Schema$DiskPartition {
/**
* Partition capacity.
*/
capacityBytes?: string | null;
/**
* Partition file system.
*/
fileSystem?: string | null;
/**
* Partition free space.
*/
freeBytes?: string | null;
/**
* Mount point (Linux/Windows) or drive letter (Windows).
*/
mountPoint?: string | null;
/**
* Sub-partitions.
*/
subPartitions?: Schema$DiskPartitionList;
/**
* Partition type.
*/
type?: string | null;
/**
* Partition UUID.
*/
uuid?: string | null;
}
/**
* Disk partition details.
*/
export interface Schema$DiskPartitionDetails {
/**
* Output only. Total free space of all partitions.
*/
freeSpaceBytes?: string | null;
/**
* Optional. List of partitions.
*/
partitions?: Schema$DiskPartitionList;
/**
* Output only. Total capacity of all partitions.
*/
totalCapacityBytes?: string | null;
}
/**
* Disk partition list.
*/
export interface Schema$DiskPartitionList {
/**
* Partition entries.
*/
entries?: Schema$DiskPartition[];
}
/**
* Disk usage sample. Values are across all disks.
*/
export interface Schema$DiskUsageSample {
/**
* Optional. Average IOPS sampled over a short window. Must be non-negative. If read or write are set, the sum of read and write will override the value of the average_iops.
*/
averageIops?: number | null;
/**
* Optional. Average read IOPS sampled over a short window. Must be non-negative. If both read and write are zero they are ignored.
*/
averageReadIops?: number | null;
/**
* Optional. Average write IOPS sampled over a short window. Must be non-negative. If both read and write are zero they are ignored.
*/
averageWriteIops?: number | null;
}
/**
* 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 {
}
/**
* Message representing a frame which failed to be processed due to an error.
*/
export interface Schema$ErrorFrame {
/**
* Output only. Frame ingestion time.
*/
ingestionTime?: string | null;
/**
* Output only. The identifier of the ErrorFrame.
*/
name?: string | null;
/**
* Output only. The frame that was originally reported.
*/
originalFrame?: Schema$AssetFrame;
/**
* Output only. All the violations that were detected for the frame.
*/
violations?: Schema$FrameViolationEntry[];
}
/**
* A resource that reports result of the import job execution.
*/
export interface Schema$ExecutionReport {
/**
* Validation errors encountered during the execution of the import job.
*/
executionErrors?: Schema$ValidationReport;
/**
* Total number of asset frames reported for the import job.
*/
framesReported?: number | null;
/**
* Output only. Total number of rows in the import job.
*/
totalRowsCount?: number | null;
}
/**
* A resource that aggregates the validation errors found in an import job file.
*/
export interface Schema$FileValidationReport {
/**
* List of file level errors.
*/
fileErrors?: Schema$ImportError[];
/**
* The name of the file.
*/
fileName?: string | null;
/**
* Flag indicating that processing was aborted due to maximum number of errors.
*/
partialReport?: boolean | null;
/**
* Partial list of rows that encountered validation error.
*/
rowErrors?: Schema$ImportRowError[];
}
/**
* Describes the fit level of an asset for migration to a specific target.
*/
export interface Schema$FitDescriptor {
/**
* Output only. Fit level.
*/
fitLevel?: string | null;
}
/**
* Collection of frame data.
*/
export interface Schema$Frames {
/**
* A repeated field of asset data.
*/
framesData?: Schema$AssetFrame[];
}
/**
* A resource that contains a single violation of a reported `AssetFrame` resource.
*/
export interface Schema$FrameViolationEntry {
/**
* The field of the original frame where the violation occurred.
*/
field?: string | null;
/**
* A message describing the violation.
*/
violation?: string | null;
}
/**
* Single fstab entry.
*/
export interface Schema$FstabEntry {
/**
* The mount point for the filesystem.
*/
file?: string | null;
/**
* Used by dump to determine which filesystems need to be dumped.
*/
freq?: number | null;
/**
* Mount options associated with the filesystem.
*/
mntops?: string | null;
/**
* Used by the fsck(8) program to determine the order in which filesystem checks are done at reboot time.
*/
passno?: number | null;
/**
* The block special device or remote filesystem to be mounted.
*/
spec?: string | null;
/**
* The type of the filesystem.
*/
vfstype?: string | null;
}
/**
* Fstab content.
*/
export interface Schema$FstabEntryList {
/**
* Fstab entries.
*/
entries?: Schema$FstabEntry[];
}
/**
* A generic insight about an asset.
*/
export interface Schema$GenericInsight {
/**
* Output only. Additional information about the insight, each entry can be a logical entry and must make sense if it is displayed with line breaks between each entry. Text can contain md style links.
*/
additionalInformation?: string[] | null;
/**
* Output only. In case message_code is not yet known by the client default_message will be the message to be used instead.
*/
defaultMessage?: string | null;
/**
* Output only. Represents a globally unique message id for this insight, can be used for localization purposes, in case message_code is not yet known by the client use default_message instead.
*/
messageId?: string | null;
}
/**
* Generic platform details.
*/
export interface Schema$GenericPlatformDetails {
/**
* Whether the machine is hyperthreaded.
*/
hyperthreading?: string | null;
/**
* Free text representation of the machine location. The format of this field should not be relied on. Different VMs in the same location may have different string values for this field.
*/
location?: string | null;
}
/**
* A resource that represents an asset group. The purpose of an asset group is to bundle a set of assets that have something in common, while allowing users to add annotations to the group. An asset can belong to multiple groups.
*/
export interface Schema$Group {
/**
* Output only. The timestamp when the group was created.
*/
createTime?: string | null;
/**
* Optional. The description of the group.
*/
description?: string | null;
/**
* Optional. User-friendly display name.
*/
displayName?: string | null;
/**
* Labels as key value pairs.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Output only. The name of the group.
*/
name?: string | null;
/**
* Output only. The timestamp when the group was last updated.
*/
updateTime?: string | null;
}
/**
* Guest OS config information.
*/
export interface Schema$GuestConfigDetails {
/**
* Mount list (Linux fstab).
*/
fstab?: Schema$FstabEntryList;
/**
* Hosts file (/etc/hosts).
*/
hosts?: Schema$HostsEntryList;
/**
* OS issue (typically /etc/issue in Linux).
*/
issue?: string | null;
/**
* NFS exports.
*/
nfsExports?: Schema$NfsExportList;
/**
* Security-Enhanced Linux (SELinux) mode.
*/
selinuxMode?: string | null;
}
/**
* Guest installed application information.
*/
export interface Schema$GuestInstalledApplication {
/**
* Installed application name.
*/
applicationName?: string | null;
/**
* The time when the application was installed.
*/
installTime?: string | null;
/**
* License strings associated with the installed application.
*/
licenses?: string[] | null;
/**
* Source path.
*/
path?: string | null;
/**
* Installed application vendor.
*/
vendor?: string | null;
/**
* Installed application version.
*/
version?: string | null;
}
/**
* Guest installed application list.
*/
export interface Schema$GuestInstalledApplicationList {
/**
* Application entries.
*/
entries?: Schema$GuestInstalledApplication[];
}
/**
* Information from Guest-level collections.
*/
export interface Schema$GuestOsDetails {
/**
* OS and app configuration.
*/
config?: Schema$GuestConfigDetails;
/**
* What family the OS belong to, if known.
*/
family?: string | null;
/**
* The name of the operating system.
*/
osName?: string | null;
/**
* Runtime information.
*/
runtime?: Schema$GuestRuntimeDetails;
/**
* The version of the operating system.
*/
version?: string | null;
}
/**
* Guest OS runtime information.
*/
export interface Schema$GuestRuntimeDetails {
/**
* Domain, e.g. c.stratozone-development.internal.
*/
domain?: string | null;
/**
* Installed applications information.
*/
installedApps?: Schema$GuestInstalledApplicationList;
/**
* Last time the OS was booted.
*/
lastBootTime?: string | null;
/**
* Machine name.
*/
machineName?: string | null;
/**
* Runtime network information (connections, ports).
*/
network?: Schema$RuntimeNetworkInfo;
/**
* Open files information.
*/
openFileList?: Schema$OpenFileList;
/**
* Running processes.
*/
processes?: Schema$RunningProcessList;
/**
* Running background services.
*/
services?: Schema$RunningServiceList;
}
/**
* Single /etc/hosts entry.
*/
export interface Schema$HostsEntry {
/**
* List of host names / aliases.
*/
hostNames?: string[] | null;
/**
* IP (raw, IPv4/6 agnostic).
*/
ip?: string | null;
}
/**
* Hosts content.
*/
export interface Schema$HostsEntryList {
/**
* Hosts entries.
*/
entries?: Schema$HostsEntry[];
}
/**
* A resource that repr