googleapis/build/src/apis/compute/beta.d.ts

Google APIs Client Library for Node.js

/**
 * Copyright 2015 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import { AxiosPromise } from 'axios';
import { GoogleApis } from '../..';
import { BodyResponseCallback, GlobalOptions, MethodOptions } from '../../lib/api';
/**
 * Compute Engine API
 *
 * Creates and runs virtual machines on Google Cloud Platform.
 *
 * @example
 * const google = require('googleapis');
 * const compute = google.compute('beta');
 *
 * @namespace compute
 * @type {Function}
 * @version beta
 * @variation beta
 * @param {object=} options Options for Compute
 */
export declare class Compute {
    _options: GlobalOptions;
    google: GoogleApis;
    root: this;
    acceleratorTypes: Resource$Acceleratortypes;
    addresses: Resource$Addresses;
    autoscalers: Resource$Autoscalers;
    backendBuckets: Resource$Backendbuckets;
    backendServices: Resource$Backendservices;
    disks: Resource$Disks;
    diskTypes: Resource$Disktypes;
    firewalls: Resource$Firewalls;
    forwardingRules: Resource$Forwardingrules;
    globalAddresses: Resource$Globaladdresses;
    globalForwardingRules: Resource$Globalforwardingrules;
    globalOperations: Resource$Globaloperations;
    healthChecks: Resource$Healthchecks;
    httpHealthChecks: Resource$Httphealthchecks;
    httpsHealthChecks: Resource$Httpshealthchecks;
    images: Resource$Images;
    instanceGroupManagers: Resource$Instancegroupmanagers;
    instanceGroups: Resource$Instancegroups;
    instances: Resource$Instances;
    instanceTemplates: Resource$Instancetemplates;
    interconnectAttachments: Resource$Interconnectattachments;
    interconnectLocations: Resource$Interconnectlocations;
    interconnects: Resource$Interconnects;
    licenseCodes: Resource$Licensecodes;
    licenses: Resource$Licenses;
    machineTypes: Resource$Machinetypes;
    networks: Resource$Networks;
    projects: Resource$Projects;
    regionAutoscalers: Resource$Regionautoscalers;
    regionBackendServices: Resource$Regionbackendservices;
    regionCommitments: Resource$Regioncommitments;
    regionDisks: Resource$Regiondisks;
    regionDiskTypes: Resource$Regiondisktypes;
    regionInstanceGroupManagers: Resource$Regioninstancegroupmanagers;
    regionInstanceGroups: Resource$Regioninstancegroups;
    regionOperations: Resource$Regionoperations;
    regions: Resource$Regions;
    routers: Resource$Routers;
    routes: Resource$Routes;
    securityPolicies: Resource$Securitypolicies;
    snapshots: Resource$Snapshots;
    sslCertificates: Resource$Sslcertificates;
    sslPolicies: Resource$Sslpolicies;
    subnetworks: Resource$Subnetworks;
    targetHttpProxies: Resource$Targethttpproxies;
    targetHttpsProxies: Resource$Targethttpsproxies;
    targetInstances: Resource$Targetinstances;
    targetPools: Resource$Targetpools;
    targetSslProxies: Resource$Targetsslproxies;
    targetTcpProxies: Resource$Targettcpproxies;
    targetVpnGateways: Resource$Targetvpngateways;
    urlMaps: Resource$Urlmaps;
    vpnTunnels: Resource$Vpntunnels;
    zoneOperations: Resource$Zoneoperations;
    zones: Resource$Zones;
    constructor(options: GlobalOptions, google: GoogleApis);
    getRoot(): this;
}
/**
 * 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;
    /**
     * Full or partial URL of the accelerator type resource to attach to this
     * instance. If you are creating an instance template, specify only the
     * accelerator name.
     */
    acceleratorType: string;
}
/**
 * An Accelerator Type resource. (== resource_for beta.acceleratorTypes ==) (==
 * resource_for v1.acceleratorTypes ==)
 */
