googleapis

import { OAuth2Client, JWT, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common'; import { Readable } from 'stream'; export declare namespace compute_beta { export interface Options extends GlobalOptions { version: 'beta'; } 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; /** * Legacy name for parameter that has been superseded by `quotaUser`. */ userIp?: string; } /** * Compute Engine API * * Creates and runs virtual machines on Google Cloud Platform. * * @example * ```js * const {google} = require('googleapis'); * const compute = google.compute('beta'); * ``` */ export class Compute { context: APIRequestContext; acceleratorTypes: Resource$Acceleratortypes; addresses: Resource$Addresses; advice: Resource$Advice; autoscalers: Resource$Autoscalers; backendBuckets: Resource$Backendbuckets; backendServices: Resource$Backendservices; crossSiteNetworks: Resource$Crosssitenetworks; disks: Resource$Disks; diskSettings: Resource$Disksettings; diskTypes: Resource$Disktypes; externalVpnGateways: Resource$Externalvpngateways; firewallPolicies: Resource$Firewallpolicies; firewalls: Resource$Firewalls; forwardingRules: Resource$Forwardingrules; futureReservations: Resource$Futurereservations; globalAddresses: Resource$Globaladdresses; globalForwardingRules: Resource$Globalforwardingrules; globalNetworkEndpointGroups: Resource$Globalnetworkendpointgroups; globalOperations: Resource$Globaloperations; globalOrganizationOperations: Resource$Globalorganizationoperations; globalPublicDelegatedPrefixes: Resource$Globalpublicdelegatedprefixes; healthChecks: Resource$Healthchecks; httpHealthChecks: Resource$Httphealthchecks; httpsHealthChecks: Resource$Httpshealthchecks; imageFamilyViews: Resource$Imagefamilyviews; images: Resource$Images; instanceGroupManagerResizeRequests: Resource$Instancegroupmanagerresizerequests; instanceGroupManagers: Resource$Instancegroupmanagers; instanceGroups: Resource$Instancegroups; instances: Resource$Instances; instanceSettings: Resource$Instancesettings; instanceTemplates: Resource$Instancetemplates; instantSnapshots: Resource$Instantsnapshots; interconnectAttachmentGroups: Resource$Interconnectattachmentgroups; interconnectAttachments: Resource$Interconnectattachments; interconnectGroups: Resource$Interconnectgroups; interconnectLocations: Resource$Interconnectlocations; interconnectRemoteLocations: Resource$Interconnectremotelocations; interconnects: Resource$Interconnects; licenseCodes: Resource$Licensecodes; licenses: Resource$Licenses; machineImages: Resource$Machineimages; machineTypes: Resource$Machinetypes; networkAttachments: Resource$Networkattachments; networkEdgeSecurityServices: Resource$Networkedgesecurityservices; networkEndpointGroups: Resource$Networkendpointgroups; networkFirewallPolicies: Resource$Networkfirewallpolicies; networkProfiles: Resource$Networkprofiles; networks: Resource$Networks; nodeGroups: Resource$Nodegroups; nodeTemplates: Resource$Nodetemplates; nodeTypes: Resource$Nodetypes; organizationSecurityPolicies: Resource$Organizationsecuritypolicies; packetMirrorings: Resource$Packetmirrorings; previewFeatures: Resource$Previewfeatures; projects: Resource$Projects; publicAdvertisedPrefixes: Resource$Publicadvertisedprefixes; publicDelegatedPrefixes: Resource$Publicdelegatedprefixes; regionAutoscalers: Resource$Regionautoscalers; regionBackendServices: Resource$Regionbackendservices; regionCommitments: Resource$Regioncommitments; regionDisks: Resource$Regiondisks; regionDiskSettings: Resource$Regiondisksettings; regionDiskTypes: Resource$Regiondisktypes; regionHealthChecks: Resource$Regionhealthchecks; regionHealthCheckServices: Resource$Regionhealthcheckservices; regionInstanceGroupManagerResizeRequests: Resource$Regioninstancegroupmanagerresizerequests; regionInstanceGroupManagers: Resource$Regioninstancegroupmanagers; regionInstanceGroups: Resource$Regioninstancegroups; regionInstances: Resource$Regioninstances; regionInstanceTemplates: Resource$Regioninstancetemplates; regionInstantSnapshots: Resource$Regioninstantsnapshots; regionMultiMigs: Resource$Regionmultimigs; regionNetworkEndpointGroups: Resource$Regionnetworkendpointgroups; regionNetworkFirewallPolicies: Resource$Regionnetworkfirewallpolicies; regionNotificationEndpoints: Resource$Regionnotificationendpoints; regionOperations: Resource$Regionoperations; regions: Resource$Regions; regionSecurityPolicies: Resource$Regionsecuritypolicies; regionSnapshots: Resource$Regionsnapshots; regionSnapshotSettings: Resource$Regionsnapshotsettings; regionSslCertificates: Resource$Regionsslcertificates; regionSslPolicies: Resource$Regionsslpolicies; regionTargetHttpProxies: Resource$Regiontargethttpproxies; regionTargetHttpsProxies: Resource$Regiontargethttpsproxies; regionTargetTcpProxies: Resource$Regiontargettcpproxies; regionUrlMaps: Resource$Regionurlmaps; regionZones: Resource$Regionzones; reservationBlocks: Resource$Reservationblocks; reservations: Resource$Reservations; reservationSubBlocks: Resource$Reservationsubblocks; resourcePolicies: Resource$Resourcepolicies; routers: Resource$Routers; routes: Resource$Routes; securityPolicies: Resource$Securitypolicies; serviceAttachments: Resource$Serviceattachments; snapshots: Resource$Snapshots; snapshotSettings: Resource$Snapshotsettings; sslCertificates: Resource$Sslcertificates; sslPolicies: Resource$Sslpolicies; storagePools: Resource$Storagepools; storagePoolTypes: Resource$Storagepooltypes; subnetworks: Resource$Subnetworks; targetGrpcProxies: Resource$Targetgrpcproxies; targetHttpProxies: Resource$Targethttpproxies; targetHttpsProxies: Resource$Targethttpsproxies; targetInstances: Resource$Targetinstances; targetPools: Resource$Targetpools; targetSslProxies: Resource$Targetsslproxies; targetTcpProxies: Resource$Targettcpproxies; targetVpnGateways: Resource$Targetvpngateways; urlMaps: Resource$Urlmaps; vpnGateways: Resource$Vpngateways; vpnTunnels: Resource$Vpntunnels; wireGroups: Resource$Wiregroups; zoneOperations: Resource$Zoneoperations; zones: Resource$Zones; constructor(options: GlobalOptions, google?: GoogleConfigurable); } /** * A specification of the type and number of accelerator cards attached to the instance. */ export interface Schema$AcceleratorConfig { /** * The number of the guest accelerator cards exposed to this instance. */ acceleratorCount?: number | null; /** * Full or partial URL of the accelerator type resource to attach to this instance. For example: projects/my-project/zones/us-central1-c/acceleratorTypes/nvidia-tesla-p100 If you are creating an instance template, specify only the accelerator name. See GPUs on Compute Engine for a full list of accelerator types. */ acceleratorType?: string | null; } /** * Represents an Accelerator Type resource. Google Cloud Platform provides graphics processing units (accelerators) that you can add to VM instances to improve or accelerate performance when working with intensive workloads. For more information, read GPUs on Compute Engine. */ export interface Schema$AcceleratorType { /** * [Output Only] Creation timestamp in RFC3339 text format. */ creationTimestamp?: string | null; /** * [Output Only] The deprecation status associated with this accelerator type. */ deprecated?: Schema$DeprecationStatus; /** * [Output Only] An optional textual description of the resource. */ description?: string | null; /** * [Output Only] The unique identifier for the resource. This identifier is defined by the server. */ id?: string | null; /** * [Output Only] The type of the resource. Always compute#acceleratorType for accelerator types. */ kind?: string | null; /** * [Output Only] Maximum number of accelerator cards allowed per instance. */ maximumCardsPerInstance?: number | null; /** * [Output Only] Name of the resource. */ name?: string | null; /** * [Output Only] Server-defined, fully qualified URL for this resource. */ selfLink?: string | null; /** * [Output Only] The name of the zone where the accelerator type resides, such as us-central1-a. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. */ zone?: string | null; } export interface Schema$AcceleratorTypeAggregatedList { /** * [Output Only] Unique identifier for the resource; defined by the server. */ id?: string | null; /** * A list of AcceleratorTypesScopedList resources. */ items?: { [key: string]: Schema$AcceleratorTypesScopedList; } | null; /** * [Output Only] Type of resource. Always compute#acceleratorTypeAggregatedList for aggregated lists of accelerator types. */ kind?: string | null; /** * [Output Only] This token allows you to get the next page of results for list requests. If the number of results is larger than maxResults, use the nextPageToken as a value for the query parameter pageToken in the next list request. Subsequent list requests will have their own nextPageToken to continue paging through the results. */ nextPageToken?: string | null; /** * [Output Only] Server-defined URL for this resource. */ selfLink?: string | null; /** * [Output Only] Unreachable resources. */ unreachables?: string[] | null; /** * [Output Only] Informational warning message. */ warning?: { code?: string; data?: Array<{ key?: string; value?: string; }>; message?: string; } | null; } /** * Contains a list of accelerator types. */ export interface Schema$AcceleratorTypeList { /** * [Output Only] Unique identifier for the resource; defined by the server. */ id?: string | null; /** * A list of AcceleratorType resources. */ items?: Schema$AcceleratorType[]; /** * [Output Only] Type of resource. Always compute#acceleratorTypeList for lists of accelerator types. */ kind?: string | null; /** * [Output Only] This token allows you to get the next page of results for list requests. If the number of results is larger than maxResults, use the nextPageToken as a value for the query parameter pageToken in the next list request. Subsequent list requests will have their own nextPageToken to continue paging through the results. */ nextPageToken?: string | null; /** * [Output Only] Server-defined URL for this resource. */ selfLink?: string | null; /** * [Output Only] Informational warning message. */ warning?: { code?: string; data?: Array<{ key?: string; value?: string; }>; message?: string; } | null; } export interface Schema$AcceleratorTypesScopedList { /** * [Output Only] A list of accelerator types contained in this scope. */ acceleratorTypes?: Schema$AcceleratorType[]; /** * [Output Only] An informational warning that appears when the accelerator types list is empty. */ warning?: { code?: string; data?: Array<{ key?: string; value?: string; }>; message?: string; } | null; } /** * An access configuration attached to an instance's network interface. Only one access config per instance is supported. */ export interface Schema$AccessConfig { /** * Applies to ipv6AccessConfigs only. The first IPv6 address of the external IPv6 range associated with this instance, prefix length is stored in externalIpv6PrefixLength in ipv6AccessConfig. To use a static external IP address, it must be unused and in the same region as the instance's zone. If not specified, Google Cloud will automatically assign an external IPv6 address from the instance's subnetwork. */ externalIpv6?: string | null; /** * Applies to ipv6AccessConfigs only. The prefix length of the external IPv6 range. */ externalIpv6PrefixLength?: number | null; /** * [Output Only] Type of the resource. Always compute#accessConfig for access configs. */ kind?: string | null; /** * The name of this access configuration. In accessConfigs (IPv4), the default and recommended name is External NAT, but you can use any arbitrary string, such as My external IP or Network Access. In ipv6AccessConfigs, the recommend name is External IPv6. */ name?: string | null; /** * Applies to accessConfigs (IPv4) only. An external IP address associated with this instance. Specify an unused static external IP address available to the project or leave this field undefined to use an IP from a shared ephemeral IP address pool. If you specify a static external IP address, it must live in the same region as the zone of the instance. */ natIP?: string | null; /** * This signifies the networking tier used for configuring this access configuration and can only take the following values: PREMIUM, STANDARD. If an AccessConfig is specified without a valid external IP address, an ephemeral IP will be created with this networkTier. If an AccessConfig with a valid external IP address is specified, it must match that of the networkTier associated with the Address resource owning that IP. */ networkTier?: string | null; /** * The DNS domain name for the public PTR record. You can set this field only if the `setPublicPtr` field is enabled in accessConfig. If this field is unspecified in ipv6AccessConfig, a default PTR record will be created for first IP in associated external IPv6 range. */ publicPtrDomainName?: string | null; /** * The resource URL for the security policy associated with this access config. */ securityPolicy?: string | null; /** * Specifies whether a public DNS 'PTR' record should be created to map the external IP address of the instance to a DNS domain name. This field is not used in ipv6AccessConfig. A default PTR record will be created if the VM has external IPv6 range associated. */ setPublicPtr?: boolean | null; /** * The type of configuration. In accessConfigs (IPv4), the default and only option is ONE_TO_ONE_NAT. In ipv6AccessConfigs, the default and only option is DIRECT_IPV6. */ type?: string | null; } /** * Represents an IP Address resource. Google Compute Engine has two IP Address resources: * [Global (external and internal)](https://cloud.google.com/compute/docs/reference/rest/beta/globalAddresses) * [Regional (external and internal)](https://cloud.google.com/compute/docs/reference/rest/beta/addresses) For more information, see Reserving a static external IP address. */ export interface Schema$Address { /** * The static IP address represented by this resource. */ address?: string | null; /** * The type of address to reserve, either INTERNAL or EXTERNAL. If unspecified, defaults to EXTERNAL. */ addressType?: string | null; /** * [Output Only] Creation timestamp in RFC3339 text format. */ creationTimestamp?: string | null; /** * An optional description of this resource. Provide this field when you create the resource. */ description?: string | null; /** * [Output Only] The unique identifier for the resource. This identifier is defined by the server. */ id?: string | null; /** * The endpoint type of this address, which should be VM or NETLB. This is used for deciding which type of endpoint this address can be used after the external IPv6 address reservation. */ ipv6EndpointType?: string | null; /** * The IP version that will be used by this address. Valid options are IPV4 or IPV6. */ ipVersion?: string | null; /** * [Output Only] Type of the resource. Always compute#address for addresses. */ kind?: string | null; /** * A fingerprint for the labels being applied to this Address, which is essentially a hash of the labels set used for optimistic locking. The fingerprint is initially generated by Compute Engine and changes after every request to modify or update labels. You must always provide an up-to-date fingerprint hash in order to update or change labels, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve an Address. */ labelFingerprint?: string | null; /** * Labels for this resource. These can only be added or modified by the setLabels method. Each label key/value pair must comply with RFC1035. Label values may be empty. */ labels?: { [key: string]: string; } | null; /** * Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?`. The first character must be a lowercase letter, and all following characters (except for the last character) must be a dash, lowercase letter, or digit. The last character must be a lowercase letter or digit. */ name?: string | null; /** * The URL of the network in which to reserve the address. This field can only be used with INTERNAL type with the VPC_PEERING purpose. */ network?: string | null; /** * This signifies the networking tier used for configuring this address and can only take the following values: PREMIUM or STANDARD. Internal IP addresses are always Premium Tier; global external IP addresses are always Premium Tier; regional external IP addresses can be either Standard or Premium Tier. If this field is not specified, it is assumed to be PREMIUM. */ networkTier?: string | null; /** * The prefix length if the resource represents an IP range. */ prefixLength?: number | null; /** * The purpose of this resource, which can be one of the following values: - GCE_ENDPOINT for addresses that are used by VM instances, alias IP ranges, load balancers, and similar resources. - DNS_RESOLVER for a DNS resolver address in a subnetwork for a Cloud DNS inbound forwarder IP addresses (regional internal IP address in a subnet of a VPC network) - VPC_PEERING for global internal IP addresses used for private services access allocated ranges. - NAT_AUTO for the regional external IP addresses used by Cloud NAT when allocating addresses using automatic NAT IP address allocation. - IPSEC_INTERCONNECT for addresses created from a private IP range that are reserved for a VLAN attachment in an *HA VPN over Cloud Interconnect* configuration. These addresses are regional resources. - `SHARED_LOADBALANCER_VIP` for an internal IP address that is assigned to multiple internal forwarding rules. - `PRIVATE_SERVICE_CONNECT` for a private network address that is used to configure Private Service Connect. Only global internal addresses can use this purpose. */ purpose?: string | null; /** * [Output Only] The URL of the region where a regional address resides. For regional addresses, you must specify the region as a path parameter in the HTTP request URL. *This field is not applicable to global addresses.* */ region?: string | null; /** * [Output Only] Server-defined URL for the resource. */ selfLink?: string | null; /** * [Output Only] The status of the address, which can be one of RESERVING, RESERVED, or IN_USE. An address that is RESERVING is currently in the process of being reserved. A RESERVED address is currently reserved and available to use. An IN_USE address is currently being used by another resource and is not available. */ status?: string | null; /** * The URL of the subnetwork in which to reserve the address. If an IP address is specified, it must be within the subnetwork's IP range. This field can only be used with INTERNAL type with a GCE_ENDPOINT or DNS_RESOLVER purpose. */ subnetwork?: string | null; /** * [Output Only] The URLs of the resources that are using this address. */ users?: string[] | null; } export interface Schema$AddressAggregatedList { /** * [Output Only] Unique identifier for the resource; defined by the server. */ id?: string | null; /** * A list of AddressesScopedList resources. */ items?: { [key: string]: Schema$AddressesScopedList; } | null; /** * [Output Only] Type of resource. Always compute#addressAggregatedList for aggregated lists of addresses. */ kind?: string | null; /** * [Output Only] This token allows you to get the next page of results for list requests. If the number of results is larger than maxResults, use the nextPageToken as a value for the query parameter pageToken in the next list request. Subsequent list requests will have their own nextPageToken to continue paging through the results. */ nextPageToken?: string | null; /** * [Output Only] Server-defined URL for this resource. */ selfLink?: string | null; /** * [Output Only] Unreachable resources. */ unreachables?: string[] | null; /** * [Output Only] Informational warning message. */ warning?: { code?: string; data?: Array<{ key?: string; value?: string; }>; message?: string; } | null; } export interface Schema$AddressesScopedList { /** * [Output Only] A list of addresses contained in this scope. */ addresses?: Schema$Address[]; /** * [Output Only] Informational warning which replaces the list of addresses when the list is empty. */ warning?: { code?: string; data?: Array<{ key?: string; value?: string; }>; message?: string; } | null; } /** * Contains a list of addresses. */ export interface Schema$AddressList { /** * [Output Only] Unique identifier for the resource; defined by the server. */ id?: string | null; /** * A list of Address resources. */ items?: Schema$Address[]; /** * [Output Only] Type of resource. Always compute#addressList for lists of addresses. */ kind?: string | null; /** * [Output Only] This token allows you to get the next page of results for list requests. If the number of results is larger than maxResults, use the nextPageToken as a value for the query parameter pageToken in the next list request. Subsequent list requests will have their own nextPageToken to continue paging through the results. */ nextPageToken?: string | null; /** * [Output Only] Server-defined URL for this resource. */ selfLink?: string | null; /** * [Output Only] Informational warning message. */ warning?: { code?: string; data?: Array<{ key?: string; value?: string; }>; message?: string; } | null; } /** * Specifies options for controlling advanced machine features. Options that would traditionally be configured in a BIOS belong here. Features that require operating system support may have corresponding entries in the GuestOsFeatures of an Image (e.g., whether or not the OS in the Image supports nested virtualization being enabled or disabled). */ export interface Schema$AdvancedMachineFeatures { /** * Whether to enable nested virtualization or not (default is false). */ enableNestedVirtualization?: boolean | null; /** * Whether to enable UEFI networking for instance creation. */ enableUefiNetworking?: boolean | null; /** * Type of Performance Monitoring Unit requested on instance. */ performanceMonitoringUnit?: string | null; /** * The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed. */ threadsPerCore?: number | null; /** * Turbo frequency mode to use for the instance. Supported modes include: * ALL_CORE_MAX Using empty string or not setting this field will use the platform-specific default turbo mode. */ turboMode?: string | null; /** * The number of physical cores to expose to an instance. Multiply by the number of threads per core to compute the total number of virtual CPUs to expose to the instance. If unset, the number of cores is inferred from the instance's nominal CPU count and the underlying platform's SMT width. */ visibleCoreCount?: number | null; } /** * An alias IP range attached to an instance's network interface. */ export interface Schema$AliasIpRange { /** * The IP alias ranges to allocate for this interface. This IP CIDR range must belong to the specified subnetwork and cannot contain IP addresses reserved by system or used by other network interfaces. This range may be a single IP address (such as 10.2.3.4), a netmask (such as /24) or a CIDR-formatted string (such as 10.1.2.0/24). */ ipCidrRange?: string | null; /** * The name of a subnetwork secondary IP range from which to allocate an IP alias range. If not specified, the primary range of the subnetwork is used. */ subnetworkRangeName?: string | null; } /** * This reservation type is specified by total resource amounts (e.g. total count of CPUs) and can account for multiple instance SKUs. In other words, one can create instances of varying shapes against this reservation. */ export interface Schema$AllocationAggregateReservation { /** * [Output only] List of resources currently in use. */ inUseResources?: Schema$AllocationAggregateReservationReservedResourceInfo[]; /** * List of reserved resources (CPUs, memory, accelerators). */ reservedResources?: Schema$AllocationAggregateReservationReservedResourceInfo[]; /** * The VM family that all instances scheduled against this reservation must belong to. */ vmFamily?: string | null; /** * The workload type of the instances that will target this reservation. */ workloadType?: string | null; } export interface Schema$AllocationAggregateReservationReservedResourceInfo { /** * Properties of accelerator resources in this reservation. */ accelerator?: Schema$AllocationAggregateReservationReservedResourceInfoAccelerator; } export interface Schema$AllocationAggregateReservationReservedResourceInfoAccelerator { /** * Number of accelerators of specified type. */ acceleratorCount?: number | null; /** * Full or partial URL to accelerator type. e.g. "projects/{PROJECT\}/zones/{ZONE\}/acceleratorTypes/ct4l" */ acceleratorType?: string | null; } export interface Schema$AllocationReservationSharingPolicy { /** * Sharing config for all Google Cloud services. */ serviceShareType?: string | null; } /** * [Output Only] Contains output only fields. */ export interface Schema$AllocationResourceStatus { /** * [Output only] Health information for the reservation. */ healthInfo?: Schema$AllocationResourceStatusHealthInfo; /** * The number of reservation blocks associated with this reservation. */ reservationBlockCount?: number | null; /** * Maintenance information for this reservation */ reservationMaintenance?: Schema$GroupMaintenanceInfo; /** * Allocation Properties of this reservation. */ specificSkuAllocation?: Schema$AllocationResourceStatusSpecificSKUAllocation; } /** * Health information for the reservation. */ export interface Schema$AllocationResourceStatusHealthInfo { /** * The number of reservation blocks that are degraded. */ degradedBlockCount?: number | null; /** * The health status of the reservation. */ healthStatus?: string | null; /** * The number of reservation blocks that are healthy. */ healthyBlockCount?: number | null; } /** * Contains Properties set for the reservation. */ export interface Schema$AllocationResourceStatusSpecificSKUAllocation { /** * ID of the instance template used to populate reservation properties. */ sourceInstanceTemplateId?: string | null; /** * Per service utilization breakdown. The Key is the Google Cloud managed service name. */ utilizations?: { [key: string]: string; } | null; } export interface Schema$AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk { /** * Specifies the size of the disk in base-2 GB. */ diskSizeGb?: string | null; /** * Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME. The default is SCSI. For performance characteristics of SCSI over NVMe, see Local SSD performance. */ interface?: string | null; } /** * Properties of the SKU instances being reserved. Next ID: 9 */ export interface Schema$AllocationSpecificSKUAllocationReservedInstanceProperties { /** * Specifies accelerator type and count. */ guestAccelerators?: Schema$AcceleratorConfig[]; /** * Specifies amount of local ssd to reserve with each instance. The type of disk is local-ssd. */ localSsds?: Schema$AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk[]; /** * An opaque location hint used to place the allocation close to other resources. This field is for use by internal tools that use the public API. */ locationHint?: string | null; /** * Specifies type of machine (name only) which has fixed number of vCPUs and fixed amount of memory. This also includes specifying custom machine type following custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY pattern. */ machineType?: string | null; /** * Specifies the number of hours after reservation creation where instances using the reservation won't be scheduled for maintenance. */ maintenanceFreezeDurationHours?: number | null; /** * Specifies the frequency of planned maintenance events. The accepted values are: `PERIODIC`. */ maintenanceInterval?: string | null; /** * Minimum cpu platform the reservation. */ minCpuPlatform?: string | null; } /** * This reservation type allows to pre allocate specific instance configuration. */ export interface Schema$AllocationSpecificSKUReservation { /** * [Output Only] Indicates how many instances are actually usable currently. */ assuredCount?: string | null; /** * Specifies the number of resources that are allocated. */ count?: string | null; /** * The instance properties for the reservation. */ instanceProperties?: Schema$AllocationSpecificSKUAllocationReservedInstanceProperties; /** * [Output Only] Indicates how many instances are in use. */ inUseCount?: string | null; /** * Specifies the instance template to create the reservation. If you use this field, you must exclude the instanceProperties field. This field is optional, and it can be a full or partial URL. For example, the following are all valid URLs to an instance template: - https://www.googleapis.com/compute/v1/projects/project /global/instanceTemplates/instanceTemplate - projects/project/global/instanceTemplates/instanceTemplate - global/instanceTemplates/instanceTemplate */ sourceInstanceTemplate?: string | null; } /** * An instance-attached disk resource. */ export interface Schema$AttachedDisk { /** * [Output Only] The architecture of the attached disk. Valid values are ARM64 or X86_64. */ architecture?: string | null; /** * Specifies whether the disk will be auto-deleted when the instance is deleted (but not when the disk is detached from the instance). */ autoDelete?: boolean | null; /** * Indicates that this is a boot disk. The virtual machine will use the first partition of the disk for its root filesystem. */ boot?: boolean | null; /** * Specifies a unique device name of your choice that is reflected into the /dev/disk/by-id/google-* tree of a Linux operating system running within the instance. This name can be used to reference the device for mounting, resizing, and so on, from within the instance. If not specified, the server chooses a default device name to apply to this disk, in the form persistent-disk-x, where x is a number assigned by Google Compute Engine. This field is only applicable for persistent disks. */ deviceName?: string | null; /** * Encrypts or decrypts a disk using a customer-supplied encryption key. If you are creating a new disk, this field encrypts the new disk using an encryption key that you provide. If you are attaching an existing disk that is already encrypted, this field decrypts the disk using the customer-supplied encryption key. If you encrypt a disk using a customer-supplied key, you must provide the same key again when you attempt to use this resource at a later time. For example, you must provide the key when you create a snapshot or an image from the disk or when you attach the disk to a virtual machine instance. If you do not provide an encryption key, then the disk will be encrypted using an automatically generated key and you do not need to provide a key to use the disk later. Note: Instance templates do not store customer-supplied encryption keys, so you cannot use your own keys to encrypt disks in a managed instance group. You cannot create VMs that have disks with customer-supplied keys using the bulk insert method. */ diskEncryptionKey?: Schema$CustomerEncryptionKey; /** * The size of the disk in GB. */ diskSizeGb?: string | null; /** * [Input Only] Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. */ forceAttach?: boolean | null; /** * A list of features to enable on the guest operating system. Applicable only for bootable images. Read Enabling guest operating system features to see a list of available options. */ guestOsFeatures?: Schema$GuestOsFeature[]; /** * [Output Only] A zero-based index to this disk, where 0 is reserved for the boot disk. If you have many disks attached to an instance, each disk would have a unique index number. */ index?: number | null; /** * [Input Only] Specifies the parameters for a new disk that will be created alongside the new instance. Use initialization parameters to create boot disks or local SSDs attached to the new instance. This property is mutually exclusive with the source property; you can only define one or the other, but not both. */ initializeParams?: Schema$AttachedDiskInitializeParams; /** * Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME. For most machine types, the default is SCSI. Local SSDs can use either NVME or SCSI. In certain configurations, persistent disks can use NVMe. For more information, see About persistent disks. */ interface?: string | null; /** * [Output Only] Type of the resource. Always compute#attachedDisk for attached disks. */ kind?: string | null; /** * [Output Only] Any valid publicly visible licenses. */ licenses?: string[] | null; /** * [Output Only] Whether to indicate the attached disk is locked. The locked disk is not allowed to be detached from the instance, or to be used as the source of the snapshot creation, and the image creation. The instance with at least one locked attached disk is not allow to be used as source of machine image creation, instant snapshot creation, and not allowed to be deleted with --keep-disk parameter set to true for locked disks. */ locked?: boolean | null; /** * The mode in which to attach this disk, either READ_WRITE or READ_ONLY. If not specified, the default is to attach the disk in READ_WRITE mode. */ mode?: string | null; /** * For LocalSSD disks on VM Instances in STOPPED or SUSPENDED state, this field is set to PRESERVED if the LocalSSD data has been saved to a persistent location by customer request. (see the discard_local_ssd option on Stop/Suspend). Read-only in the api. */ savedState?: string | null; /** * [Output Only] shielded vm initial state stored on disk */ shieldedInstanceInitialState?: Schema$InitialStateConfig; /** * Specifies a valid partial or full URL to an existing Persistent Disk resource. When creating a new instance boot disk, one of initializeParams.sourceImage or initializeParams.sourceSnapshot or disks.source is required. If desired, you can also attach existing non-root persistent disks using this property. This field is only applicable for persistent disks. Note that for InstanceTemplate, specify the disk name for zonal disk, and the URL for regional disk. */ source?: string | null; /** * Specifies the type of the disk, either SCRATCH or PERSISTENT. If not specified, the default is PERSISTENT. */ type?: string | null; /** * [Output Only] A list of user provided licenses. It represents a list of URLs to the license resource. Unlike regular licenses, user provided licenses can be modified after the disk is created. */ userLicenses?: string[] | null; } /** * [Input Only] Specifies the parameters for a new disk that will be created alongside the new instance. Use initialization parameters to create boot disks or local SSDs attached to the new instance. This field is persisted and returned for instanceTemplate and not returned in the context of instance. This property is mutually exclusive with the source property; you can only define one or the other, but not both. */ export interface Schema$AttachedDiskInitializeParams { /** * The architecture of the attached disk. Valid values are arm64 or x86_64. */ architecture?: string | null; /** * An optional description. Provide this property when creating the disk. */ description?: string | null; /** * Specifies the disk name. If not specified, the default is to use the name of the instance. If a disk with the same name already exists in the given region, the existing disk is attached to the new instance and the new disk is not created. */ diskName?: string | null; /** * Specifies the size of the disk in base-2 GB. The size must be at least 10 GB. If you specify a sourceImage, which is required for boot disks, the default size is the size of the sourceImage. If you do not specify a sourceImage, the default disk size is 500 GB. */ diskSizeGb?: string | null; /** * Specifies the disk type to use to create the instance. If not specified, the default is pd-standard, specified using the full URL. For example: https://www.googleapis.com/compute/v1/projects/project/zones/zone /diskTypes/pd-standard For a full list of acceptable values, see Persistent disk types. If you specify this field when creating a VM, you can provide either the full or partial URL. For example, the following values are valid: - https://www.googleapis.com/compute/v1/projects/project/zones/zone /diskTypes/diskType - projects/project/zones/zone/diskTypes/diskType - zones/zone/diskTypes/diskType If you specify this field when creating or updating an instance template or all-instances configuration, specify the type of the disk, not the URL. For example: pd-standard. */ diskType?: string | null; /** * Whether this disk is using confidential compute mode. */ enableConfidentialCompute?: boolean | null; /** * A list of features to enable on the guest operating system. Applicable only for bootable images. Read Enabling guest operating system features to see a list of available options. Guest OS features are applied by merging initializeParams.guestOsFeatures and disks.guestOsFeatures */ guestOsFeatures?: Schema$GuestOsFeature[]; /** * Labels to apply to this disk. These can be later modified by the disks.setLabels method. This field is only applicable for persistent disks. */ labels?: { [key: string]: string; } | null; /** * A list of publicly visible licenses. Reserved for Google's use. */ licenses?: string[] | null; /** * Indicates whether or not the disk can be read/write attached to more than one instance. */ multiWriter?: boolean | null; /** * Specifies which action to take on instance update with this disk. Default is to use the existing disk. */ onUpdateAction?: string | null; /** * Indicates how many IOPS to provision for the disk. This sets the number of I/O operations per second that the disk can handle. Values must be between 10,000 and 120,000. For more details, see the Extreme persistent disk documentation. */ provisionedIops?: string | null; /** * Indicates how much throughput to provision for the disk. This sets the number of throughput mb per second that the disk can handle. Values must greater than or equal to 1. */ provisionedThroughput?: string | null; /** * Required for each regional disk associated with the instance. Specify the URLs of the zones where the disk should be replicated to. You must provide exactly two replica zones, and one zone must be the same as the instance zone. */ replicaZones?: string[] | null; /** * Resource manager tags to be bound to the disk. Tag keys and values have the same definition as resource manager tags. Keys must be in the format `tagKeys/{tag_key_id\}`, and values are in the format `tagValues/456`. The field is ignored (both PUT & PATCH) when empty. */ resourceManagerTags?: { [key: string]: string; } | null; /** * Resource policies applied to this disk for automatic snapshot creations. Specified using the full or partial URL. For instance template, specify only the resource policy name. */ resourcePolicies?: string[] | null; /** * The source image to create this disk. When creating a new instance boot disk, one of initializeParams.sourceImage or initializeParams.sourceSnapshot or disks.source is required. To create a disk with one of the public operating system images, specify the image by its family name. For example, specify family/debian-9 to use the latest Debian 9 image: projects/debian-cloud/global/images/family/debian-9 Alternatively, use a specific version of a public operating system image: projects/debian-cloud/global/images/debian-9-stretch-vYYYYMMDD To create a disk with a custom image that you created, specify the image name in the following format: global/images/my-custom-image You can also specify a custom image by its image family, which returns the latest version of the image in that family. Replace the image name with family/family-name: global/images/family/my-image-family If the source image is deleted later, this field will not be set. */ sourceImage?: string | null; /** * The customer-supplied encryption key of the source image. Required if the source image is protected by a customer-supplied encryption key. InstanceTemplate and InstancePropertiesPatch do not store customer-supplied encryption keys, so you cannot create disks for instances in a managed instance group if the source images are encrypted with your own keys. */ sourceImageEncryptionKey?: Schema$CustomerEncryptionKey; /** * The source instant-snapshot to create this disk. When creating a new instance boot disk, one of initializeParams.sourceSnapshot or initializeParams.sourceInstantSnapshot initializeParams.sourceImage or disks.source is required. To create a disk with a snapshot that you created, specify the