googleapis
Version:
Google APIs Client Library for Node.js
1,340 lines (1,339 loc) • 393 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 netapp_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;
}
/**
* NetApp API
*
* Google Cloud NetApp Volumes is a fully-managed, cloud-based data storage service that provides advanced data management capabilities and highly scalable performance with global availability.
*
* @example
* ```js
* const {google} = require('googleapis');
* const netapp = google.netapp('v1');
* ```
*/
export class Netapp {
context: APIRequestContext;
projects: Resource$Projects;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* ActiveDirectory is the public representation of the active directory config.
*/
export interface Schema$ActiveDirectory {
/**
* Optional. Users to be added to the Built-in Admininstrators group.
*/
administrators?: string[] | null;
/**
* If enabled, AES encryption will be enabled for SMB communication.
*/
aesEncryption?: boolean | null;
/**
* Optional. Users to be added to the Built-in Backup Operator active directory group.
*/
backupOperators?: string[] | null;
/**
* Output only. Create time of the active directory.
*/
createTime?: string | null;
/**
* Description of the active directory.
*/
description?: string | null;
/**
* Required. Comma separated list of DNS server IP addresses for the Active Directory domain.
*/
dns?: string | null;
/**
* Required. Name of the Active Directory domain
*/
domain?: string | null;
/**
* If enabled, traffic between the SMB server to Domain Controller (DC) will be encrypted.
*/
encryptDcConnections?: boolean | null;
/**
* Name of the active directory machine. This optional parameter is used only while creating kerberos volume
*/
kdcHostname?: string | null;
/**
* KDC server IP address for the active directory machine.
*/
kdcIp?: string | null;
/**
* Labels for the active directory.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Specifies whether or not the LDAP traffic needs to be signed.
*/
ldapSigning?: boolean | null;
/**
* Identifier. The resource name of the active directory. Format: `projects/{project_number\}/locations/{location_id\}/activeDirectories/{active_directory_id\}`.
*/
name?: string | null;
/**
* Required. NetBIOSPrefix is used as a prefix for SMB server name.
*/
netBiosPrefix?: string | null;
/**
* If enabled, will allow access to local users and LDAP users. If access is needed for only LDAP users, it has to be disabled.
*/
nfsUsersWithLdap?: boolean | null;
/**
* The Organizational Unit (OU) within the Windows Active Directory the user belongs to.
*/
organizationalUnit?: string | null;
/**
* Required. Password of the Active Directory domain administrator.
*/
password?: string | null;
/**
* Optional. Domain users to be given the SeSecurityPrivilege.
*/
securityOperators?: string[] | null;
/**
* The Active Directory site the service will limit Domain Controller discovery too.
*/
site?: string | null;
/**
* Output only. The state of the AD.
*/
state?: string | null;
/**
* Output only. The state details of the Active Directory.
*/
stateDetails?: string | null;
/**
* Required. Username of the Active Directory domain administrator.
*/
username?: string | null;
}
/**
* A NetApp Backup.
*/
export interface Schema$Backup {
/**
* Output only. Region in which backup is stored. Format: `projects/{project_id\}/locations/{location\}`
*/
backupRegion?: string | null;
/**
* Output only. Type of backup, manually created or created by a backup policy.
*/
backupType?: string | null;
/**
* Output only. Total size of all backups in a chain in bytes = baseline backup size + sum(incremental backup size)
*/
chainStorageBytes?: string | null;
/**
* Output only. The time when the backup was created.
*/
createTime?: string | null;
/**
* A description of the backup with 2048 characters or less. Requests with longer descriptions will be rejected.
*/
description?: string | null;
/**
* Output only. The time until which the backup is not deletable.
*/
enforcedRetentionEndTime?: string | null;
/**
* Resource labels to represent user provided metadata.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Identifier. The resource name of the backup. Format: `projects/{project_id\}/locations/{location\}/backupVaults/{backup_vault_id\}/backups/{backup_id\}`.
*/
name?: string | null;
/**
* Output only. Reserved for future use
*/
satisfiesPzi?: boolean | null;
/**
* Output only. Reserved for future use
*/
satisfiesPzs?: boolean | null;
/**
* If specified, backup will be created from the given snapshot. If not specified, there will be a new snapshot taken to initiate the backup creation. Format: `projects/{project_id\}/locations/{location\}/volumes/{volume_id\}/snapshots/{snapshot_id\}`
*/
sourceSnapshot?: string | null;
/**
* Volume full name of this backup belongs to. Format: `projects/{projects_id\}/locations/{location\}/volumes/{volume_id\}`
*/
sourceVolume?: string | null;
/**
* Output only. The backup state.
*/
state?: string | null;
/**
* Output only. Region of the volume from which the backup was created. Format: `projects/{project_id\}/locations/{location\}`
*/
volumeRegion?: string | null;
/**
* Output only. Size of the file system when the backup was created. When creating a new volume from the backup, the volume capacity will have to be at least as big.
*/
volumeUsageBytes?: string | null;
}
/**
* BackupConfig contains backup related config on a volume.
*/
export interface Schema$BackupConfig {
/**
* Output only. Total size of all backups in a chain in bytes = baseline backup size + sum(incremental backup size).
*/
backupChainBytes?: string | null;
/**
* Optional. When specified, schedule backups will be created based on the policy configuration.
*/
backupPolicies?: string[] | null;
/**
* Optional. Name of backup vault. Format: projects/{project_id\}/locations/{location\}/backupVaults/{backup_vault_id\}
*/
backupVault?: string | null;
/**
* Optional. When set to true, scheduled backup is enabled on the volume. This field should be nil when there's no backup policy attached.
*/
scheduledBackupEnabled?: boolean | null;
}
/**
* Backup Policy.
*/
export interface Schema$BackupPolicy {
/**
* Output only. The total number of volumes assigned by this backup policy.
*/
assignedVolumeCount?: number | null;
/**
* Output only. The time when the backup policy was created.
*/
createTime?: string | null;
/**
* Number of daily backups to keep. Note that the minimum daily backup limit is 2.
*/
dailyBackupLimit?: number | null;
/**
* Description of the backup policy.
*/
description?: string | null;
/**
* If enabled, make backups automatically according to the schedules. This will be applied to all volumes that have this policy attached and enforced on volume level. If not specified, default is true.
*/
enabled?: boolean | null;
/**
* Resource labels to represent user provided metadata.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Number of monthly backups to keep. Note that the sum of daily, weekly and monthly backups should be greater than 1.
*/
monthlyBackupLimit?: number | null;
/**
* Identifier. The resource name of the backup policy. Format: `projects/{project_id\}/locations/{location\}/backupPolicies/{backup_policy_id\}`.
*/
name?: string | null;
/**
* Output only. The backup policy state.
*/
state?: string | null;
/**
* Number of weekly backups to keep. Note that the sum of daily, weekly and monthly backups should be greater than 1.
*/
weeklyBackupLimit?: number | null;
}
/**
* Retention policy for backups in the backup vault
*/
export interface Schema$BackupRetentionPolicy {
/**
* Required. Minimum retention duration in days for backups in the backup vault.
*/
backupMinimumEnforcedRetentionDays?: number | null;
/**
* Optional. Indicates if the daily backups are immutable. At least one of daily_backup_immutable, weekly_backup_immutable, monthly_backup_immutable and manual_backup_immutable must be true.
*/
dailyBackupImmutable?: boolean | null;
/**
* Optional. Indicates if the manual backups are immutable. At least one of daily_backup_immutable, weekly_backup_immutable, monthly_backup_immutable and manual_backup_immutable must be true.
*/
manualBackupImmutable?: boolean | null;
/**
* Optional. Indicates if the monthly backups are immutable. At least one of daily_backup_immutable, weekly_backup_immutable, monthly_backup_immutable and manual_backup_immutable must be true.
*/
monthlyBackupImmutable?: boolean | null;
/**
* Optional. Indicates if the weekly backups are immutable. At least one of daily_backup_immutable, weekly_backup_immutable, monthly_backup_immutable and manual_backup_immutable must be true.
*/
weeklyBackupImmutable?: boolean | null;
}
/**
* A NetApp BackupVault.
*/
export interface Schema$BackupVault {
/**
* Optional. Region where the backups are stored. Format: `projects/{project_id\}/locations/{location\}`
*/
backupRegion?: string | null;
/**
* Optional. Backup retention policy defining the retention of backups.
*/
backupRetentionPolicy?: Schema$BackupRetentionPolicy;
/**
* Output only. The crypto key version used to encrypt the backup vault. Format: `projects/{project\}/locations/{location\}/keyRings/{key_ring\}/cryptoKeys/{crypto_key\}/cryptoKeyVersions/{crypto_key_version\}`
*/
backupsCryptoKeyVersion?: string | null;
/**
* Optional. Type of backup vault to be created. Default is IN_REGION.
*/
backupVaultType?: string | null;
/**
* Output only. Create time of the backup vault.
*/
createTime?: string | null;
/**
* Description of the backup vault.
*/
description?: string | null;
/**
* Output only. Name of the Backup vault created in backup region. Format: `projects/{project_id\}/locations/{location\}/backupVaults/{backup_vault_id\}`
*/
destinationBackupVault?: string | null;
/**
* Output only. Field indicating encryption state of CMEK backups.
*/
encryptionState?: string | null;
/**
* Optional. Specifies the Key Management System (KMS) configuration to be used for backup encryption. Format: `projects/{project\}/locations/{location\}/kmsConfigs/{kms_config\}`
*/
kmsConfig?: string | null;
/**
* Resource labels to represent user provided metadata.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Identifier. The resource name of the backup vault. Format: `projects/{project_id\}/locations/{location\}/backupVaults/{backup_vault_id\}`.
*/
name?: string | null;
/**
* Output only. Name of the Backup vault created in source region. Format: `projects/{project_id\}/locations/{location\}/backupVaults/{backup_vault_id\}`
*/
sourceBackupVault?: string | null;
/**
* Output only. Region in which the backup vault is created. Format: `projects/{project_id\}/locations/{location\}`
*/
sourceRegion?: string | null;
/**
* Output only. The backup vault state.
*/
state?: string | null;
}
/**
* Block device represents the device(s) which are stored in the block volume.
*/
export interface Schema$BlockDevice {
/**
* Optional. A list of host groups that identify hosts that can mount the block volume. Format: `projects/{project_id\}/locations/{location\}/hostGroups/{host_group_id\}` This field can be updated after the block device is created.
*/
hostGroups?: string[] | null;
/**
* Output only. Device identifier of the block volume. This represents `lun_serial_number` for iSCSI volumes.
*/
identifier?: string | null;
/**
* Optional. User-defined name for the block device, unique within the volume. In case no user input is provided, name will be auto-generated in the backend. The name must meet the following requirements: * Be between 1 and 255 characters long. * Contain only uppercase or lowercase letters (A-Z, a-z), numbers (0-9), and the following special characters: "-", "_", "\}", "{", ".". * Spaces are not allowed.
*/
name?: string | null;
/**
* Required. Immutable. The OS type of the volume. This field can't be changed after the block device is created.
*/
osType?: string | null;
/**
* Optional. The size of the block device in GiB. Any value provided for the `size_gib` field during volume creation is ignored. The block device's size is system-managed and will be set to match the parent Volume's `capacity_gib`.
*/
sizeGib?: string | null;
}
/**
* Configuration of the cache volume.
*/
export interface Schema$CacheConfig {
/**
* Optional. Pre-populate cache volume with data from the origin volume.
*/
cachePrePopulate?: Schema$CachePrePopulate;
/**
* Output only. State of the prepopulation job indicating how the prepopulation is progressing.
*/
cachePrePopulateState?: string | null;
/**
* Optional. Flag indicating whether a CIFS change notification is enabled for the FlexCache volume.
*/
cifsChangeNotifyEnabled?: boolean | null;
/**
* Optional. Flag indicating whether writeback is enabled for the FlexCache volume.
*/
writebackEnabled?: boolean | null;
}
/**
* Cache Parameters for the volume.
*/
export interface Schema$CacheParameters {
/**
* Optional. Configuration of the cache volume.
*/
cacheConfig?: Schema$CacheConfig;
/**
* Output only. State of the cache volume indicating the peering status.
*/
cacheState?: string | null;
/**
* Output only. Copy-paste-able commands to be used on user's ONTAP to accept peering requests.
*/
command?: string | null;
/**
* Optional. Indicates whether the cache volume has global file lock enabled.
*/
enableGlobalFileLock?: boolean | null;
/**
* Output only. Temporary passphrase generated to accept cluster peering command.
*/
passphrase?: string | null;
/**
* Required. Name of the origin volume's ONTAP cluster.
*/
peerClusterName?: string | null;
/**
* Optional. Expiration time for the peering command to be executed on user's ONTAP.
*/
peeringCommandExpiryTime?: string | null;
/**
* Required. List of IC LIF addresses of the origin volume's ONTAP cluster.
*/
peerIpAddresses?: string[] | null;
/**
* Required. Name of the origin volume's SVM.
*/
peerSvmName?: string | null;
/**
* Required. Name of the origin volume for the cache volume.
*/
peerVolumeName?: string | null;
/**
* Output only. Detailed description of the current cache state.
*/
stateDetails?: string | null;
}
/**
* Pre-populate cache volume with data from the origin volume.
*/
export interface Schema$CachePrePopulate {
/**
* Optional. List of directory-paths to be excluded for pre-population for the FlexCache volume.
*/
excludePathList?: string[] | null;
/**
* Optional. List of directory-paths to be pre-populated for the FlexCache volume.
*/
pathList?: string[] | null;
/**
* Optional. Flag indicating whether the directories listed with the `path_list` need to be recursively pre-populated.
*/
recursion?: boolean | null;
}
/**
* The request message for Operations.CancelOperation.
*/
export interface Schema$CancelOperationRequest {
}
/**
* Make a snapshot every day e.g. at 04:00, 05:20, 23:50
*/
export interface Schema$DailySchedule {
/**
* Set the hour to start the snapshot (0-23), defaults to midnight (0).
*/
hour?: number | null;
/**
* Set the minute of the hour to start the snapshot (0-59), defaults to the top of the hour (0).
*/
minute?: number | null;
/**
* The maximum number of Snapshots to keep for the hourly schedule
*/
snapshotsToKeep?: number | null;
}
/**
* DestinationVolumeParameters specify input parameters used for creating destination volume.
*/
export interface Schema$DestinationVolumeParameters {
/**
* Description for the destination volume.
*/
description?: string | null;
/**
* Destination volume's share name. If not specified, source volume's share name will be used.
*/
shareName?: string | null;
/**
* Required. Existing destination StoragePool name.
*/
storagePool?: string | null;
/**
* Optional. Tiering policy for the volume.
*/
tieringPolicy?: Schema$TieringPolicy;
/**
* Desired destination volume resource id. If not specified, source volume's resource id will be used. This value must start with a lowercase letter followed by up to 62 lowercase letters, numbers, or hyphens, and cannot end with a hyphen.
*/
volumeId?: string | null;
}
/**
* EncryptVolumesRequest specifies the KMS config to encrypt existing volumes.
*/
export interface Schema$EncryptVolumesRequest {
}
/**
* EstablishPeeringRequest establishes cluster and svm peerings between the source and the destination replications.
*/
export interface Schema$EstablishPeeringRequest {
/**
* Required. Name of the user's local source cluster to be peered with the destination cluster.
*/
peerClusterName?: string | null;
/**
* Optional. List of IPv4 ip addresses to be used for peering.
*/
peerIpAddresses?: string[] | null;
/**
* Required. Name of the user's local source vserver svm to be peered with the destination vserver svm.
*/
peerSvmName?: string | null;
/**
* Required. Name of the user's local source volume to be peered with the destination volume.
*/
peerVolumeName?: string | null;
}
/**
* EstablishVolumePeeringRequest establishes cluster and svm peerings between the source and destination clusters.
*/
export interface Schema$EstablishVolumePeeringRequest {
/**
* Required. Name of the user's local source cluster to be peered with the destination cluster.
*/
peerClusterName?: string | null;
/**
* Optional. List of IPv4 ip addresses to be used for peering.
*/
peerIpAddresses?: string[] | null;
/**
* Required. Name of the user's local source vserver svm to be peered with the destination vserver svm.
*/
peerSvmName?: string | null;
/**
* Required. Name of the user's local source volume to be peered with the destination volume.
*/
peerVolumeName?: string | null;
}
/**
* Defines the export policy for the volume.
*/
export interface Schema$ExportPolicy {
/**
* Required. List of export policy rules
*/
rules?: Schema$SimpleExportPolicyRule[];
}
/**
* 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$GoogleProtobufEmpty {
}
/**
* Host group is a collection of hosts that can be used for accessing a Block Volume.
*/
export interface Schema$HostGroup {
/**
* Output only. Create time of the host group.
*/
createTime?: string | null;
/**
* Optional. Description of the host group.
*/
description?: string | null;
/**
* Required. The list of hosts associated with the host group.
*/
hosts?: string[] | null;
/**
* Optional. Labels of the host group.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Identifier. The resource name of the host group. Format: `projects/{project_number\}/locations/{location_id\}/hostGroups/{host_group_id\}`.
*/
name?: string | null;
/**
* Required. The OS type of the host group. It indicates the type of operating system used by all of the hosts in the HostGroup. All hosts in a HostGroup must be of the same OS type. This can be set only when creating a HostGroup.
*/
osType?: string | null;
/**
* Output only. State of the host group.
*/
state?: string | null;
/**
* Required. Type of the host group.
*/
type?: string | null;
}
/**
* Make a snapshot every hour e.g. at 04:00, 05:00, 06:00.
*/
export interface Schema$HourlySchedule {
/**
* Set the minute of the hour to start the snapshot (0-59), defaults to the top of the hour (0).
*/
minute?: number | null;
/**
* The maximum number of Snapshots to keep for the hourly schedule
*/
snapshotsToKeep?: number | null;
}
/**
* HybridPeeringDetails contains details about the hybrid peering.
*/
export interface Schema$HybridPeeringDetails {
/**
* Output only. Copy-paste-able commands to be used on user's ONTAP to accept peering requests.
*/
command?: string | null;
/**
* Output only. Expiration time for the peering command to be executed on user's ONTAP.
*/
commandExpiryTime?: string | null;
/**
* Output only. Temporary passphrase generated to accept cluster peering command.
*/
passphrase?: string | null;
/**
* Output only. Name of the user's local source cluster to be peered with the destination cluster.
*/
peerClusterName?: string | null;
/**
* Output only. Name of the user's local source vserver svm to be peered with the destination vserver svm.
*/
peerSvmName?: string | null;
/**
* Output only. Name of the user's local source volume to be peered with the destination volume.
*/
peerVolumeName?: string | null;
/**
* Output only. IP address of the subnet.
*/
subnetIp?: string | null;
}
/**
* The Hybrid Replication parameters for the volume.
*/
export interface Schema$HybridReplicationParameters {
/**
* Optional. Name of source cluster location associated with the Hybrid replication. This is a free-form field for the display purpose only.
*/
clusterLocation?: string | null;
/**
* Optional. Description of the replication.
*/
description?: string | null;
/**
* Optional. Type of the hybrid replication.
*/
hybridReplicationType?: string | null;
/**
* Optional. Labels to be added to the replication as the key value pairs.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Optional. Constituent volume count for large volume.
*/
largeVolumeConstituentCount?: number | null;
/**
* Required. Name of the user's local source cluster to be peered with the destination cluster.
*/
peerClusterName?: string | null;
/**
* Required. List of node ip addresses to be peered with.
*/
peerIpAddresses?: string[] | null;
/**
* Required. Name of the user's local source vserver svm to be peered with the destination vserver svm.
*/
peerSvmName?: string | null;
/**
* Required. Name of the user's local source volume to be peered with the destination volume.
*/
peerVolumeName?: string | null;
/**
* Required. Desired name for the replication of this volume.
*/
replication?: string | null;
/**
* Optional. Replication Schedule for the replication created.
*/
replicationSchedule?: string | null;
}
/**
* KmsConfig is the customer-managed encryption key(CMEK) configuration.
*/
export interface Schema$KmsConfig {
/**
* Output only. Create time of the KmsConfig.
*/
createTime?: string | null;
/**
* Required. Customer-managed crypto key resource full name. Format: `projects/{project\}/locations/{location\}/keyRings/{key_ring\}/cryptoKeys/{crypto_key\}`
*/
cryptoKeyName?: string | null;
/**
* Description of the KmsConfig.
*/
description?: string | null;
/**
* Output only. Instructions to provide the access to the customer provided encryption key.
*/
instructions?: string | null;
/**
* Labels as key value pairs
*/
labels?: {
[key: string]: string;
} | null;
/**
* Identifier. Name of the KmsConfig. Format: `projects/{project\}/locations/{location\}/kmsConfigs/{kms_config\}`
*/
name?: string | null;
/**
* Output only. The Service account which will have access to the customer provided encryption key.
*/
serviceAccount?: string | null;
/**
* Output only. State of the KmsConfig.
*/
state?: string | null;
/**
* Output only. State details of the KmsConfig.
*/
stateDetails?: string | null;
}
/**
* ListActiveDirectoriesResponse contains all the active directories requested.
*/
export interface Schema$ListActiveDirectoriesResponse {
/**
* The list of active directories.
*/
activeDirectories?: Schema$ActiveDirectory[];
/**
* A token identifying a page of results the server should return.
*/
nextPageToken?: string | null;
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* ListBackupPoliciesResponse contains all the backup policies requested.
*/
export interface Schema$ListBackupPoliciesResponse {
/**
* The list of backup policies.
*/
backupPolicies?: Schema$BackupPolicy[];
/**
* A token identifying a page of results the server should return.
*/
nextPageToken?: string | null;
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* ListBackupsResponse is the result of ListBackupsRequest.
*/
export interface Schema$ListBackupsResponse {
/**
* A list of backups in the project.
*/
backups?: Schema$Backup[];
/**
* The token you can use to retrieve the next page of results. Not returned if there are no more results in the list.
*/
nextPageToken?: string | null;
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* ListBackupVaultsResponse is the result of ListBackupVaultsRequest.
*/
export interface Schema$ListBackupVaultsResponse {
/**
* A list of backupVaults in the project for the specified location.
*/
backupVaults?: Schema$BackupVault[];
/**
* The token you can use to retrieve the next page of results. Not returned if there are no more results in the list.
*/
nextPageToken?: string | null;
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* ListHostGroupsResponse is the response to a ListHostGroupsRequest.
*/
export interface Schema$ListHostGroupsResponse {
/**
* The list of host groups.
*/
hostGroups?: Schema$HostGroup[];
/**
* A token identifying a page of results the server should return.
*/
nextPageToken?: string | null;
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* ListKmsConfigsResponse is the response to a ListKmsConfigsRequest.
*/
export interface Schema$ListKmsConfigsResponse {
/**
* The list of KmsConfigs
*/
kmsConfigs?: Schema$KmsConfig[];
/**
* A token identifying a page of results the server should return.
*/
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[];
/**
* Unordered list. Unreachable resources. Populated when the request sets `ListOperationsRequest.return_partial_success` and reads across collections. For example, when attempting to list all resources across all supported locations.
*/
unreachable?: string[] | null;
}
/**
* ListQuotaRulesResponse is the response to a ListQuotaRulesRequest.
*/
export interface Schema$ListQuotaRulesResponse {
/**
* A token identifying a page of results the server should return.
*/
nextPageToken?: string | null;
/**
* List of quota rules
*/
quotaRules?: Schema$QuotaRule[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* ListReplicationsResponse is the result of ListReplicationsRequest.
*/
export interface Schema$ListReplicationsResponse {
/**
* The token you can use to retrieve the next page of results. Not returned if there are no more results in the list.
*/
nextPageToken?: string | null;
/**
* A list of replications in the project for the specified volume.
*/
replications?: Schema$Replication[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* ListSnapshotsResponse is the result of ListSnapshotsRequest.
*/
export interface Schema$ListSnapshotsResponse {
/**
* The token you can use to retrieve the next page of results. Not returned if there are no more results in the list.
*/
nextPageToken?: string | null;
/**
* A list of snapshots in the project for the specified volume.
*/
snapshots?: Schema$Snapshot[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* ListStoragePoolsResponse is the response to a ListStoragePoolsRequest.
*/
export interface Schema$ListStoragePoolsResponse {
/**
* A token identifying a page of results the server should return.
*/
nextPageToken?: string | null;
/**
* The list of StoragePools
*/
storagePools?: Schema$StoragePool[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* Message for response to listing Volumes
*/
export interface Schema$ListVolumesResponse {
/**
* A token identifying a page of results the server should return.
*/
nextPageToken?: string | null;
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
/**
* The list of Volume
*/
volumes?: Schema$Volume[];
}
/**
* 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;
}
/**
* Metadata for a given google.cloud.location.Location.
*/
export interface Schema$LocationMetadata {
/**
* Output only. Indicates if the location has ONTAP Proxy support.
*/
hasOntapProxy?: boolean | null;
/**
* Output only. Indicates if the location has VCP support.
*/
hasVcp?: boolean | null;
/**
* Output only. Supported flex performance in a location.
*/
supportedFlexPerformance?: string[] | null;
/**
* Output only. Supported service levels in a location.
*/
supportedServiceLevels?: string[] | null;
}
/**
* Make a snapshot once a month e.g. at 2nd 04:00, 7th 05:20, 24th 23:50
*/
export interface Schema$MonthlySchedule {
/**
* Set the day or days of the month to make a snapshot (1-31). Accepts a comma separated number of days. Defaults to '1'.
*/
daysOfMonth?: string | null;
/**
* Set the hour to start the snapshot (0-23), defaults to midnight (0).
*/
hour?: number | null;
/**
* Set the minute of the hour to start the snapshot (0-59), defaults to the top of the hour (0).
*/
minute?: number | null;
/**
* The maximum number of Snapshots to keep for the hourly schedule
*/
snapshotsToKeep?: number | null;
}
/**
* View only mount options for a volume.
*/
export interface Schema$MountOption {
/**
* Export string
*/
export?: string | null;
/**
* Full export string
*/
exportFull?: string | null;
/**
* Instructions for mounting
*/
instructions?: string | null;
/**
* Output only. IP Address.
*/
ipAddress?: string | null;
/**
* Protocol to mount with.
*/
protocol?: string | null;
}
/**
* 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 been canceled successfully 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;
}
/**
* QuotaRule specifies the maximum disk space a user or group can use within a volume. They can be used for creating default and individual quota rules.
*/
export interface Schema$QuotaRule {
/**
* Output only. Create time of the quota rule
*/
createTime?: string | null;
/**
* Optional. Description of the quota rule
*/
description?: string | null;
/**
* Required. The maximum allowed disk space in MiB.
*/
diskLimitMib?: number | null;
/**
* Optional. Labels of the quota rule
*/
labels?: {
[key: string]: string;
} | null;
/**
* Identifier. The resource name of the quota rule. Format: `projects/{project_number\}/locations/{location_id\}/volumes/volumes/{volume_id\}/quotaRules/{quota_rule_id\}`.
*/
name?: string | null;
/**
* Output only. State of the quota rule
*/
state?: string | null;
/**
* Output only. State details of the quota rule
*/
stateDetails?: string | null;
/**
* Optional. The quota rule applies to the specified user or group, identified by a Unix UID/GID, Windows SID, or null for default.
*/
target?: string | null;
/**
* Required. The type of quota rule.
*/
type?: string | null;
}
/**
* Replication is a nested resource under Volume, that describes a cross-region replication relationship between 2 volumes in different regions.
*/
export interface Schema$Replication {
/**
* Optional. Location of the user cluster.
*/
clusterLocation?: string | null;
/**
* Output only. Replication create time.
*/
createTime?: string | null;
/**
* A description about this replication relationship.
*/
description?: string | null;
/**
* Output only. Full name of destination volume resource. Example : "projects/{project\}/locations/{location\}/volumes/{volume_id\}"
*/
destinationVolume?: string | null;
/**
* Required. Input only. Destination volume parameters
*/
destinationVolumeParameters?: Schema$DestinationVolumeParameters;
/**
* Output only. Condition of the relationship. Can be one of the following: - true: The replication relationship is healthy. It has not missed the most recent scheduled transfer. - false: The replication relationship is not healthy. It has missed the most recent scheduled transfer.
*/
healthy?: boolean | null;
/**
* Output only. Hybrid peering details.
*/
hybridPeeringDetails?: Schema$HybridPeeringDetails;
/**
* Output only. Type of the hybrid replication.
*/
hybridReplicationType?: string | null;
/**
* Output only. Copy pastable snapmirror commands to be executed on onprem cluster by the customer.
*/
hybridReplicationUserCommands?: Schema$UserCommands;
/**
* Resource labels to represent user provided metadata.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Output only. Indicates the state of mirroring.
*/
mirrorState?: string | null;
/**
* Identifier. The resource name of the Replication. Format: `projects/{project_id\}/locations/{location\}/volumes/{volume_id\}/replications/{replication_id\}`.
*/
name?: string | null;
/**
* Required. Indicates the schedule for replication.
*/
replicationSchedule?: string | null;
/**
* Output only. Indicates whether this points to source or destination.
*/
role?: string | null;
/**
* Output only. Full name of source volume resource. Example : "projects/{project\}/locations/{location\}/volumes/{volume_id\}"
*/
sourceVolume?: string | null;
/**
* Output only. State of the replication.
*/
state?: string | null;
/**
* Output only. State details of the replication.
*/
stateDetails?: string | null;
/**
* Output only. Replication transfer statistics.
*/
transferStats?: Schema$TransferStats;
}
/**
* RestoreBackupFilesRequest restores files from a backup to a volume.
*/
export interface Schema$RestoreBackupFilesRequest {
/**
* Required. The backup resource name, in the format `projects/{project_id\}/locations/{location\}/backupVaults/{backup_vault_id\}/backups/{backup_id\}`
*/
backup?: string | null;
/**
* Required. List of files to be restored, specified by their absolute path in the source volume.
*/
fileList?: string[] | null;
/**
* Optional. Absolute directory path in the destination volume. This is required if the `file_list` is provided.
*/
restoreDestinationPath?: string | null;
}
/**
* The RestoreParameters if volume is created from a snapshot or backup.
*/
export interface Schema$RestoreParameters {
/**
* Full name of the backup resource. Format: projects/{project\}/locations/{location\}/backupVaults/{backup_vault_id\}/backups/{backup_id\}
*/
sourceBackup?: string | null;
/**
* Full name of the snapshot resource. Format: projects/{project\}/locations/{location\}/volumes/{volume\}/snapshots/{snapshot\}
*/
sourceSnapshot?: string | null;
}
/**
* ResumeReplicationRequest resumes a stopped replication.
*/
export interface Schema$ResumeReplicationRequest {
}
/**
* ReverseReplicationDirectionRequest reverses direction of replication. Source becomes destination and destination becomes source.
*/
export interface Schema$ReverseReplicationDirectionRequest {
}
/**
* RevertVolumeRequest reverts the given volume to the specified snapshot.
*/
export interface Schema$RevertVolumeRequest {
/**
* Required. The snapshot resource ID, in the format 'my-snapshot', where the specified ID is the {snapshot_id\} of the fully qualified name like projects/{project_id\}/locations/{location_id\}/volumes/{volume_id\}/snapshots/{snapshot_id\}
*/
snapshotId?: string | null;
}
/**
* An export policy rule describing various export options.
*/
export interface Schema$SimpleExportPolicyRule {