export interface Schema$AcceleratorType {
    /**
     * [Output Only] Creation timestamp in RFC3339 text format.
     */
    creationTimestamp: string;
    /**
     * [Output Only] The deprecation status associated with this accelerator type.
     */
    deprecated: Schema$DeprecationStatus;
    /**
     * [Output Only] An optional textual description of the resource.
     */
    description: string;
    /**
     * [Output Only] The unique identifier for the resource. This identifier is
     * defined by the server.
     */
    id: string;
    /**
     * [Output Only] The type of the resource. Always compute#acceleratorType for
     * accelerator types.
     */
    kind: string;
    /**
     * [Output Only] Maximum accelerator cards allowed per instance.
     */
    maximumCardsPerInstance: number;
    /**
     * [Output Only] Name of the resource.
     */
    name: string;
    /**
     * [Output Only] Server-defined fully-qualified URL for this resource.
     */
    selfLink: string;
    /**
     * [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;
}
export interface Schema$AcceleratorTypeAggregatedList {
    /**
     * [Output Only] Unique identifier for the resource; defined by the server.
     */
    id: string;
    /**
     * A list of AcceleratorTypesScopedList resources.
     */
    items: any;
    /**
     * [Output Only] Type of resource. Always
     * compute#acceleratorTypeAggregatedList for aggregated lists of accelerator
     * types.
     */
    kind: string;
    /**
     * [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;
    /**
     * [Output Only] Server-defined URL for this resource.
     */
    selfLink: string;
    /**
     * [Output Only] Informational warning message.
     */
    warning: any;
}
/**
 * Contains a list of accelerator types.
 */
