npm package: @maxim_mazurok/gapi.client.compute-alpha
Description: TypeScript typings for Compute Engine API alpha
Author: Maxim Mazurok
Latest version: 0.1.20260306

# TypeScript typings for Compute Engine API alpha

Creates and runs virtual machines on Google Cloud Platform.
For detailed description please check [documentation](https://cloud.google.com/compute/).

## Installing

Install typings for Compute Engine API:

```
npm install @types/gapi.client.compute-alpha --save-dev
```

## Usage

You need to initialize Google API client in your code:

```typescript
gapi.load('client', () => {
  // now we can use gapi.client
  // ...
});
```

Then load api client wrapper:

```typescript
gapi.client.load(
  'https://www.googleapis.com/discovery/v1/apis/compute/alpha/rest',
  () => {
    // now we can use:
    // gapi.client.compute
  },
);
```

```typescript
// Deprecated, use discovery document URL, see https://github.com/google/google-api-javascript-client/blob/master/docs/reference.md#----gapiclientloadname----version----callback--
gapi.client.load('compute', 'alpha', () => {
  // now we can use:
  // gapi.client.compute
});
```

Don't forget to authenticate your client before sending any request to resources:

```typescript
// declare client_id registered in Google Developers Console
var client_id = '',
  scope = [
    // See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account.
    'https://www.googleapis.com/auth/cloud-platform',

    // View and manage your Google Compute Engine resources
    'https://www.googleapis.com/auth/compute',

    // View your Google Compute Engine resources
    'https://www.googleapis.com/auth/compute.readonly',

    // Manage your data and permissions in Cloud Storage and see the email address for your Google Account
    'https://www.googleapis.com/auth/devstorage.full_control',

    // View your data in Google Cloud Storage
    'https://www.googleapis.com/auth/devstorage.read_only',

    // Manage your data in Cloud Storage and see the email address of your Google Account
    'https://www.googleapis.com/auth/devstorage.read_write',
  ],
  immediate = true;
// ...

gapi.auth.authorize(
  {client_id: client_id, scope: scope, immediate: immediate},
  authResult => {
    if (authResult && !authResult.error) {
      /* handle successful authorization */
    } else {
      /* handle authorization error */
    }
  },
);
```

After that you can use Compute Engine API resources: <!-- TODO: make this work for multiple namespaces -->

```typescript

/*
Retrieves an aggregated list of accelerator types.

To prevent failure, it is recommended that you set the
`returnPartialSuccess` parameter to `true`.
*/
await gapi.client.compute.acceleratorTypes.aggregatedList({ project: "project",  });

/*
Returns the specified accelerator type.
*/
await gapi.client.compute.acceleratorTypes.get({ acceleratorType: "acceleratorType", project: "project", zone: "zone",  });

/*
Retrieves a list of accelerator types that are available to the specified
project.
*/
await gapi.client.compute.acceleratorTypes.list({ project: "project", zone: "zone",  });

/*
Retrieves an aggregated list of addresses.

To prevent failure, it is recommended that you set the
`returnPartialSuccess` parameter to `true`.
*/
await gapi.client.compute.addresses.aggregatedList({ project: "project",  });

/*
Deletes the specified address resource.
*/
await gapi.client.compute.addresses.delete({ address: "address", project: "project", region: "region",  });

/*
Returns the specified address resource.
*/
await gapi.client.compute.addresses.get({ address: "address", project: "project", region: "region",  });

/*
Creates an address resource in the specified project by using the data
included in the request.
*/
await gapi.client.compute.addresses.insert({ project: "project", region: "region",  });

/*
Retrieves a list of addresses contained within
the specified region.
*/
await gapi.client.compute.addresses.list({ project: "project", region: "region",  });

/*
Moves the specified address resource.
*/
await gapi.client.compute.addresses.move({ address: "address", project: "project", region: "region",  });

/*
Sets the labels on an Address. To learn more about labels, read theLabeling
Resources documentation.
*/
await gapi.client.compute.addresses.setLabels({ project: "project", region: "region", resource: "resource",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.addresses.testIamPermissions({ project: "project", region: "region", resource: "resource",  });

/*
Advise how, where and when to create the requested amount of instances
with specified accelerators, within the specified time and location limits.
The method recommends creating future reservations for the requested
resources.
*/
await gapi.client.compute.advice.calendarMode({ project: "project", region: "region",  });

/*
Advice on making real-time decisions (such as choosing zone or
machine types) during deployment to maximize your chances of obtaining
capacity.
*/
await gapi.client.compute.advice.capacity({ project: "project", region: "region",  });

/*
Retrieves an aggregated list of autoscalers.

To prevent failure, it is recommended that you set the
`returnPartialSuccess` parameter to `true`.
*/
await gapi.client.compute.autoscalers.aggregatedList({ project: "project",  });

/*
Deletes the specified autoscaler.
*/
await gapi.client.compute.autoscalers.delete({ autoscaler: "autoscaler", project: "project", zone: "zone",  });

/*
Returns the specified autoscaler resource.
*/
await gapi.client.compute.autoscalers.get({ autoscaler: "autoscaler", project: "project", zone: "zone",  });

/*
Creates an autoscaler in the specified project using the data
included in the request.
*/
await gapi.client.compute.autoscalers.insert({ project: "project", zone: "zone",  });

/*
Retrieves a list of autoscalers contained within
the specified zone.
*/
await gapi.client.compute.autoscalers.list({ project: "project", zone: "zone",  });

/*
Updates an autoscaler in the specified project using the data
included in the request. This method supportsPATCH
semantics and uses theJSON merge
patch format and processing rules.
*/
await gapi.client.compute.autoscalers.patch({ project: "project", zone: "zone",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.autoscalers.testIamPermissions({ project: "project", resource: "resource", zone: "zone",  });

/*
Updates an autoscaler in the specified project using the data
included in the request.
*/
await gapi.client.compute.autoscalers.update({ project: "project", zone: "zone",  });

/*
Adds a key for validating requests with signed URLs for this backend
bucket.
*/
await gapi.client.compute.backendBuckets.addSignedUrlKey({ backendBucket: "backendBucket", project: "project",  });

/*
Retrieves the list of all BackendBucket resources, regional and global,
available to the specified project.

To prevent failure, it is recommended that you set the
`returnPartialSuccess` parameter to `true`.
*/
await gapi.client.compute.backendBuckets.aggregatedList({ project: "project",  });

/*
Deletes the specified BackendBucket resource.
*/
await gapi.client.compute.backendBuckets.delete({ backendBucket: "backendBucket", project: "project",  });

/*
Deletes a key for validating requests with signed URLs for this backend
bucket.
*/
await gapi.client.compute.backendBuckets.deleteSignedUrlKey({ backendBucket: "backendBucket", keyName: "keyName", project: "project",  });

/*
Returns the specified BackendBucket resource.
*/
await gapi.client.compute.backendBuckets.get({ backendBucket: "backendBucket", project: "project",  });

/*
Gets the access control policy for a resource. May be empty if no such
policy or resource exists.
*/
await gapi.client.compute.backendBuckets.getIamPolicy({ project: "project", resource: "resource",  });

/*
Creates a BackendBucket resource in the specified project using
the data included in the request.
*/
await gapi.client.compute.backendBuckets.insert({ project: "project",  });

/*
Retrieves the list of BackendBucket resources available to the specified
project.
*/
await gapi.client.compute.backendBuckets.list({ project: "project",  });

/*
Retrieves a list of all usable backend buckets in the specified project.
*/
await gapi.client.compute.backendBuckets.listUsable({ project: "project",  });

/*
Updates the specified BackendBucket resource with the data included in the
request. This method supportsPATCH
semantics and uses theJSON merge
patch format and processing rules.
*/
await gapi.client.compute.backendBuckets.patch({ backendBucket: "backendBucket", project: "project",  });

/*
Sets the edge security policy for the specified backend bucket.
*/
await gapi.client.compute.backendBuckets.setEdgeSecurityPolicy({ backendBucket: "backendBucket", project: "project",  });

/*
Sets the access control policy on the specified resource.
Replaces any existing policy.
*/
await gapi.client.compute.backendBuckets.setIamPolicy({ project: "project", resource: "resource",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.backendBuckets.testIamPermissions({ project: "project", resource: "resource",  });

/*
Updates the specified BackendBucket resource with the data included in the
request.
*/
await gapi.client.compute.backendBuckets.update({ backendBucket: "backendBucket", project: "project",  });

/*
Adds a key for validating requests with signed URLs for this backend
service.
*/
await gapi.client.compute.backendServices.addSignedUrlKey({ backendService: "backendService", project: "project",  });

/*
Retrieves the list of all BackendService resources, regional and global,
available to the specified project.

To prevent failure, it is recommended that you set the
`returnPartialSuccess` parameter to `true`.
*/
await gapi.client.compute.backendServices.aggregatedList({ project: "project",  });

/*
Deletes the specified BackendService resource.
*/
await gapi.client.compute.backendServices.delete({ backendService: "backendService", project: "project",  });

/*
Deletes a key for validating requests with signed URLs for this backend
service.
*/
await gapi.client.compute.backendServices.deleteSignedUrlKey({ backendService: "backendService", keyName: "keyName", project: "project",  });

/*
Returns the specified BackendService resource.
*/
await gapi.client.compute.backendServices.get({ backendService: "backendService", project: "project",  });

/*
Returns effective security policies applied to this backend service.
*/
await gapi.client.compute.backendServices.getEffectiveSecurityPolicies({ backendService: "backendService", project: "project",  });

/*
Gets the most recent health check results for this
BackendService.

Example request body:

{
  "group": "/zones/us-east1-b/instanceGroups/lb-backend-example"
}
*/
await gapi.client.compute.backendServices.getHealth({ backendService: "backendService", project: "project",  });

/*
Gets the access control policy for a resource. May be empty if no such
policy or resource exists.
*/
await gapi.client.compute.backendServices.getIamPolicy({ project: "project", resource: "resource",  });

/*
Creates a BackendService resource in the specified project using
the data included in the request. For more information, see
Backend services overview.
*/
await gapi.client.compute.backendServices.insert({ project: "project",  });

/*
Retrieves the list of BackendService resources available to the specified
project.
*/
await gapi.client.compute.backendServices.list({ project: "project",  });

/*
Retrieves a list of all usable backend services in the specified project.
*/
await gapi.client.compute.backendServices.listUsable({ project: "project",  });

/*
Patches the specified BackendService resource with the data included in the
request. For more information, see
Backend services overview. This method
supports PATCH semantics and uses the JSON merge
patch format and processing rules.
*/
await gapi.client.compute.backendServices.patch({ backendService: "backendService", project: "project",  });

/*
Sets the edge security policy for the specified backend service.
*/
await gapi.client.compute.backendServices.setEdgeSecurityPolicy({ backendService: "backendService", project: "project",  });

/*
Sets the access control policy on the specified resource.
Replaces any existing policy.
*/
await gapi.client.compute.backendServices.setIamPolicy({ project: "project", resource: "resource",  });

/*
Sets the Google Cloud Armor security policy for the specified backend
service. For more information, seeGoogle
Cloud Armor Overview
*/
await gapi.client.compute.backendServices.setSecurityPolicy({ backendService: "backendService", project: "project",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.backendServices.testIamPermissions({ project: "project", resource: "resource",  });

/*
Updates the specified BackendService resource with the data included in the
request. For more information, seeBackend
services overview.
*/
await gapi.client.compute.backendServices.update({ backendService: "backendService", project: "project",  });

/*
Deletes the specified cross-site network in the given scope.
*/
await gapi.client.compute.crossSiteNetworks.delete({ crossSiteNetwork: "crossSiteNetwork", project: "project",  });

/*
Returns the specified cross-site network in the given scope.
*/
await gapi.client.compute.crossSiteNetworks.get({ crossSiteNetwork: "crossSiteNetwork", project: "project",  });

/*
Creates a cross-site network in the specified project in the given scope
using the parameters that are included in the request.
*/
await gapi.client.compute.crossSiteNetworks.insert({ project: "project",  });

/*
Lists the cross-site networks for a project in the given scope.
*/
await gapi.client.compute.crossSiteNetworks.list({ project: "project",  });

/*
Updates the specified cross-site network with the data included in
the request. This method supportsPATCH
semantics and uses theJSON merge
patch format and processing rules.
*/
await gapi.client.compute.crossSiteNetworks.patch({ crossSiteNetwork: "crossSiteNetwork", project: "project",  });

/*
Adds existing resource policies to a disk. You can only add one
policy which will be applied to this disk for scheduling snapshot
creation.
*/
await gapi.client.compute.disks.addResourcePolicies({ disk: "disk", project: "project", zone: "zone",  });

/*
Retrieves an aggregated list of persistent disks.

To prevent failure, it is recommended that you set the
`returnPartialSuccess` parameter to `true`.
*/
await gapi.client.compute.disks.aggregatedList({ project: "project",  });

/*
Bulk create a set of disks.
*/
await gapi.client.compute.disks.bulkInsert({ project: "project", zone: "zone",  });

/*
Sets the labels on many disks at once. To learn more about labels, read theLabeling
Resources documentation.
*/
await gapi.client.compute.disks.bulkSetLabels({ project: "project", zone: "zone",  });

/*
Converts a persistent disk to support Gen4+ VMs.
*/
await gapi.client.compute.disks.convert({ disk: "disk", project: "project", zone: "zone",  });

/*
Creates a snapshot of a specified persistent disk. For regular snapshot
creation, consider using snapshots.insert
instead, as that method supports more features, such as creating snapshots
in a project different from the source disk project.
*/
await gapi.client.compute.disks.createSnapshot({ disk: "disk", project: "project", zone: "zone",  });

/*
Deletes the specified persistent disk. Deleting a disk removes its data
permanently and is irreversible. However, deleting a disk does not
delete any snapshots
previously made from the disk. You must separatelydelete
snapshots.
*/
await gapi.client.compute.disks.delete({ disk: "disk", project: "project", zone: "zone",  });

/*
Returns the specified persistent disk.
*/
await gapi.client.compute.disks.get({ disk: "disk", project: "project", zone: "zone",  });

/*
Gets the status of current async replication for a given device.
*/
await gapi.client.compute.disks.getAsyncReplicationStatus({ disk: "disk", project: "project", zone: "zone",  });

/*
Gets the access control policy for a resource. May be empty if no such
policy or resource exists.
*/
await gapi.client.compute.disks.getIamPolicy({ project: "project", resource: "resource", zone: "zone",  });

/*
Creates a persistent disk in the specified project using the data
in the request. You can create a disk from a source
(sourceImage, sourceSnapshot, orsourceDisk) or create an empty 500 GB data disk by
omitting all properties. You can also create a disk that is larger than
the default size by specifying the sizeGb property.
*/
await gapi.client.compute.disks.insert({ project: "project", zone: "zone",  });

/*
Retrieves a list of persistent disks contained within
the specified zone.
*/
await gapi.client.compute.disks.list({ project: "project", zone: "zone",  });

/*
Removes resource policies from a disk.
*/
await gapi.client.compute.disks.removeResourcePolicies({ disk: "disk", project: "project", zone: "zone",  });

/*
Resizes the specified persistent disk.
You can only increase the size of the disk.
*/
await gapi.client.compute.disks.resize({ disk: "disk", project: "project", zone: "zone",  });

/*
Sets the access control policy on the specified resource.
Replaces any existing policy.
*/
await gapi.client.compute.disks.setIamPolicy({ project: "project", resource: "resource", zone: "zone",  });

/*
Sets the labels on a disk. To learn more about labels, read theLabeling
Resources documentation.
*/
await gapi.client.compute.disks.setLabels({ project: "project", resource: "resource", zone: "zone",  });

/*
Starts asynchronous replication.
Must be invoked on the primary disk.
*/
await gapi.client.compute.disks.startAsyncReplication({ disk: "disk", project: "project", zone: "zone",  });

/*
Stops asynchronous replication.
Can be invoked either on the primary or on the secondary disk.
*/
await gapi.client.compute.disks.stopAsyncReplication({ disk: "disk", project: "project", zone: "zone",  });

/*
Stops asynchronous replication for a consistency group of disks.
Can be invoked either in the primary or secondary scope.
*/
await gapi.client.compute.disks.stopGroupAsyncReplication({ project: "project", zone: "zone",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.disks.testIamPermissions({ project: "project", resource: "resource", zone: "zone",  });

/*
Updates the specified disk with the data included in the request.
The update is performed only on selected fields included as part
of update-mask.
*/
await gapi.client.compute.disks.update({ disk: "disk", project: "project", zone: "zone",  });

/*
Rotates the customer-managed
encryption key to the latest version for the specified persistent disk.
*/
await gapi.client.compute.disks.updateKmsKey({ disk: "disk", project: "project", zone: "zone",  });

/*
Wait for replication to catch up on the secondary disk.
*/
await gapi.client.compute.disks.waitForReplicationCatchUp({ disk: "disk", project: "project", zone: "zone",  });

/*
Get Zonal Disk Settings.
*/
await gapi.client.compute.diskSettings.get({ project: "project", zone: "zone",  });

/*
Patch Zonal Disk Settings
*/
await gapi.client.compute.diskSettings.patch({ project: "project", zone: "zone",  });

/*
Retrieves an aggregated list of disk types.

To prevent failure, it is recommended that you set the
`returnPartialSuccess` parameter to `true`.
*/
await gapi.client.compute.diskTypes.aggregatedList({ project: "project",  });

/*
Returns the specified disk type.
*/
await gapi.client.compute.diskTypes.get({ diskType: "diskType", project: "project", zone: "zone",  });

/*
Retrieves a list of disk types available to the specified
project.
*/
await gapi.client.compute.diskTypes.list({ project: "project", zone: "zone",  });

/*
Deletes the specified externalVpnGateway.
*/
await gapi.client.compute.externalVpnGateways.delete({ externalVpnGateway: "externalVpnGateway", project: "project",  });

/*
Returns the specified externalVpnGateway. Get a list of available
externalVpnGateways by making a list() request.
*/
await gapi.client.compute.externalVpnGateways.get({ externalVpnGateway: "externalVpnGateway", project: "project",  });

/*
Creates a ExternalVpnGateway in the specified project using
the data included in the request.
*/
await gapi.client.compute.externalVpnGateways.insert({ project: "project",  });

/*
Retrieves the list of ExternalVpnGateway available to the specified
project.
*/
await gapi.client.compute.externalVpnGateways.list({ project: "project",  });

/*
Sets the labels on an ExternalVpnGateway. To learn more about labels,
read the Labeling
Resources documentation.
*/
await gapi.client.compute.externalVpnGateways.setLabels({ project: "project", resource: "resource",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.externalVpnGateways.testIamPermissions({ project: "project", resource: "resource",  });

/*
Inserts an association for the specified firewall policy.
*/
await gapi.client.compute.firewallPolicies.addAssociation({ firewallPolicy: "firewallPolicy",  });

/*
Inserts a packet mirroring rule into a firewall policy.
*/
await gapi.client.compute.firewallPolicies.addPacketMirroringRule({ firewallPolicy: "firewallPolicy",  });

/*
Inserts a rule into a firewall policy.
*/
await gapi.client.compute.firewallPolicies.addRule({ firewallPolicy: "firewallPolicy",  });

/*
Copies rules to the specified firewall policy.
*/
await gapi.client.compute.firewallPolicies.cloneRules({ firewallPolicy: "firewallPolicy",  });

/*
Deletes the specified policy.
*/
await gapi.client.compute.firewallPolicies.delete({ firewallPolicy: "firewallPolicy",  });

/*
Starts a brand new progressive rollout of hierarchical firewall policy.
This API will return an error when there is an ongoing progressive rollout.
*/
await gapi.client.compute.firewallPolicies.forceStartProgressiveRollout({ firewallPolicy: "firewallPolicy",  });

/*
Returns the specified firewall policy.
*/
await gapi.client.compute.firewallPolicies.get({ firewallPolicy: "firewallPolicy",  });

/*
Gets an association with the specified name.
*/
await gapi.client.compute.firewallPolicies.getAssociation({ firewallPolicy: "firewallPolicy",  });

/*
Gets the access control policy for a resource. May be empty if no such
policy or resource exists.
*/
await gapi.client.compute.firewallPolicies.getIamPolicy({ resource: "resource",  });

/*
Gets a packet mirroring rule of the specified priority.
*/
await gapi.client.compute.firewallPolicies.getPacketMirroringRule({ firewallPolicy: "firewallPolicy",  });

/*
Gets a rule of the specified priority.
*/
await gapi.client.compute.firewallPolicies.getRule({ firewallPolicy: "firewallPolicy",  });

/*
Creates a new policy in the specified project using the data included in
the request.
*/
await gapi.client.compute.firewallPolicies.insert({  });

/*
Lists all the policies that have been configured for the specified
folder or organization.
*/
await gapi.client.compute.firewallPolicies.list({  });

/*
Lists associations of a specified target, i.e., organization or folder.
*/
await gapi.client.compute.firewallPolicies.listAssociations({  });

/*
Moves the specified firewall policy.
*/
await gapi.client.compute.firewallPolicies.move({ firewallPolicy: "firewallPolicy",  });

/*
Patches the specified policy with the data included in the request.
*/
await gapi.client.compute.firewallPolicies.patch({ firewallPolicy: "firewallPolicy",  });

/*
Patches a packet mirroring rule of the specified priority.
*/
await gapi.client.compute.firewallPolicies.patchPacketMirroringRule({ firewallPolicy: "firewallPolicy",  });

/*
Patches a rule of the specified priority.
*/
await gapi.client.compute.firewallPolicies.patchRule({ firewallPolicy: "firewallPolicy",  });

/*
Removes an association for the specified firewall policy.
*/
await gapi.client.compute.firewallPolicies.removeAssociation({ firewallPolicy: "firewallPolicy",  });

/*
Deletes a packet mirroring rule of the specified priority.
*/
await gapi.client.compute.firewallPolicies.removePacketMirroringRule({ firewallPolicy: "firewallPolicy",  });

/*
Deletes a rule of the specified priority.
*/
await gapi.client.compute.firewallPolicies.removeRule({ firewallPolicy: "firewallPolicy",  });

/*
Sets the access control policy on the specified resource.
Replaces any existing policy.
*/
await gapi.client.compute.firewallPolicies.setIamPolicy({ resource: "resource",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.firewallPolicies.testIamPermissions({ resource: "resource",  });

/*
Deletes the specified firewall.
*/
await gapi.client.compute.firewalls.delete({ firewall: "firewall", project: "project",  });

/*
Returns the specified firewall.
*/
await gapi.client.compute.firewalls.get({ firewall: "firewall", project: "project",  });

/*
Creates a firewall rule in the specified project using the data
included in the request.
*/
await gapi.client.compute.firewalls.insert({ project: "project",  });

/*
Retrieves the list of firewall rules available to the specified
project.
*/
await gapi.client.compute.firewalls.list({ project: "project",  });

/*
Updates the specified firewall rule with the data included in the
request. This method supportsPATCH
semantics and uses theJSON merge
patch format and processing rules.
*/
await gapi.client.compute.firewalls.patch({ firewall: "firewall", project: "project",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.firewalls.testIamPermissions({ project: "project", resource: "resource",  });

/*
Updates the specified firewall rule with the data included in the
request.
Note that all fields will be updated if using PUT, even fields that are not
specified. To update individual fields, please use PATCH instead.
*/
await gapi.client.compute.firewalls.update({ firewall: "firewall", project: "project",  });

/*
Retrieves an aggregated list of forwarding rules.

To prevent failure, it is recommended that you set the
`returnPartialSuccess` parameter to `true`.
*/
await gapi.client.compute.forwardingRules.aggregatedList({ project: "project",  });

/*
Deletes the specified ForwardingRule resource.
*/
await gapi.client.compute.forwardingRules.delete({ forwardingRule: "forwardingRule", project: "project", region: "region",  });

/*
Returns the specified ForwardingRule resource.
*/
await gapi.client.compute.forwardingRules.get({ forwardingRule: "forwardingRule", project: "project", region: "region",  });

/*
Creates a ForwardingRule resource in the specified project and region using
the data included in the request.
*/
await gapi.client.compute.forwardingRules.insert({ project: "project", region: "region",  });

/*
Retrieves a list of ForwardingRule resources available to the specified
project and region.
*/
await gapi.client.compute.forwardingRules.list({ project: "project", region: "region",  });

/*
Updates the specified forwarding rule with the data included in the
request. This method supportsPATCH
semantics and uses theJSON merge
patch format and processing rules. Currently, you can only
patch the network_tier field.
*/
await gapi.client.compute.forwardingRules.patch({ forwardingRule: "forwardingRule", project: "project", region: "region",  });

/*
Sets the labels on the specified resource. To learn more about labels,
read the
Labeling Resources documentation.
*/
await gapi.client.compute.forwardingRules.setLabels({ project: "project", region: "region", resource: "resource",  });

/*
Changes target URL for forwarding rule. The new target should be of the
same type as the old target.
*/
await gapi.client.compute.forwardingRules.setTarget({ forwardingRule: "forwardingRule", project: "project", region: "region",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.forwardingRules.testIamPermissions({ project: "project", region: "region", resource: "resource",  });

/*
Retrieves an aggregated list of future reservations.

To prevent failure, it is recommended that you set the
`returnPartialSuccess` parameter to `true`.
*/
await gapi.client.compute.futureReservations.aggregatedList({ project: "project",  });

/*
Cancel the specified future reservation.
*/
await gapi.client.compute.futureReservations.cancel({ futureReservation: "futureReservation", project: "project", zone: "zone",  });

/*
Deletes the specified future reservation.
*/
await gapi.client.compute.futureReservations.delete({ futureReservation: "futureReservation", project: "project", zone: "zone",  });

/*
Retrieves information about the specified future reservation.
*/
await gapi.client.compute.futureReservations.get({ futureReservation: "futureReservation", project: "project", zone: "zone",  });

/*
Creates a new Future Reservation.
*/
await gapi.client.compute.futureReservations.insert({ project: "project", zone: "zone",  });

/*
A list of all the future reservations that have been configured for the
specified project in specified zone.
*/
await gapi.client.compute.futureReservations.list({ project: "project", zone: "zone",  });

/*
Updates the specified future reservation.
*/
await gapi.client.compute.futureReservations.update({ futureReservation: "futureReservation", project: "project", zone: "zone",  });

/*
Deletes the specified address resource.
*/
await gapi.client.compute.globalAddresses.delete({ address: "address", project: "project",  });

/*
Returns the specified address resource.
*/
await gapi.client.compute.globalAddresses.get({ address: "address", project: "project",  });

/*
Find owner instance from given ip address
*/
await gapi.client.compute.globalAddresses.getOwnerInstance({ project: "project",  });

/*
Creates an address resource in the specified project by using the data
included in the request.
*/
await gapi.client.compute.globalAddresses.insert({ project: "project",  });

/*
Retrieves a list of global addresses.
*/
await gapi.client.compute.globalAddresses.list({ project: "project",  });

/*
Moves the specified address resource from one project to another project.
*/
await gapi.client.compute.globalAddresses.move({ address: "address", project: "project",  });

/*
Sets the labels on a GlobalAddress. To learn more about labels, read theLabeling
Resources documentation.
*/
await gapi.client.compute.globalAddresses.setLabels({ project: "project", resource: "resource",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.globalAddresses.testIamPermissions({ project: "project", resource: "resource",  });

/*
Retrieves the specified Operations resource.
*/
await gapi.client.compute.globalFolderOperations.get({ folder: "folder", operation: "operation",  });

/*
Retrieves a list of Operation resources contained within the specified
folder.
*/
await gapi.client.compute.globalFolderOperations.list({ folder: "folder",  });

/*
Deletes the specified GlobalForwardingRule resource.
*/
await gapi.client.compute.globalForwardingRules.delete({ forwardingRule: "forwardingRule", project: "project",  });

/*
Returns the specified GlobalForwardingRule resource. Gets a list of
available forwarding rules by making a list() request.
*/
await gapi.client.compute.globalForwardingRules.get({ forwardingRule: "forwardingRule", project: "project",  });

/*
Creates a GlobalForwardingRule resource in the specified project using
the data included in the request.
*/
await gapi.client.compute.globalForwardingRules.insert({ project: "project",  });

/*
Retrieves a list of GlobalForwardingRule resources available to the
specified project.
*/
await gapi.client.compute.globalForwardingRules.list({ project: "project",  });

/*
Updates the specified forwarding rule with the data included in the
request. This method supportsPATCH
semantics and uses theJSON merge
patch format and processing rules. Currently, you can only
patch the network_tier field.
*/
await gapi.client.compute.globalForwardingRules.patch({ forwardingRule: "forwardingRule", project: "project",  });

/*
Sets the labels on the specified resource. To learn more about labels,
read the
Labeling resources documentation.
*/
await gapi.client.compute.globalForwardingRules.setLabels({ project: "project", resource: "resource",  });

/*
Changes target URL for the GlobalForwardingRule resource. The new target
should be of the same type as the old target.
*/
await gapi.client.compute.globalForwardingRules.setTarget({ forwardingRule: "forwardingRule", project: "project",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.globalForwardingRules.testIamPermissions({ project: "project", resource: "resource",  });

/*
Attach a network endpoint to the specified network endpoint group.
*/
await gapi.client.compute.globalNetworkEndpointGroups.attachNetworkEndpoints({ networkEndpointGroup: "networkEndpointGroup", project: "project",  });

/*
Deletes the specified network endpoint group.Note that the NEG cannot be
deleted if there are backend services referencing it.
*/
await gapi.client.compute.globalNetworkEndpointGroups.delete({ networkEndpointGroup: "networkEndpointGroup", project: "project",  });

/*
Detach the network endpoint from the specified network endpoint group.
*/
await gapi.client.compute.globalNetworkEndpointGroups.detachNetworkEndpoints({ networkEndpointGroup: "networkEndpointGroup", project: "project",  });

/*
Returns the specified network endpoint group.
*/
await gapi.client.compute.globalNetworkEndpointGroups.get({ networkEndpointGroup: "networkEndpointGroup", project: "project",  });

/*
Creates a network endpoint group in the specified project using the
parameters that are included in the request.

Note: Use the following APIs to manage network endpoint groups:

   -
   To manage NEGs with zonal scope (such as zonal NEGs, hybrid connectivity
   NEGs): zonal
   API
   -
   To manage NEGs with regional scope (such as regional internet NEGs,
   serverless NEGs, Private Service Connect NEGs): regional
   API
   -
   To manage NEGs with global scope (such as global internet NEGs):global
   API
*/
await gapi.client.compute.globalNetworkEndpointGroups.insert({ project: "project",  });

/*
Retrieves the list of network endpoint groups that are located in the
specified project.
*/
await gapi.client.compute.globalNetworkEndpointGroups.list({ project: "project",  });

/*
Lists the network endpoints in the specified network endpoint group.
*/
await gapi.client.compute.globalNetworkEndpointGroups.listNetworkEndpoints({ networkEndpointGroup: "networkEndpointGroup", project: "project",  });

/*
Retrieves an aggregated list of all operations.

To prevent failure, Google recommends that you set the
`returnPartialSuccess` parameter to `true`.
*/
await gapi.client.compute.globalOperations.aggregatedList({ project: "project",  });

/*
Deletes the specified Operations resource.
*/
await gapi.client.compute.globalOperations.delete({ operation: "operation", project: "project",  });

/*
Retrieves the specified Operations resource.
*/
await gapi.client.compute.globalOperations.get({ operation: "operation", project: "project",  });

/*
Retrieves a list of Operation resources contained within the specified
project.
*/
await gapi.client.compute.globalOperations.list({ project: "project",  });

/*
Waits for the specified Operation resource to return as `DONE`
or for the request to approach the 2 minute deadline, and retrieves the
specified Operation resource. This method differs from the
`GET` method in that it waits for no more than the default
deadline (2 minutes) and then returns the current state of the operation,
which might be `DONE` or still in progress.

This method is called on a best-effort basis. Specifically:


    - In uncommon cases, when the server is overloaded, the request might
    return before the default deadline is reached, or might return after zero
    seconds.
   - If the default deadline is reached, there is no guarantee that the
    operation is actually done when the method returns. Be prepared to retry
    if the operation is not `DONE`.
*/
await gapi.client.compute.globalOperations.wait({ operation: "operation", project: "project",  });

/*
Deletes the specified Operations resource.
*/
await gapi.client.compute.globalOrganizationOperations.delete({ operation: "operation",  });

/*
Retrieves the specified Operations resource. Gets a list of operations
by making a `list()` request.
*/
await gapi.client.compute.globalOrganizationOperations.get({ operation: "operation",  });

/*
Retrieves a list of Operation resources contained within the specified
organization.
*/
await gapi.client.compute.globalOrganizationOperations.list({  });

/*
Deletes the specified global PublicDelegatedPrefix.
*/
await gapi.client.compute.globalPublicDelegatedPrefixes.delete({ project: "project", publicDelegatedPrefix: "publicDelegatedPrefix",  });

/*
Returns the specified global PublicDelegatedPrefix resource.
*/
await gapi.client.compute.globalPublicDelegatedPrefixes.get({ project: "project", publicDelegatedPrefix: "publicDelegatedPrefix",  });

/*
Creates a global PublicDelegatedPrefix in the specified project using the
parameters that are included in the request.
*/
await gapi.client.compute.globalPublicDelegatedPrefixes.insert({ project: "project",  });

/*
Lists the global PublicDelegatedPrefixes for a project.
*/
await gapi.client.compute.globalPublicDelegatedPrefixes.list({ project: "project",  });

/*
Patches the specified global PublicDelegatedPrefix resource with the data
included in the request. This method supportsPATCH
semantics and usesJSON merge
patch format and processing rules.
*/
await gapi.client.compute.globalPublicDelegatedPrefixes.patch({ project: "project", publicDelegatedPrefix: "publicDelegatedPrefix",  });

/*
Retrieves the list of all VM Extension Policy resources
available to the specified project.

To prevent failure, it's recommended that you set the
`returnPartialSuccess` parameter to `true`.
*/
await gapi.client.compute.globalVmExtensionPolicies.aggregatedList({ project: "project",  });

/*
Purge scoped resources (zonal policies) from a global VM extension
policy, and then delete the global VM extension policy. Purge of the scoped
resources is a pre-condition of the global VM extension policy deletion.
The deletion of the global VM extension policy happens after the purge
rollout is done, so it's not a part of the LRO. It's an automatic process
that triggers in the backend.
*/
await gapi.client.compute.globalVmExtensionPolicies.delete({ globalVmExtensionPolicy: "globalVmExtensionPolicy", project: "project",  });

/*
Gets details of a global VM extension policy.
*/
await gapi.client.compute.globalVmExtensionPolicies.get({ globalVmExtensionPolicy: "globalVmExtensionPolicy", project: "project",  });

/*
Retrieves details of a specific VM extension.
*/
await gapi.client.compute.globalVmExtensionPolicies.getVmExtension({ extensionName: "extensionName", project: "project",  });

/*
Creates a new project level GlobalVmExtensionPolicy.
*/
await gapi.client.compute.globalVmExtensionPolicies.insert({ project: "project",  });

/*
Lists global VM extension policies.
*/
await gapi.client.compute.globalVmExtensionPolicies.list({ project: "project",  });

/*
Lists all VM extensions within a specific zone for a project.
This is a read-only API.
*/
await gapi.client.compute.globalVmExtensionPolicies.listVmExtensions({ project: "project",  });

/*
Updates a global VM extension policy.
*/
await gapi.client.compute.globalVmExtensionPolicies.update({ globalVmExtensionPolicy: "globalVmExtensionPolicy", project: "project",  });

/*
Retrieves an aggregated list of all of the HaControllers in the specified
project across all regions.
*/
await gapi.client.compute.haControllers.aggregatedList({ project: "project",  });

/*
Deletes an HaController in the specified project.
*/
await gapi.client.compute.haControllers.delete({ haController: "haController", project: "project", region: "region",  });

/*
Fails over a VM targeted by the specified HaController to the selected
zone.
*/
await gapi.client.compute.haControllers.failover({ haController: "haController", project: "project", region: "region",  });

/*
Returns all the details of a specific HaController.
*/
await gapi.client.compute.haControllers.get({ haController: "haController", project: "project", region: "region",  });

/*
Creates HaController in the specified project.
*/
await gapi.client.compute.haControllers.insert({ project: "project", region: "region",  });

/*
Lists all HaControllers in the specified project in the specified region.
*/
await gapi.client.compute.haControllers.list({ project: "project", region: "region",  });

/*
Updates HaController in the specified project.
*/
await gapi.client.compute.haControllers.patch({ haController: "haController", project: "project", region: "region",  });

/*
Retrieves the list of all HealthCheck resources, regional and global,
available to the specified project.

To prevent failure, Google recommends that you set the
`returnPartialSuccess` parameter to `true`.
*/
await gapi.client.compute.healthChecks.aggregatedList({ project: "project",  });

/*
Deletes the specified HealthCheck resource.
*/
await gapi.client.compute.healthChecks.delete({ healthCheck: "healthCheck", project: "project",  });

/*
Returns the specified HealthCheck resource.
*/
await gapi.client.compute.healthChecks.get({ healthCheck: "healthCheck", project: "project",  });

/*
Creates a HealthCheck resource in the specified project using the data
included in the request.
*/
await gapi.client.compute.healthChecks.insert({ project: "project",  });

/*
Retrieves the list of HealthCheck resources available to the specified
project.
*/
await gapi.client.compute.healthChecks.list({ project: "project",  });

/*
Updates a HealthCheck resource in the specified project using the data
included in the request. This method supportsPATCH
semantics and uses theJSON merge
patch format and processing rules.
*/
await gapi.client.compute.healthChecks.patch({ healthCheck: "healthCheck", project: "project",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.healthChecks.testIamPermissions({ project: "project", resource: "resource",  });

/*
Updates a HealthCheck resource in the specified project using the data
included in the request.
*/
await gapi.client.compute.healthChecks.update({ healthCheck: "healthCheck", project: "project",  });

/*
Deletes the specified HttpHealthCheck resource.
*/
await gapi.client.compute.httpHealthChecks.delete({ httpHealthCheck: "httpHealthCheck", project: "project",  });

/*
Returns the specified HttpHealthCheck resource.
*/
await gapi.client.compute.httpHealthChecks.get({ httpHealthCheck: "httpHealthCheck", project: "project",  });

/*
Creates a HttpHealthCheck resource in the specified project using the data
included in the request.
*/
await gapi.client.compute.httpHealthChecks.insert({ project: "project",  });

/*
Retrieves the list of HttpHealthCheck resources available to the specified
project.
*/
await gapi.client.compute.httpHealthChecks.list({ project: "project",  });

/*
Updates a HttpHealthCheck resource in the specified project using the data
included in the request. This method supportsPATCH
semantics and uses theJSON merge
patch format and processing rules.
*/
await gapi.client.compute.httpHealthChecks.patch({ httpHealthCheck: "httpHealthCheck", project: "project",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.httpHealthChecks.testIamPermissions({ project: "project", resource: "resource",  });

/*
Updates a HttpHealthCheck resource in the specified project using the data
included in the request.
*/
await gapi.client.compute.httpHealthChecks.update({ httpHealthCheck: "httpHealthCheck", project: "project",  });

/*
Deletes the specified HttpsHealthCheck resource.
*/
await gapi.client.compute.httpsHealthChecks.delete({ httpsHealthCheck: "httpsHealthCheck", project: "project",  });

/*
Returns the specified HttpsHealthCheck resource.
*/
await gapi.client.compute.httpsHealthChecks.get({ httpsHealthCheck: "httpsHealthCheck", project: "project",  });

/*
Creates a HttpsHealthCheck resource in the specified project using the data
included in the request.
*/
await gapi.client.compute.httpsHealthChecks.insert({ project: "project",  });

/*
Retrieves the list of HttpsHealthCheck resources available to the specified
project.
*/
await gapi.client.compute.httpsHealthChecks.list({ project: "project",  });

/*
Updates a HttpsHealthCheck resource in the specified project using the data
included in the request. This method supportsPATCH
semantics and uses theJSON merge
patch format and processing rules.
*/
await gapi.client.compute.httpsHealthChecks.patch({ httpsHealthCheck: "httpsHealthCheck", project: "project",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.httpsHealthChecks.testIamPermissions({ project: "project", resource: "resource",  });

/*
Updates a HttpsHealthCheck resource in the specified project using the data
included in the request.
*/
await gapi.client.compute.httpsHealthChecks.update({ httpsHealthCheck: "httpsHealthCheck", project: "project",  });

/*
Returns the latest image that is part of an image family, is not
deprecated and is rolled out in the specified zone.
*/
await gapi.client.compute.imageFamilyViews.get({ family: "family", project: "project", zone: "zone",  });

/*
Deletes the specified image.
*/
await gapi.client.compute.images.delete({ image: "image", project: "project",  });

/*
Sets the deprecation status of an image.

If an empty request body is given, clears the deprecation status instead.
*/
await gapi.client.compute.images.deprecate({ image: "image", project: "project",  });

/*
Returns the specified image.
*/
await gapi.client.compute.images.get({ image: "image", project: "project",  });

/*
Returns the latest image that is part of an image family and is not
deprecated. For more information on image families, seePublic
image families documentation.
*/
await gapi.client.compute.images.getFromFamily({ family: "family", project: "project",  });

/*
Gets the access control policy for a resource. May be empty if no such
policy or resource exists.
*/
await gapi.client.compute.images.getIamPolicy({ project: "project", resource: "resource",  });

/*
Creates an image in the specified project using the data included
in the request.
*/
await gapi.client.compute.images.insert({ project: "project",  });

/*
Retrieves the list of custom images
available to the specified project. Custom images are images you
create that belong to your project. This method does not
get any images that belong to other projects, including publicly-available
images, like Debian 8. If you want to get a list of publicly-available
images, use this method to make a request to the respective image project,
such as debian-cloud or windows-cloud.
*/
await gapi.client.compute.images.list({ project: "project",  });

/*
Patches the specified image with the data included in the request.
Only the following fields can be modified: family, description,
deprecation status.
*/
await gapi.client.compute.images.patch({ image: "image", project: "project",  });

/*
Sets the access control policy on the specified resource.
Replaces any existing policy.
*/
await gapi.client.compute.images.setIamPolicy({ project: "project", resource: "resource",  });

/*
Sets the labels on an image. To learn more about labels, read theLabeling
Resources documentation.
*/
await gapi.client.compute.images.setLabels({ project: "project", resource: "resource",  });

/*
Returns permissions that a caller has on the specified resource.
*/
await gapi.client.compute.images.testIamPermissions({ project: "project", resource: "resource",  });

/*
Cancels the specified resize request and removes it from the queue.
Cancelled resize request does no longer wait for the resources to be
provisioned. Cancel is only possible for requests that are accepted in the
queue.
*/
await gapi.client.compute.instanceGroupManagerResizeRequests.cancel({ instanceGroupManager: "instanceGroupManager", project: "project", resizeRequest: "resizeRequest", zone: "zone",  });

/*
Deletes the specified, inactive resize request. Requests that are still
active cannot be deleted. Deleting request does not delete instances that
were provisioned previously.
*/
await gapi.client.compute.instanceGroupManagerResizeRequests.delete({ instanceGroupManager: "instanceGroupManager", project: "project", resizeRequest: "resizeRequest", zone: "zone",  });

/*
Returns all of the details about the specified resize request.
*/
await gapi.client.compute.instanceGroupManagerResizeRequests.get({ instanceGroupManager: "instanceGroupManager", project: "project", resizeRequest: "resizeRequest", zone: "zone",  });

/*
Creates a new resize request that starts provisioning VMs immediately
or queues VM creation.
*/
await gapi.client.compute.instanceGroupManagerResizeRequests.insert({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Retrieves a list of resize requests that are contained in the
managed instance group.
*/
await gapi.client.compute.instanceGroupManagerResizeRequests.list({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Flags the specified instances to be removed from the
managed instance group. Abandoning an instance does not delete the
instance, but it does remove the instance from any target pools that are
applied by the managed instance group. This method reduces thetargetSize of the managed instance group by the
number of instances that you abandon. This operation is marked asDONE when the action is scheduled even if the instances have
not yet been removed from the group. You must separately verify the
status of the abandoning action with thelistmanagedinstances
method.

If the group is part of a backend
service that has enabled
connection draining, it can take up to 60 seconds after the connection
draining duration has elapsed before the VM instance is removed or deleted.

You can specify a maximum of 1000 instances with this method per request.
*/
await gapi.client.compute.instanceGroupManagers.abandonInstances({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Retrieves the list of managed instance groups and groups them by zone.

To prevent failure, Google recommends that you set the
`returnPartialSuccess` parameter to `true`.
*/
await gapi.client.compute.instanceGroupManagers.aggregatedList({ project: "project",  });

/*
Applies changes to selected instances on the managed instance group.
This method can be used to apply new overrides and/or new versions.
*/
await gapi.client.compute.instanceGroupManagers.applyUpdatesToInstances({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Updates the accelerator topologies configuration.
*/
await gapi.client.compute.instanceGroupManagers.configureAcceleratorTopologies({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Creates instances with per-instance configurations in this managed instance
group. Instances are created using the current instance template. Thecreate instances operation is marked DONE if thecreateInstances request is successful. The underlying actions
take additional time. You must separately verify the status of thecreating or actions with the listmanagedinstances
method.
*/
await gapi.client.compute.instanceGroupManagers.createInstances({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Deletes the specified managed instance group and all of the instances
in that group. Note that the instance group must not belong to a
backend service. Read
Deleting an instance group for more information.
*/
await gapi.client.compute.instanceGroupManagers.delete({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Flags the specified instances in the managed instance group for immediate
deletion. The instances are also removed from any target
pools of which they were a member. This method reduces thetargetSize of the managed instance group by the number of
instances that you delete. This operation is marked as DONE
when the action is scheduled even if the instances are still being deleted.
You must separately verify the status of the deleting action
with thelistmanagedinstances
method.

If the group is part of a backend
service that has enabled
connection draining, it can take up to 60 seconds after the connection
draining duration has elapsed before the VM instance is removed or deleted.

You can specify a maximum of 1000 instances with this method per request.
*/
await gapi.client.compute.instanceGroupManagers.deleteInstances({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Deletes selected per-instance configurations for the managed instance
group.
*/
await gapi.client.compute.instanceGroupManagers.deletePerInstanceConfigs({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Returns all of the details about the specified managed instance group.
*/
await gapi.client.compute.instanceGroupManagers.get({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Returns information about available accelerator topologies for a given MIG.
*/
await gapi.client.compute.instanceGroupManagers.getAvailableAcceleratorTopologies({ project: "project", resourceId: "resourceId", zone: "zone",  });

/*
Creates a managed instance group using the information that you specify
in the request. After the group is created, instances in the group are
created using the specified instance template.
This operation is marked as DONE when the group is created
even if the instances in the group have not yet been created. You
must separately verify the status of the individual instances with thelistmanagedinstances
method.

A managed instance group can have up to 1000 VM instances per group. Please
contact Cloud Support if you need an increase in
this limit.
*/
await gapi.client.compute.instanceGroupManagers.insert({ project: "project", zone: "zone",  });

/*
Retrieves a list of managed instance groups that are contained within the
specified project and zone.
*/
await gapi.client.compute.instanceGroupManagers.list({ project: "project", zone: "zone",  });

/*
Lists all errors thrown by actions on instances for a given managed
instance group. The filter and orderBy query
parameters are not supported.
*/
await gapi.client.compute.instanceGroupManagers.listErrors({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Lists all of the instances in the managed instance group. Each instance
in the list has a currentAction, which indicates the action
that the managed instance group is performing on the instance. For example,
if the group is still creating an instance, the currentAction
is CREATING. If a previous action failed, the
list displays the errors for that failed action. The orderBy
query parameter is not supported. The `pageToken` query parameter is
supported only if the group's `listManagedInstancesResults` field is set
to `PAGINATED`.
*/
await gapi.client.compute.instanceGroupManagers.listManagedInstances({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Lists all of the per-instance configurations defined for the managed
instance group. The orderBy query parameter is not supported.
*/
await gapi.client.compute.instanceGroupManagers.listPerInstanceConfigs({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Updates a managed instance group using the information that you specify
in the request.
This operation is marked as DONE when the group is patched
even if the instances in the group are still in the process of being
patched. You must separately verify the status of the individual instances
with thelistManagedInstances
method. This method supportsPATCH
semantics and uses theJSON merge
patch format and processing rules.

If you update your group to specify a new template or instance
configuration, it's possible that your intended specification for each VM
in the group is different from the current state of that VM. To learn how
to apply an updated configuration to the VMs in a MIG, seeUpdating instances in
a MIG.
*/
await gapi.client.compute.instanceGroupManagers.patch({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Inserts or patches per-instance configurations for the managed instance
group. perInstanceConfig.name serves as a key used to
distinguish whether to perform insert or patch.
*/
await gapi.client.compute.instanceGroupManagers.patchPerInstanceConfigs({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Flags the specified VM instances in the managed instance group to be
immediately recreated. Each instance is recreated using the group's current
configuration. This operation is marked as DONE when the flag
is set even if the instances have not yet been recreated. You must
separately verify the status of each instance by checking itscurrentAction field; for more information, see Checking
the status of managed instances.

If the group is part of a backend
service that has enabled
connection draining, it can take up to 60 seconds after the connection
draining duration has elapsed before the VM instance is removed or deleted.

You can specify a maximum of 1000 instances with this method per request.
*/
await gapi.client.compute.instanceGroupManagers.recreateInstances({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Resizes the managed instance group. If you increase the size, the group
creates new instances using the current instance template. If you decrease
the size, the group deletes instances. The resize operation is markedDONE when the resize actions are scheduled even if the group
has not yet added or deleted any instances. You must separately
verify the status of the creating or deleting
actions with thelistmanagedinstances
method.

When resizing down, the instance group arbitrarily chooses the order in
which VMs are deleted. The group takes into account some VM attributes when
making the selection including:

+ The status of the VM instance.
+ The health of the VM instance.
+ The instance template version the VM is based on.
+ For regional managed instance groups, the location of the VM instance.

This list is subject to change.

If the group is part of a backend
service that has enabled
connection draining, it can take up to 60 seconds after the connection
draining duration has elapsed before the VM instance is removed or deleted.
*/
await gapi.client.compute.instanceGroupManagers.resize({ instanceGroupManager: "instanceGroupManager", project: "project", size: 1, zone: "zone",  });

/*
Resizes the managed instance group with advanced configuration options like
disabling creation retries. This is an extended version of theresize method.

If you increase the size of the instance group, the group creates new
instances using the current instance template. If you decrease the size,
the group deletes instances. The resize operation is markedDONE when the resize actions are scheduled even if the group
has not yet added or deleted any instances. You must separately
verify the status of the creating,creatingWithoutRetries, or deleting actions with
the get
orlistmanagedinstances
method.

If the group is part of a backend
service that has enabled
connection draining, it can take up to 60 seconds after the connection
draining duration has elapsed before the VM instance is removed or deleted.
*/
await gapi.client.compute.instanceGroupManagers.resizeAdvanced({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Flags the specified instances in the managed instance group to be
resumed. This method increases thetargetSize and decreases the targetSuspendedSize
of the managed instance group by the number of instances that you resume.
The resumeInstances operation is marked DONE if
the resumeInstances request is successful. The underlying
actions take additional time. You must separately verify the status of theRESUMING action with thelistmanagedinstances
method.

In this request, you can only specify instances that are suspended. For
example, if an instance was previously suspended using the suspendInstances
method, it can be resumed using the resumeInstances method.

If a health check is attached to the managed instance group, the specified
instances will be verified as healthy after they are resumed.

You can specify a maximum of 1000 instances with this method per request.
*/
await gapi.client.compute.instanceGroupManagers.resumeInstances({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Motifies the autohealing policy for the instances in this managed
instance group.
[Deprecated] This method is deprecated. UseinstanceGroupManagers.patch instead.
*/
await gapi.client.compute.instanceGroupManagers.setAutoHealingPolicies({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Specifies the instance template to use when creating new instances in this
group. The templates for existing instances in the group do not change
unless you run recreateInstances, runapplyUpdatesToInstances, or set the group'supdatePolicy.type to PROACTIVE.
*/
await gapi.client.compute.instanceGroupManagers.setInstanceTemplate({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Modifies the target pools to which all instances in this managed instance
group are assigned. The target pools automatically apply to all of the
instances in the managed instance group. This operation is markedDONE when you make the request even if the instances have not
yet been added to their target pools. The change might take some time to
apply to all of the instances in the group depending on the size of the
group.
*/
await gapi.client.compute.instanceGroupManagers.setTargetPools({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Flags the specified instances in the managed instance group to be
started. This method increases thetargetSize and decreases the targetStoppedSize
of the managed instance group by the number of instances that you start.
The startInstances operation is marked DONE if
the startInstances request is successful. The underlying
actions take additional time. You must separately verify the status of theSTARTING action with thelistmanagedinstances
method.

In this request, you can only specify instances that are stopped. For
example, if an instance was previously stopped using the stopInstances
method, it can be started using the startInstances method.

If a health check is attached to the managed instance group, the specified
instances will be verified as healthy after they are started.

You can specify a maximum of 1000 instances with this method per request.
*/
await gapi.client.compute.instanceGroupManagers.startInstances({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Flags the specified instances in the managed instance group to be
immediately stopped. You can only specify instances that are running in
this request. This method reduces thetargetSize and increases the targetStoppedSize
of the managed instance group by the number of instances that you stop.
The stopInstances operation is marked DONE if
the stopInstances request is successful. The underlying
actions take additional time. You must separately verify the status of theSTOPPING action with thelistmanagedinstances
method.

If the standbyPolicy.initialDelaySec field is set, the group
delays stopping the instances until initialDelaySec have
passed from instance.creationTimestamp (that is, when the
instance was created). This delay gives your application time to
set itself up and initialize on the instance. If more thaninitialDelaySec seconds have passed sinceinstance.creationTimestamp when this method is called, there
will be zero delay.

If the group is part of a backend
service that has enabled
connection draining, it can take up to 60 seconds after the connection
draining duration has elapsed before the VM instance is stopped.

Stopped instances can be started using the startInstances
method.

You can specify a maximum of 1000 instances with this method per request.
*/
await gapi.client.compute.instanceGroupManagers.stopInstances({ instanceGroupManager: "instanceGroupManager", project: "project", zone: "zone",  });

/*
Flags the specified instances in the managed instance group to be
immediately suspended. You can only specify instances that are running in
this request. This method reduces thetargetSize and increases the targetSuspendedSize
of the managed instance group by the number of instances that you suspend.
The suspendInstances operation is marked DONE if
the suspendInstances request is successful. The underlying
actions take additional time. You must separately verify the