export interface Schema$AcceleratorTypeList {
    /**
     * [Output Only] Unique identifier for the resource; defined by the server.
     */
    id: string;
    /**
     * A list of AcceleratorType resources.
     */
    items: Schema$AcceleratorType[];
    /**
     * [Output Only] Type of resource. Always compute#acceleratorTypeList for
     * lists of accelerator types.
     */
    kind: string;
    /**
     * [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;
    /**
     * [Output Only] Server-defined URL for this resource.
     */
    selfLink: string;
    /**
     * [Output Only] Informational warning message.
     */
    warning: any;
}
export interface Schema$AcceleratorTypesScopedList {
    /**
     * [Output Only] 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: any;
}
/**
 * An access configuration attached to an instance's network interface. Only
 * one access config per instance is supported.
 */
export interface Schema$AccessConfig {
    /**
     * [Output Only] Type of the resource. Always compute#accessConfig for access
     * configs.
     */
    kind: string;
    /**
     * The name of this access configuration. The default and recommended name is
     * External NAT but you can use any arbitrary string you would like. For
     * example, My external IP or Network Access.
     */
    name: string;
    /**
     * 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;
    /**
     * 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;
    /**
     * The DNS domain name for the public PTR record. This field can only be set
     * when the set_public_ptr field is enabled.
     */
    publicPtrDomainName: string;
    /**
     * Specifies whether a public DNS ?PTR? record should be created to map the
     * external IP address of the instance to a DNS domain name.
     */
    setPublicPtr: boolean;
    /**
     * The type of configuration. The default and only option is ONE_TO_ONE_NAT.
     */
    type: string;
}
/**
 * A reserved address resource. (== resource_for beta.addresses ==) (==
 * resource_for v1.addresses ==) (== resource_for beta.globalAddresses ==) (==
 * resource_for v1.globalAddresses ==)
 */
export interface Schema$Address {
    /**
     * The static IP address represented by this resource.
     */
    address: string;
    /**
     * The type of address to reserve, either INTERNAL or EXTERNAL. If
     * unspecified, defaults to EXTERNAL.
     */
    addressType: string;
    /**
     * [Output Only] Creation timestamp in RFC3339 text format.
     */
    creationTimestamp: string;
    /**
     * An optional description of this resource. Provide this property when you
     * create the resource.
     */
    description: string;
    /**
     * [Output Only] The unique identifier for the resource. This identifier is
     * defined by the server.
     */
    id: string;
    /**
     * The IP Version that will be used by this address. Valid options are IPV4 or
     * IPV6. This can only be specified for a global address.
     */
    ipVersion: string;
    /**
     * [Output Only] Type of the resource. Always compute#address for addresses.
     */
    kind: string;
    /**
     * 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.  To see
     * the latest fingerprint, make a get() request to retrieve an Address.
     */
    labelFingerprint: string;
    /**
     * Labels to apply to this Address resource. These can be later modified by
     * the setLabels method. Each label key/value must comply with RFC1035. Label
     * values may be empty.
     */
    labels: any;
    /**
     * 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])?` which means the first character
     * must be a lowercase letter, and all following characters must be a dash,
     * lowercase letter, or digit, except the last character, which cannot be a
     * dash.
     */
    name: string;
    /**
     * This signifies the networking tier used for configuring this Address and
     * can only take the following values: PREMIUM , STANDARD.  If this field is
     * not specified, it is assumed to be PREMIUM.
     */
    networkTier: string;
    /**
     * [Output Only] URL of the region where the regional address resides. This
     * field is not applicable to global addresses. You must specify this field as
     * part of the HTTP request URL. You cannot set this field in the request
     * body.
     */
    region: string;
    /**
     * [Output Only] Server-defined URL for the resource.
     */
    selfLink: string;
    /**
     * [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;
    /**
     * 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 GCE_ENDPOINT/DNS_RESOLVER
     * purposes.
     */
    subnetwork: string;
    /**
     * [Output Only] The URLs of the resources that are using this address.
     */
    users: string[];
}
export interface Schema$AddressAggregatedList {
    /**
     * [Output Only] Unique identifier for the resource; defined by the server.
     */
    id: string;
    /**
     * A list of AddressesScopedList resources.
     */
    items: any;
    /**
     * [Output Only] Type of resource. Always compute#addressAggregatedList for
     * aggregated lists of addresses.
     */
    kind: string;
    /**
     * [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;
    /**
     * [Output Only] Server-defined URL for this resource.
     */
    selfLink: string;
    /**
     * [Output Only] Informational warning message.
     */
    warning: any;
}
export interface Schema$AddressesScopedList {
    /**
     * [Output Only] 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: any;
}
/**
 * Contains a list of addresses.
 */
export interface Schema$AddressList {
    /**
     * [Output Only] Unique identifier for the resource; defined by the server.
     */
    id: string;
    /**
     * A list of Address resources.
     */
    items: Schema$Address[];
    /**
     * [Output Only] Type of resource. Always compute#addressList for lists of
     * addresses.
     */
    kind: string;
    /**
     * [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;
    /**
     * [Output Only] Server-defined URL for this resource.
     */
    selfLink: string;
    /**
     * [Output Only] Informational warning message.
     */
    warning: any;
}
/**
 * An alias IP range attached to an instance's network interface.
 */
export interface Schema$AliasIpRange {
    /**
     * The IP CIDR range represented by this alias IP range. 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 (e.g. 10.2.3.4), a netmask (e.g. /24) or a CIDR format
     * string (e.g. 10.1.2.0/24).
     */
    ipCidrRange: string;
    /**
     * Optional subnetwork secondary range name specifying the secondary range
     * from which to allocate the IP CIDR range for this alias IP range. If left
     * unspecified, the primary range of the subnetwork will be used.
     */
    subnetworkRangeName: string;
}
/**
 * An instance-attached disk resource.
 */
export interface Schema$AttachedDisk {
    /**
     * 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;
    /**
     * Indicates that this is a boot disk. The virtual machine will use the first
     * partition of the disk for its root filesystem.
     */
    boot: boolean;
    /**
     * 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-disks-x, where x is a number assigned by Google Compute Engine.
     * This field is only applicable for persistent disks.
     */
    deviceName: string;
    /**
     * 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.  Instance
     * templates do not store customer-supplied encryption keys, so you cannot use
     * your own keys to encrypt disks in a managed instance group.
     */
    diskEncryptionKey: Schema$CustomerEncryptionKey;
    /**
     * 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;
    /**
     * [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. The default is SCSI. Persistent disks must always use
     * SCSI and the request will fail if you attempt to attach a persistent disk
     * in any other format than SCSI. Local SSDs can use either NVME or SCSI. For
     * performance characteristics of SCSI over NVMe, see Local SSD performance.
     */
    interface: string;
    /**
     * [Output Only] Type of the resource. Always compute#attachedDisk for
     * attached disks.
     */
    kind: string;
    /**
     * [Output Only] Any valid publicly visible licenses.
     */
    licenses: string[];
    /**
     * 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;
    /**
     * Specifies a valid partial or full URL to an existing Persistent Disk
     * resource. When creating a new instance, one of initializeParams.sourceImage
     * or disks.source is required except for local SSD.  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, not the URL for the disk.
     */
    source: string;
    /**
     * Specifies the type of the disk, either SCRATCH or PERSISTENT. If not
     * specified, the default is PERSISTENT.
     */
    type: string;
}
/**
 * [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.
 */
export interface Schema$AttachedDiskInitializeParams {
    /**
     * Specifies the disk name. If not specified, the default is to use the name
     * of the instance.
     */
    diskName: string;
    /**
     * Specifies the size of the disk in base-2 GB.
     */
    diskSizeGb: string;
    /**
     * [Deprecated] Storage type of the disk.
     */
    diskStorageType: string;
    /**
     * 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
     * Other values include pd-ssd and local-ssd. If you define this field, you
     * can provide either the full or partial URL. For example, the following are
     * valid values:   -
     * https://www.googleapis.com/compute/v1/projects/project/zones/zone/diskTypes/diskType
     * - projects/project/zones/zone/diskTypes/diskType  -
     * zones/zone/diskTypes/diskType  Note that for InstanceTemplate, this is the
     * name of the disk type, not URL.
     */
    diskType: string;
    /**
     * 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: any;
    /**
     * The source image to create this disk. When creating a new instance, one of
     * initializeParams.sourceImage or disks.source is required except for local
     * SSD.  To create a disk with one of the public operating system images,
     * specify the image by its family name. For example, specify family/debian-8
     * to use the latest Debian 8 image:
     * projects/debian-cloud/global/images/family/debian-8   Alternatively, use a
     * specific version of a public operating system image:
     * projects/debian-cloud/global/images/debian-8-jessie-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;
    /**
     * The customer-supplied encryption key of the source image. Required if the
     * source image is protected by a customer-supplied encryption key.  Instance
     * templates 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;
}
/**
 * Specifies the audit configuration for a service. The configuration determines
 * which permission types are logged, and what identities, if any, are exempted
 * from logging. An AuditConfig must have one or more AuditLogConfigs.  If there
 * are AuditConfigs for both `allServices` and a specific service, the union of
 * the two AuditConfigs is used for that service: the log_types specified in
 * each AuditConfig are enabled, and the exempted_members in each AuditLogConfig
 * are exempted.  Example Policy with multiple AuditConfigs:  {
 * "audit_configs": [ { "service": "allServices"
 * "audit_log_configs": [ { "log_type":
 * "DATA_READ", "exempted_members": [
 * "user:foo@gmail.com" ] }, { "log_type":
 * "DATA_WRITE", }, { "log_type": "ADMIN_READ", }
 * ] }, { "service": "fooservice.googleapis.com"
 * "audit_log_configs": [ { "log_type":
 * "DATA_READ", }, { "log_type": "DATA_WRITE",
 * "exempted_members": [ "user:bar@gmail.com" ] } ] } ] }
 * For fooservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ
 * logging. It also exempts foo@gmail.com from DATA_READ logging, and
 * bar@gmail.com from DATA_WRITE logging.
 */
export interface Schema$AuditConfig {
    /**
     * The configuration for logging of each type of permission.
     */
    auditLogConfigs: Schema$AuditLogConfig[];
    exemptedMembers: string[];
    /**
     * Specifies a service that will be enabled for audit logging. For example,
     * `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a
     * special value that covers all services.
     */
    service: string;
}
/**
 * Provides the configuration for logging a type of permissions. Example:  {
 * "audit_log_configs": [ { "log_type":
 * "DATA_READ", "exempted_members": [
 * "user:foo@gmail.com" ] }, { "log_type":
 * "DATA_WRITE", } ] }  This enables 'DATA_READ' and
 * 'DATA_WRITE' logging, while exempting foo@gmail.com from DATA_READ
 * logging.
 */
export interface Schema$AuditLogConfig {
    /**
     * Specifies the identities that do not cause logging for this type of
     * permission. Follows the same format of [Binding.members][].
     */
    exemptedMembers: string[];
    /**
     * The log type that this config enables.
     */
    logType: string;
}
/**
 * Authorization-related information used by Cloud Audit Logging.
 */
export interface Schema$AuthorizationLoggingOptions {
    /**
     * The type of the permission that was checked.
     */
    permissionType: string;
}
/**
 * Represents an Autoscaler resource. Autoscalers allow you to automatically
 * scale virtual machine instances in managed instance groups according to an
 * autoscaling policy that you define. For more information, read Autoscaling
 * Groups of Instances. (== resource_for beta.autoscalers ==) (== resource_for
 * v1.autoscalers ==) (== resource_for beta.regionAutoscalers ==) (==
 * resource_for v1.regionAutoscalers ==)
 */
export interface Schema$Autoscaler {
    /**
     * The configuration parameters for the autoscaling algorithm. You can define
     * one or more of the policies for an autoscaler: cpuUtilization,
     * customMetricUtilizations, and loadBalancingUtilization.  If none of these
     * are specified, the default will be to autoscale based on cpuUtilization to
     * 0.6 or 60%.
     */
    autoscalingPolicy: Schema$AutoscalingPolicy;
    /**
     * [Output Only] Creation timestamp in RFC3339 text format.
     */
    creationTimestamp: string;
    /**
     * An optional description of this resource. Provide this property when you
     * create the resource.
     */
    description: string;
    /**
     * [Output Only] The unique identifier for the resource. This identifier is
     * defined by the server.
     */
    id: string;
    /**
     * [Output Only] Type of the resource. Always compute#autoscaler for
     * autoscalers.
     */
    kind: string;
    /**
     * 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])?` which means the first character
     * must be a lowercase letter, and all following characters must be a dash,
     * lowercase letter, or digit, except the last character, which cannot be a
     * dash.
     */
    name: string;
    /**
     * [Output Only] URL of the region where the instance group resides (for
     * autoscalers living in regional scope).
     */
    region: string;
    /**
     * [Output Only] Server-defined URL for the resource.
     */
    selfLink: string;
    /**
     * [Output Only] The status of the autoscaler configuration.
     */
    status: string;
    /**
     * [Output Only] Human-readable details about the current state of the
     * autoscaler. Read the documentation for Commonly returned status messages
     * for examples of status messages you might encounter.
     */
    statusDetails: Schema$AutoscalerStatusDetails[];
    /**
     * URL of the managed instance group that this autoscaler will scale.
     */
    target: string;
    /**
     * [Output Only] URL of the zone where the instance group resides (for
     * autoscalers living in zonal scope).
     */
    zone: string;
}
export interface Schema$AutoscalerAggregatedList {
    /**
     * [Output Only] Unique identifier for the resource; defined by the server.
     */
    id: string;
    /**
     * A list of AutoscalersScopedList resources.
     */
    items: any;
    /**
     * [Output Only] Type of resource. Always compute#autoscalerAggregatedList for
     * aggregated lists of autoscalers.
     */
    kind: string;
    /**
     * [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;
    /**
     * [Output Only] Server-defined URL for this resource.
     */
    selfLink: string;
    /**
     * [Output Only] Informational warning message.
     */
    warning: any;
}
/**
 * Contains a list of Autoscaler resources.
 */
export interface Schema$AutoscalerList {
    /**
     * [Output Only] Unique identifier for the resource; defined by the server.
     */
    id: string;
    /**
     * A list of Autoscaler resources.
     */
    items: Schema$Autoscaler[];
    /**
     * [Output Only] Type of resource. Always compute#autoscalerList for lists of
     * autoscalers.
     */
    kind: string;
    /**
     * [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;
    /**
     * [Output Only] Server-defined URL for this resource.
     */
    selfLink: string;
    /**
     * [Output Only] Informational warning message.
     */
    warning: any;
}
export interface Schema$AutoscalersScopedList {
    /**
     * [Output Only] List of autoscalers contained in this scope.
     */
    autoscalers: Schema$Autoscaler[];
    /**
     * [Output Only] Informational warning which replaces the list of autoscalers
     * when the list is empty.
     */
    warning: any;
}
export interface Schema$AutoscalerStatusDetails {
    /**
     * The status message.
     */
    message: string;
    /**
     * The type of error returned.
     */
    type: string;
}
/**
 * Cloud Autoscaler policy.
 */
export interface Schema$AutoscalingPolicy {
    /**
     * The number of seconds that the autoscaler should wait before it starts
     * collecting information from a new instance. This prevents the autoscaler
     * from collecting information when the instance is initializing, during which
     * the collected usage would not be reliable. The default time autoscaler
     * waits is 60 seconds.  Virtual machine initialization times might vary
     * because of numerous factors. We recommend that you test how long an
     * instance may take to initialize. To do this, create an instance and time
     * the startup process.
     */
    coolDownPeriodSec: number;
    /**
     * Defines the CPU utilization policy that allows the autoscaler to scale
     * based on the average CPU utilization of a managed instance group.
     */
    cpuUtilization: Schema$AutoscalingPolicyCpuUtilization;
    /**
     * Configuration parameters of autoscaling based on a custom metric.
     */
    customMetricUtilizations: Schema$AutoscalingPolicyCustomMetricUtilization[];
    /**
     * Configuration parameters of autoscaling based on load balancer.
     */
    loadBalancingUtilization: Schema$AutoscalingPolicyLoadBalancingUtilization;
    /**
     * The maximum number of instances that the autoscaler can scale up to. This
     * is required when creating or updating an autoscaler. The maximum number of
     * replicas should not be lower than minimal number of replicas.
     */
    maxNumReplicas: number;
    /**
     * The minimum number of replicas that the autoscaler can scale down to. This
     * cannot be less than 0. If not provided, autoscaler will choose a default
     * value depending on maximum number of instances allowed.
     */
    minNumReplicas: number;
}
/**
 * CPU utilization policy.
 */
export interface Schema$AutoscalingPolicyCpuUtilization {
    /**
     * The target CPU utilization that the autoscaler should maintain. Must be a
     * float value in the range (0, 1]. If not specified, the default is 0.6.  If
     * the CPU level is below the target utilization, the autoscaler scales down
     * the number of instances until it reaches the minimum number of instances
     * you specified or until the average CPU of your instances reaches the target
     * utilization.  If the average CPU is above the target utilization, the
     * autoscaler scales up until it reaches the maximum number of instances you
     * specified or until the average utilization reaches the target utilization.
     */
    utilizationTarget: number;
}
/**
 * Custom utilization metric policy.
 */
export interface Schema$AutoscalingPolicyCustomMetricUtilization {
    /**
     * A filter string, compatible with a Stackdriver Monitoring filter string for
     * TimeSeries.list API call. This filter is used to select a specific
     * TimeSeries for the purpose of autoscaling and to determine whether the
     * metric is exporting per-instance or per-group data.  For the filter to be
     * valid for autoscaling purposes, the following rules apply:   - You can only
     * use the AND operator for joining selectors.  - You can only use direct
     * equality comparison operator (=) without any functions for each selector.
     * - You can specify the metric in both the filter string and in the metric
     * field. However, if specified in both places, the metric must be identical.
     * - The monitored resource type determines what kind of values are expected
     * for the metric. If it is a gce_instance, the autoscaler expects the metric
     * to include a separate TimeSeries for each instance in a group. In such a
     * case, you cannot filter on resource labels. If the resource type is any
     * other value, the autoscaler expects this metric to contain values that
     * apply to the entire autoscaled instance group and resource label filtering
     * can be performed to point autoscaler at the correct TimeSeries to scale
     * upon. This is called a per-group metric for the purpose of autoscaling.  If
     * not specified, the type defaults to gce_instance.    You should provide a
     * filter that is selective enough to pick just one TimeSeries for the
     * autoscaled group or for each of the instances (if you are using
     * gce_instance resource type). If multiple TimeSeries are returned upon the
     * query execution, the autoscaler will sum their respective values to obtain
     * its scaling value.
     */
    filter: string;
    /**
     * The identifier (type) of the Stackdriver Monitoring metric. The metric
     * cannot have negative values.  The metric must have a value type of INT64 or
     * DOUBLE.
     */
    metric: string;
    /**
     * If scaling is based on a per-group metric value that represents the total
     * amount of work to be done or resource usage, set this value to an amount
     * assigned for a single instance of the scaled group. Autoscaler will keep
     * the number of instances proportional to the value of this metric, the
     * metric itself should not change value due to group resizing.  A good metric
     * to use with the target is for example
     * pubsub.googleapis.com/subscription/num_undelivered_messages or a custom
     * metric exporting the total number of requests coming to your instances.  A
     * bad example would be a metric exporting an average or median latency, since
     * this value can't include a chunk assignable to a single instance, it
     * could be better used with utilization_target instead.
     */
    singleInstanceAssignment: number;
    /**
     * The target value of the metric that autoscaler should maintain. This must
     * be a positive value. A utilization metric scales number of virtual machines
     * handling requests to increase or decrease proportionally to the metric. For
     * example, a good metric to use as a utilization_target is
     * compute.googleapis.com/instance/network/received_bytes_count. The
     * autoscaler will work to keep this value constant for each of the instances.
     */
    utilizationTarget: number;
    /**
     * Defines how target utilization value is expressed for a Stackdriver
     * Monitoring metric. Either GAUGE, DELTA_PER_SECOND, or DELTA_PER_MINUTE. If
     * not specified, the default is GAUGE.
     */
    utilizationTargetType: string;
}
/**
 * Configuration parameters of autoscaling based on load balancing.
 */
export interface Schema$AutoscalingPolicyLoadBalancingUtilization {
    /**
     * Fraction of backend capacity utilization (set in HTTP(s) load balancing
     * configuration) that autoscaler should maintain. Must be a positive float
     * value. If not defined, the default is 0.8.
     */
    utilizationTarget: number;
}
/**
 * Message containing information of one individual backend.
 */
export interface Schema$Backend {
    /**
     * Specifies the balancing mode for this backend. For global HTTP(S) or
     * TCP/SSL load balancing, the default is UTILIZATION. Valid values are
     * UTILIZATION, RATE (for HTTP(S)) and CONNECTION (for TCP/SSL).  For Internal
     * Load Balancing, the default and only supported mode is CONNECTION.
     */
    balancingMode: string;
    /**
     * A multiplier applied to the group's maximum servicing capacity (based
     * on UTILIZATION, RATE or CONNECTION). Default value is 1, which means the
     * group will serve up to 100% of its configured capacity (depending on
     * balancingMode). A setting of 0 means the group is completely drained,
     * offering 0% of its available Capacity. Valid range is [0.0,1.0].  This
     * cannot be used for internal load balancing.
     */
    capacityScaler: number;
    /**
     * An optional description of this resource. Provide this property when you
     * create the resource.
     */
    description: string;
    /**
     * The fully-qualified URL of a Instance Group resource. This instance group
     * defines the list of instances that serve traffic. Member virtual machine
     * instances from each instance group must live in the same zone as the
     * instance group itself. No two backends in a backend service are allowed to
     * use same Instance Group resource.  Note that you must specify an Instance
     * Group resource using the fully-qualified URL, rather than a partial URL.
     * When the BackendService has load balancing scheme INTERNAL, the instance
     * group must be within the same region as the BackendService.
     */
    group: string;
    /**
     * The max number of simultaneous connections for the group. Can be used with
     * either CONNECTION or UTILIZATION balancing modes. For CONNECTION mode,
     * either maxConnections or maxConnectionsPerInstance must be set.  This
     * cannot be used for internal load balancing.
     */
    maxConnections: number;
    /**
     * The max number of simultaneous connections that a single backend instance
     * can handle. This is used to calculate the capacity of the group. Can be
     * used in either CONNECTION or UTILIZATION balancing modes. For CONNECTION
     * mode, either maxConnections or maxConnectionsPerInstance must be set.  This
     * cannot be used for internal load balancing.
     */
    maxConnectionsPerInstance: number;
    /**
     * The max requests per second (RPS) of the group. Can be used with either
     * RATE or UTILIZATION balancing modes, but required if RATE mode. For RATE
     * mode, either maxRate or maxRatePerInstance must be set.  This cannot be
     * used for internal load balancing.
     */
    maxRate: number;
    /**
     * The max requests per second (RPS) that a single backend instance can
     * handle. This is used to calculate the capacity of the group. Can be used in
     * either balancing mode. For RATE mode, either maxRate or maxRatePerInstance
     * must be set.  This cannot be used for internal load balancing.
     */
    maxRatePerInstance: number;
    /**
     * Used when balancingMode is UTILIZATION. This ratio defines the CPU
     * utilization target for the group. The default is 0.8. Valid range is
     * [0.0, 1.0].  This cannot be used for internal load balancing.
     */
    maxUtilization: number;
}
/**
 * A BackendBucket resource. This resource defines a Cloud Storage bucket.
 */
export interface Schema$BackendBucket {
    /**
     * Cloud Storage bucket name.
     */
    bucketName: string;
    /**
     * Cloud CDN Coniguration for this BackendBucket.
     */
    cdnPolicy: Schema$BackendBucketCdnPolicy;
    /**
     * [Output Only] Creation timestamp in RFC3339 text format.
     */
    creationTimestamp: string;
    /**
     * An optional textual description of the resource; provided by the client
     * when the resource is created.
     */
    description: string;
    /**
     * If true, enable Cloud CDN for this BackendBucket.
     */
    enableCdn: boolean;
    /**
     * [Output Only] Unique identifier for the resource; defined by the server.
     */
    id: string;
    /**
     * Type of the resource.
     */
    kind: string;
    /**
     * 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])?` which means the first character
     * must be a lowercase letter, and all following characters must be a dash,
     * lowercase letter, or digit, except the last character, which cannot be a
     * dash.
     */
    name: string;
    /**
     * [Output Only] Server-defined URL for the resource.
     */
    selfLink: string;
}
/**
 * Message containing Cloud CDN configuration for a backend bucket.
 */
export interface Schema$BackendBucketCdnPolicy {
    /**
     * Number of seconds up to which the response to a signed URL request will be
     * cached in the CDN. After this time period, the Signed URL will be
     * revalidated before being served. Defaults to 1hr (3600s). If this field is
     * set, Cloud CDN will internally act as though all responses from this bucket
     * had a ?Cache-Control: public, max-age=[TTL]? header, regardless of any
     * existing Cache-Control header. The actual headers served in responses will
     * not be altered.
     */
    signedUrlCacheMaxAgeSec: string;
    /**
     * [Output Only] Names of the keys currently configured for Cloud CDN Signed
     * URL on this backend bucket.
     */
    signedUrlKeyNames: string[];
}
/**
 * Contains a list of BackendBucket resources.
 */
export interface Schema$BackendBucketList {
    /**
     * [Output Only] Unique identifier for the resource; defined by the server.
     */
    id: string;
    /**
     * A list of BackendBucket resources.
     */
    items: Schema$BackendBucket[];
    /**
     * Type of resource.
     */
    kind: string;
    /**
     * [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;
    /**
     * [Output Only] Server-defined URL for this resource.
     */
    selfLink: string;
    /**
     * [Output Only] Informational warning message.
     */
    warning: any;
}
/**
 * A BackendService resource. This resource defines a group of backend virtual
 * machines and their serving capacity. (== resource_for v1.backendService ==)
 * (== resource_for beta.backendService ==)
 */
export interface Schema$BackendService {
    /**
     * Lifetime of cookies in seconds if session_affinity is GENERATED_COOKIE. If
     * set to 0, the cookie is non-persistent and lasts only until the end of the
     * browser session (or equivalent). The maximum allowed value for TTL is one
     * day.  When the load balancing scheme is INTERNAL, this field is not used.
     */
    affinityCookieTtlSec: number;
    /**
     * The list of backends that serve this BackendService.
     */
    backends: Schema$Backend[];
    /**
     * Cloud CDN configuration for this BackendService.
     */
    cdnPolicy: Schema$BackendServiceCdnPolicy;
    connectionDraining: Schema$ConnectionDraining;
    /**
     * [Output Only] Creation timestamp in RFC3339 text format.
     */
    creationTimestamp: string;
    /**
     * Headers that the HTTP/S load balancer should add to proxied requests.
     */
    customRequestHeaders: string[];
    /**
     * An optional description of this resource. Provide this property when you
     * create the resource.
     */
    description: string;
    /**
     * If true, enable Cloud CDN for this BackendService.  When the load balancing
     * scheme is INTERNAL, this field is not used.
     */
    enableCDN: boolean;
    /**
     * Fingerprint of this resource. A hash of the contents stored in this object.
     * This field is used in optimistic locking. This field will be ignored when
     * inserting a BackendService. An up-to-date fingerprint must be provided in
     * order to update the BackendService.
     */
    fingerprint: string;
    /**
     * The list of URLs to the HttpHealthCheck or HttpsHealthCheck resource for
     * health checking this BackendService. Currently at most one health check can
     * be specified, and a health check is required for Compute Engine backend
     * services. A health check must not be specified for App Engine backend and
     * Cloud Function backend.  For internal load balancing, a URL to a
     * HealthCheck resource must be specified instead.
     */
    healthChecks: string[];
    iap: Schema$BackendServiceIAP;
    /**
     * [Output Only] The unique identifier for the resource. This identifier is
     * defined by the server.
     */
    id: string;
    /**
     * [Output Only] Type of resource. Always compute#backendService for backend
     * services.
     */
    kind: string;
    /**
     * Indicates whether the backend service will be used with internal or
     * external load balancing. A backend service created for one type of load
     * balancing cannot be used with the other. Possible values are INTERNAL and
     * EXTERNAL.
     */
    loadBalancingScheme: string;
    /**
     * 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])?` which means the first character
     * must be a lowercase letter, and all following characters must be a dash,
     * lowercase letter, or digit, except the last character, which cannot be a
     * dash.
     */
    name: string;
    /**
     * Deprecated in favor of portName. The TCP port to connect on the backend.
     * The default value is 80.  This cannot be used for internal load balancing.
     */
    port: number;
    /**
     * Name of backend port. The same name should appear in the instance groups
     * referenced by this service. Required when the load balancing s