googleapis/build/src/apis/appengine/v1beta.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';
/**
 * App Engine Admin API
 *
 * The App Engine Admin API enables developers to provision and manage their App
 * Engine applications.
 *
 * @example
 * const google = require('googleapis');
 * const appengine = google.appengine('v1beta');
 *
 * @namespace appengine
 * @type {Function}
 * @version v1beta
 * @variation v1beta
 * @param {object=} options Options for Appengine
 */
export declare class Appengine {
    _options: GlobalOptions;
    google: GoogleApis;
    root: this;
    apps: Resource$Apps;
    constructor(options: GlobalOptions, google: GoogleApis);
    getRoot(): this;
}
/**
 * Google Cloud Endpoints
 * (https://cloud.google.com/appengine/docs/python/endpoints/) configuration for
 * API handlers.
 */
export interface Schema$ApiConfigHandler {
    /**
     * Action to take when users access resources that require authentication.
     * Defaults to redirect.
     */
    authFailAction: string;
    /**
     * Level of login required to access this resource. Defaults to optional.
     */
    login: string;
    /**
     * Path to the script from the application root directory.
     */
    script: string;
    /**
     * Security (HTTPS) enforcement for this URL.
     */
    securityLevel: string;
    /**
     * URL to serve the endpoint at.
     */
    url: string;
}
/**
 * Uses Google Cloud Endpoints to handle requests.
 */
export interface Schema$ApiEndpointHandler {
    /**
     * Path to the script from the application root directory.
     */
    scriptPath: string;
}
/**
 * An Application resource contains the top-level configuration of an App Engine
 * application.
 */
export interface Schema$Application {
    /**
     * Google Apps authentication domain that controls which users can access this
     * application.Defaults to open access for any Google Account.
     */
    authDomain: string;
    /**
     * Google Cloud Storage bucket that can be used for storing files associated
     * with this application. This bucket is associated with the application and
     * can be used by the gcloud deployment commands.@OutputOnly
     */
    codeBucket: string;
    /**
     * Google Cloud Storage bucket that can be used by this application to store
     * content.@OutputOnly
     */
    defaultBucket: string;
    /**
     * Cookie expiration policy for this application.
     */
    defaultCookieExpiration: string;
    /**
     * Hostname used to reach this application, as resolved by App
     * Engine.@OutputOnly
     */
    defaultHostname: string;
    /**
     * HTTP path dispatch rules for requests to the application that do not
     * explicitly target a service or version. Rules are order-dependent. Up to 20
     * dispatch rules can be supported.@OutputOnly
     */
    dispatchRules: Schema$UrlDispatchRule[];
    /**
     * The feature specific settings to be used in the application.
     */
    featureSettings: Schema$FeatureSettings;
    /**
     * The Google Container Registry domain used for storing managed build docker
     * images for this application.
     */
    gcrDomain: string;
    iap: Schema$IdentityAwareProxy;
    /**
     * Identifier of the Application resource. This identifier is equivalent to
     * the project ID of the Google Cloud Platform project where you want to
     * deploy your application. Example: myapp.
     */
    id: string;
    /**
     * Location from which this application runs. Application instances run out of
     * the data centers in the specified location, which is also where all of the
     * application's end user content is stored.Defaults to us-central.View
     * the list of supported locations
     * (https://cloud.google.com/appengine/docs/locations).
     */
    locationId: string;
    /**
     * Full path to the Application resource in the API. Example:
     * apps/myapp.@OutputOnly
     */
    name: string;
    /**
     * Serving status of this application.
     */
    servingStatus: string;
}
/**
 * An SSL certificate that a user has been authorized to administer. A user is
 * authorized to administer any certificate that applies to one of their
 * authorized domains.
 */
export interface Schema$AuthorizedCertificate {
    /**
     * The SSL certificate serving the AuthorizedCertificate resource. This must
     * be obtained independently from a certificate authority.
     */
    certificateRawData: Schema$CertificateRawData;
    /**
     * The user-specified display name of the certificate. This is not guaranteed
     * to be unique. Example: My Certificate.
     */
    displayName: string;
    /**
     * Aggregate count of the domain mappings with this certificate mapped. This
     * count includes domain mappings on applications for which the user does not
     * have VIEWER permissions.Only returned by GET or LIST requests when
     * specifically requested by the view=FULL_CERTIFICATE option.@OutputOnly
     */
    domainMappingsCount: number;
    /**
     * Topmost applicable domains of this certificate. This certificate applies to
     * these domains and their subdomains. Example: example.com.@OutputOnly
     */
    domainNames: string[];
    /**
     * The time when this certificate expires. To update the renewal time on this
     * certificate, upload an SSL certificate with a different expiration time
     * using AuthorizedCertificates.UpdateAuthorizedCertificate.@OutputOnly
     */
    expireTime: string;
    /**
     * Relative name of the certificate. This is a unique value autogenerated on
     * AuthorizedCertificate resource creation. Example: 12345.@OutputOnly
     */
    id: string;
    /**
     * Only applicable if this certificate is managed by App Engine. Managed
     * certificates are tied to the lifecycle of a DomainMapping and cannot be
     * updated or deleted via the AuthorizedCertificates API. If this certificate
     * is manually administered by the user, this field will be empty.@OutputOnly
     */
    managedCertificate: Schema$ManagedCertificate;
    /**
     * Full path to the AuthorizedCertificate resource in the API. Example:
     * apps/myapp/authorizedCertificates/12345.@OutputOnly
     */
    name: string;
    /**
     * The full paths to user visible Domain Mapping resources that have this
     * certificate mapped. Example: apps/myapp/domainMappings/example.com.This may
     * not represent the full list of mapped domain mappings if the user does not
     * have VIEWER permissions on all of the applications that have this
     * certificate mapped. See domain_mappings_count for a complete count.Only
     * returned by GET or LIST requests when specifically requested by the
     * view=FULL_CERTIFICATE option.@OutputOnly
     */
    visibleDomainMappings: string[];
}
/**
 * A domain that a user has been authorized to administer. To authorize use of a
 * domain, verify ownership via Webmaster Central
 * (https://www.google.com/webmasters/verification/home).
 */
export interface Schema$AuthorizedDomain {
    /**
     * Fully qualified domain name of the domain authorized for use. Example:
     * example.com.
     */
    id: string;
    /**
     * Full path to the AuthorizedDomain resource in the API. Example:
     * apps/myapp/authorizedDomains/example.com.@OutputOnly
     */
    name: string;
}
/**
 * Automatic scaling is based on request rate, response latencies, and other
 * application metrics.
 */
export interface Schema$AutomaticScaling {
    /**
     * Amount of time that the Autoscaler
     * (https://cloud.google.com/compute/docs/autoscaler/) should wait between
     * changes to the number of virtual machines. Only applicable in the App
     * Engine flexible environment.
     */
    coolDownPeriod: string;
    /**
     * Target scaling by CPU usage.
     */
    cpuUtilization: Schema$CpuUtilization;
    /**
     * Target scaling by user-provided metrics.
     */
    customMetrics: Schema$CustomMetric[];
    /**
     * Target scaling by disk usage.
     */
    diskUtilization: Schema$DiskUtilization;
    /**
     * Number of concurrent requests an automatic scaling instance can accept
     * before the scheduler spawns a new instance.Defaults to a runtime-specific
     * value.
     */
    maxConcurrentRequests: number;
    /**
     * Maximum number of idle instances that should be maintained for this
     * version.
     */
    maxIdleInstances: number;
    /**
     * Maximum amount of time that a request should wait in the pending queue
     * before starting a new instance to handle it.
     */
    maxPendingLatency: string;
    /**
     * Maximum number of instances that should be started to handle requests for
     * this version.
     */
    maxTotalInstances: number;
    /**
     * Minimum number of idle instances that should be maintained for this
     * version. Only applicable for the default version of a service.
     */
    minIdleInstances: number;
    /**
     * Minimum amount of time a request should wait in the pending queue before
     * starting a new instance to handle it.
     */
    minPendingLatency: string;
    /**
     * Minimum number of running instances that should be maintained for this
     * version.
     */
    minTotalInstances: number;
    /**
     * Target scaling by network usage.
     */
    networkUtilization: Schema$NetworkUtilization;
    /**
     * Target scaling by request utilization.
     */
    requestUtilization: Schema$RequestUtilization;
    /**
     * Scheduler settings for standard environment.
     */
    standardSchedulerSettings: Schema$StandardSchedulerSettings;
}
/**
 * A service with basic scaling will create an instance when the application
 * receives a request. The instance will be turned down when the app becomes
 * idle. Basic scaling is ideal for work that is intermittent or driven by user
 * activity.
 */
export interface Schema$BasicScaling {
    /**
     * Duration of time after the last request that an instance must wait before
     * the instance is shut down.
     */
    idleTimeout: string;
    /**
     * Maximum number of instances to create for this version.
     */
    maxInstances: number;
}
/**
 * Request message for Firewall.BatchUpdateIngressRules.
 */
export interface Schema$BatchUpdateIngressRulesRequest {
    /**
     * A list of FirewallRules to replace the existing set.
     */
    ingressRules: Schema$FirewallRule[];
}
/**
 * Response message for Firewall.UpdateAllIngressRules.
 */
export interface Schema$BatchUpdateIngressRulesResponse {
    /**
     * The full list of ingress FirewallRules for this application.
     */
    ingressRules: Schema$FirewallRule[];
}
/**
 * Google Cloud Container Builder build information.
 */
export interface Schema$BuildInfo {
    /**
     * The Google Cloud Container Builder build id. Example:
     * "f966068f-08b2-42c8-bdfe-74137dff2bf9"
     */
    cloudBuildId: string;
}
/**
 * An SSL certificate obtained from a certificate authority.
 */
export interface Schema$CertificateRawData {
    /**
     * Unencrypted PEM encoded RSA private key. This field is set once on
     * certificate creation and then encrypted. The key size must be 2048 bits or
     * fewer. Must include the header and footer. Example: <pre> -----BEGIN
     * RSA PRIVATE KEY----- <unencrypted_key_value> -----END RSA PRIVATE
     * KEY----- </pre> @InputOnly
     */
    privateKey: string;
    /**
     * PEM encoded x.509 public key certificate. This field is set once on
     * certificate creation. Must include the header and footer. Example:
     * <pre> -----BEGIN CERTIFICATE----- <certificate_value> -----END
     * CERTIFICATE----- </pre>
     */
    publicCertificate: string;
}
/**
 * Options for the build operations performed as a part of the version
 * deployment. Only applicable for App Engine flexible environment when creating
 * a version using source code directly.
 */
export interface Schema$CloudBuildOptions {
    /**
     * Path to the yaml file used in deployment, used to determine runtime
     * configuration details.Required for flexible environment builds.See
     * https://cloud.google.com/appengine/docs/standard/python/config/appref for
     * more details.
     */
    appYamlPath: string;
    /**
     * The Cloud Build timeout used as part of any dependent builds performed by
     * version creation. Defaults to 10 minutes.
     */
    cloudBuildTimeout: string;
}
/**
 * Docker image that is used to create a container and start a VM instance for
 * the version that you deploy. Only applicable for instances running in the App
 * Engine flexible environment.
 */
export interface Schema$ContainerInfo {
    /**
     * URI to the hosted container image in Google Container Registry. The URI
     * must be fully qualified and include a tag or digest. Examples:
     * "gcr.io/my-project/image:tag" or
     * "gcr.io/my-project/image@digest"
     */
    image: string;
}
/**
 * Target scaling by CPU usage.
 */
export interface Schema$CpuUtilization {
    /**
     * Period of time over which CPU utilization is calculated.
     */
    aggregationWindowLength: string;
    /**
     * Target CPU utilization ratio to maintain when scaling. Must be between 0
     * and 1.
     */
    targetUtilization: number;
}
/**
 * Metadata for the given google.longrunning.Operation during a
 * google.appengine.v1.CreateVersionRequest.
 */
export interface Schema$CreateVersionMetadataV1 {
    /**
     * The Cloud Build ID if one was created as part of the version create.
     * @OutputOnly
     */
    cloudBuildId: string;
}
/**
 * Metadata for the given google.longrunning.Operation during a
 * google.appengine.v1alpha.CreateVersionRequest.
 */
export interface Schema$CreateVersionMetadataV1Alpha {
    /**
     * The Cloud Build ID if one was created as part of the version create.
     * @OutputOnly
     */
    cloudBuildId: string;
}
/**
 * Metadata for the given google.longrunning.Operation during a
 * google.appengine.v1beta.CreateVersionRequest.
 */
export interface Schema$CreateVersionMetadataV1Beta {
    /**
     * The Cloud Build ID if one was created as part of the version create.
     * @OutputOnly
     */
    cloudBuildId: string;
}
/**
 * Allows autoscaling based on Stackdriver metrics.
 */
export interface Schema$CustomMetric {
    /**
     * Allows filtering on the metric's fields.
     */
    filter: string;
    /**
     * The name of the metric.
     */
    metricName: string;
    /**
     * May be used instead of target_utilization when an instance can handle a
     * specific amount of work/resources and the metric value is equal to the
     * current amount of work remaining. The autoscaler will try to keep the
     * number of instances equal to the metric value divided by
     * single_instance_assignment.
     */
    singleInstanceAssignment: number;
    /**
     * The type of the metric. Must be a string representing a Stackdriver metric
     * type e.g. GAGUE, DELTA_PER_SECOND, etc.
     */
    targetType: string;
    /**
     * The target value for the metric.
     */
    targetUtilization: number;
}
/**
 * Request message for Instances.DebugInstance.
 */
export interface Schema$DebugInstanceRequest {
    /**
     * Public SSH key to add to the instance. Examples: [USERNAME]:ssh-rsa
     * [KEY_VALUE] [USERNAME] [USERNAME]:ssh-rsa [KEY_VALUE] google-ssh
     * {"userName":"[USERNAME]","expireOn":"[EXPIRE_TIME]"}For
     * more information, see Adding and Removing SSH Keys
     * (https://cloud.google.com/compute/docs/instances/adding-removing-ssh-keys).
     */
    sshKey: string;
}
/**
 * Code and application artifacts used to deploy a version to App Engine.
 */
export interface Schema$Deployment {
    /**
     * Google Cloud Container Builder build information. Only applicable for
     * instances running in the App Engine flexible environment.
     */
    build: Schema$BuildInfo;
    /**
     * Options for any Google Cloud Container Builder builds created as a part of
     * this deployment.Note that this is orthogonal to the build parameter, where
     * the deployment depends on an already existing cloud build. These options
     * will only be used if a new build is created, such as when deploying to the
     * App Engine flexible environment using files or zip.
     */
    cloudBuildOptions: Schema$CloudBuildOptions;
    /**
     * The Docker image for the container that runs the version. Only applicable
     * for instances running in the App Engine flexible environment.
     */
    container: Schema$ContainerInfo;
    /**
     * Manifest of the files stored in Google Cloud Storage that are included as
     * part of this version. All files must be readable using the credentials
     * supplied with this call.
     */
    files: any;
    /**
     * The zip file for this deployment, if this is a zip deployment.
     */
    zip: Schema$ZipInfo;
}
/**
 * Target scaling by disk usage. Only applicable in the App Engine flexible
 * environment.
 */
export interface Schema$DiskUtilization {
    /**
     * Target bytes read per second.
     */
    targetReadBytesPerSecond: number;
    /**
     * Target ops read per seconds.
     */
    targetReadOpsPerSecond: number;
    /**
     * Target bytes written per second.
     */
    targetWriteBytesPerSecond: number;
    /**
     * Target ops written per second.
     */
    targetWriteOpsPerSecond: number;
}
/**
 * A domain serving an App Engine application.
 */
export interface Schema$DomainMapping {
    /**
     * Relative name of the domain serving the application. Example: example.com.
     */
    id: string;
    /**
     * Full path to the DomainMapping resource in the API. Example:
     * apps/myapp/domainMapping/example.com.@OutputOnly
     */
    name: string;
    /**
     * The resource records required to configure this domain mapping. These
     * records must be added to the domain's DNS configuration in order to
     * serve the application via this domain mapping.@OutputOnly
     */
    resourceRecords: Schema$ResourceRecord[];
    /**
     * SSL configuration for this domain. If unconfigured, this domain will not
     * serve with SSL.
     */
    sslSettings: Schema$SslSettings;
}
/**
 * A generic empty message that you can re-use to avoid defining duplicated
 * empty messages in your APIs. A typical example is to use it as the request or
 * the response type of an API method. For instance: service Foo {   rpc
 * Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON
 * representation for Empty is empty JSON object {}.
 */
export interface Schema$Empty {
}
/**
 * Cloud Endpoints (https://cloud.google.com/endpoints) configuration. The
 * Endpoints API Service provides tooling for serving Open API and gRPC
 * endpoints via an NGINX proxy. Only valid for App Engine Flexible environment
 * deployments.The fields here refer to the name and configuration id of a
 * "service" resource in the Service Management API
 * (https://cloud.google.com/service-management/overview).
 */
export interface Schema$EndpointsApiService {
    /**
     * Endpoints service configuration id as specified by the Service Management
     * API. For example "2016-09-19r1"By default, the Endpoints service
     * configuration id is fixed and config_id must be specified. To keep the
     * Endpoints service configuration id updated with each rollout, specify
     * RolloutStrategy.MANAGED and omit config_id.
     */
    configId: string;
    /**
     * Endpoints service name which is the name of the "service"
     * resource in the Service Management API. For example
     * "myapi.endpoints.myproject.cloud.goog"
     */
    name: string;
    /**
     * Endpoints rollout strategy. If FIXED, config_id must be specified. If
     * MANAGED, config_id must be omitted.
     */
    rolloutStrategy: string;
}
/**
 * Custom static error page to be served when an error occurs.
 */
export interface Schema$ErrorHandler {
    /**
     * Error condition this handler applies to.
     */
    errorCode: string;
    /**
     * MIME type of file. Defaults to text/html.
     */
    mimeType: string;
    /**
     * Static file content to be served for this error.
     */
    staticFile: string;
}
/**
 * The feature specific settings to be used in the application. These define
 * behaviors that are user configurable.
 */
export interface Schema$FeatureSettings {
    /**
     * Boolean value indicating if split health checks should be used instead of
     * the legacy health checks. At an app.yaml level, this means defaulting to
     * 'readiness_check' and 'liveness_check' values instead of
     * 'health_check' ones. Once the legacy 'health_check'
     * behavior is deprecated, and this value is always true, this setting can be
     * removed.
     */
    splitHealthChecks: boolean;
    /**
     * If true, use Container-Optimized OS
     * (https://cloud.google.com/container-optimized-os/) base image for VMs,
     * rather than a base Debian image.
     */
    useContainerOptimizedOs: boolean;
}
/**
 * Single source file that is part of the version to be deployed. Each source
 * file that is deployed must be specified separately.
 */
export interface Schema$FileInfo {
    /**
     * The MIME type of the file.Defaults to the value from Google Cloud Storage.
     */
    mimeType: string;
    /**
     * The SHA1 hash of the file, in hex.
     */
    sha1Sum: string;
    /**
     * URL source to use to fetch this file. Must be a URL to a resource in Google
     * Cloud Storage in the form
     * 'http(s)://storage.googleapis.com/<bucket>/<object>'.
     */
    sourceUrl: string;
}
/**
 * A single firewall rule that is evaluated against incoming traffic and
 * provides an action to take on matched requests.
 */
export interface Schema$FirewallRule {
    /**
     * The action to take on matched requests.
     */
    action: string;
    /**
     * An optional string description of this rule. This field has a maximum
     * length of 100 characters.
     */
    description: string;
    /**
     * A positive integer between 1, Int32.MaxValue-1 that defines the order of
     * rule evaluation. Rules with the lowest priority are evaluated first.A
     * default rule at priority Int32.MaxValue matches all IPv4 and IPv6 traffic
     * when no previous rule matches. Only the action of this rule can be modified
     * by the user.
     */
    priority: number;
    /**
     * IP address or range, defined using CIDR notation, of requests that this
     * rule applies to. You can use the wildcard character "*" to match
     * all IPs equivalent to "0/0" and "::/0" together.
     * Examples: 192.168.1.1 or 192.168.0.0/16 or 2001:db8::/32  or
     * 2001:0db8:0000:0042:0000:8a2e:0370:7334.<p>Truncation will be
     * silently performed on addresses which are not properly truncated. For
     * example, 1.2.3.4/24 is accepted as the same address as 1.2.3.0/24.
     * Similarly, for IPv6, 2001:db8::1/32 is accepted as the same address as
     * 2001:db8::/32.
     */
    sourceRange: string;
}
/**
 * Health checking configuration for VM instances. Unhealthy instances are
 * killed and replaced with new instances. Only applicable for instances in App
 * Engine flexible environment.
 */
export interface Schema$HealthCheck {
    /**
     * Interval between health checks.
     */
    checkInterval: string;
    /**
     * Whether to explicitly disable health checks for this instance.
     */
    disableHealthCheck: boolean;
    /**
     * Number of consecutive successful health checks required before receiving
     * traffic.
     */
    healthyThreshold: number;
    /**
     * Host header to send when performing an HTTP health check. Example:
     * "myapp.appspot.com"
     */
    host: string;
    /**
     * Number of consecutive failed health checks required before an instance is
     * restarted.
     */
    restartThreshold: number;
    /**
     * Time before the health check is considered failed.
     */
    timeout: string;
    /**
     * Number of consecutive failed health checks required before removing
     * traffic.
     */
    unhealthyThreshold: number;
}
/**
 * Identity-Aware Proxy
 */
export interface Schema$IdentityAwareProxy {
    /**
     * Whether the serving infrastructure will authenticate and authorize all
     * incoming requests.If true, the oauth2_client_id and oauth2_client_secret
     * fields must be non-empty.
     */
    enabled: boolean;
    /**
     * OAuth2 client ID to use for the authentication flow.
     */
    oauth2ClientId: string;
    /**
     * OAuth2 client secret to use for the authentication flow.For security
     * reasons, this value cannot be retrieved via the API. Instead, the SHA-256
     * hash of the value is returned in the oauth2_client_secret_sha256
     * field.@InputOnly
     */
    oauth2ClientSecret: string;
    /**
     * Hex-encoded SHA-256 hash of the client secret.@OutputOnly
     */
    oauth2ClientSecretSha256: string;
}
/**
 * An Instance resource is the computing unit that App Engine uses to
 * automatically scale an application.
 */
export interface Schema$Instance {
    /**
     * App Engine release this instance is running on.@OutputOnly
     */
    appEngineRelease: string;
    /**
     * Availability of the instance.@OutputOnly
     */
    availability: string;
    /**
     * Average latency (ms) over the last minute.@OutputOnly
     */
    averageLatency: number;
    /**
     * Number of errors since this instance was started.@OutputOnly
     */
    errors: number;
    /**
     * Relative name of the instance within the version. Example:
     * instance-1.@OutputOnly
     */
    id: string;
    /**
     * Total memory in use (bytes).@OutputOnly
     */
    memoryUsage: string;
    /**
     * Full path to the Instance resource in the API. Example:
     * apps/myapp/services/default/versions/v1/instances/instance-1.@OutputOnly
     */
    name: string;
    /**
     * Average queries per second (QPS) over the last minute.@OutputOnly
     */
    qps: number;
    /**
     * Number of requests since this instance was started.@OutputOnly
     */
    requests: number;
    /**
     * Time that this instance was started.@OutputOnly
     */
    startTime: string;
    /**
     * Whether this instance is in debug mode. Only applicable for instances in
     * App Engine flexible environment.@OutputOnly
     */
    vmDebugEnabled: boolean;
    /**
     * Virtual machine ID of this instance. Only applicable for instances in App
     * Engine flexible environment.@OutputOnly
     */
    vmId: string;
    /**
     * The IP address of this instance. Only applicable for instances in App
     * Engine flexible environment.@OutputOnly
     */
    vmIp: string;
    /**
     * Name of the virtual machine where this instance lives. Only applicable for
     * instances in App Engine flexible environment.@OutputOnly
     */
    vmName: string;
    /**
     * Status of the virtual machine where this instance lives. Only applicable
     * for instances in App Engine flexible environment.@OutputOnly
     */
    vmStatus: string;
    /**
     * Zone where the virtual machine is located. Only applicable for instances in
     * App Engine flexible environment.@OutputOnly
     */
    vmZoneName: string;
}
/**
 * Third-party Python runtime library that is required by the application.
 */
export interface Schema$Library {
    /**
     * Name of the library. Example: "django".
     */
    name: string;
    /**
     * Version of the library to select, or "latest".
     */
    version: string;
}
/**
 * Response message for AuthorizedCertificates.ListAuthorizedCertificates.
 */
export interface Schema$ListAuthorizedCertificatesResponse {
    /**
     * The SSL certificates the user is authorized to administer.
     */
    certificates: Schema$AuthorizedCertificate[];
    /**
     * Continuation token for fetching the next page of results.
     */
    nextPageToken: string;
}
/**
 * Response message for AuthorizedDomains.ListAuthorizedDomains.
 */
export interface Schema$ListAuthorizedDomainsResponse {
    /**
     * The authorized domains belonging to the user.
     */
    domains: Schema$AuthorizedDomain[];
    /**
     * Continuation token for fetching the next page of results.
     */
    nextPageToken: string;
}
/**
 * Response message for DomainMappings.ListDomainMappings.
 */
export interface Schema$ListDomainMappingsResponse {
    /**
     * The domain mappings for the application.
     */
    domainMappings: Schema$DomainMapping[];
    /**
     * Continuation token for fetching the next page of results.
     */
    nextPageToken: string;
}
/**
 * Response message for Firewall.ListIngressRules.
 */
export interface Schema$ListIngressRulesResponse {
    /**
     * The ingress FirewallRules for this application.
     */
    ingressRules: Schema$FirewallRule[];
    /**
     * Continuation token for fetching the next page of results.
     */
    nextPageToken: string;
}
/**
 * Response message for Instances.ListInstances.
 */
export interface Schema$ListInstancesResponse {
    /**
     * The instances belonging to the requested version.
     */
    instances: Schema$Instance[];
    /**
     * Continuation token for fetching the next page of results.
     */
    nextPageToken: string;
}
/**
 * The response message for Locations.ListLocations.
 */
export interface Schema$ListLocationsResponse {
    /**
     * A list of locations that matches the specified filter in the request.
     */
    locations: Schema$Location[];
    /**
     * The standard List next-page token.
     */
    nextPageToken: string;
}
/**
 * The response message for Operations.ListOperations.
 */
export interface Schema$ListOperationsResponse {
    /**
     * The standard List next-page token.
     */
    nextPageToken: string;
    /**
     * A list of operations that matches the specified filter in the request.
     */
    operations: Schema$Operation[];
}
/**
 * Response message for Services.ListServices.
 */
export interface Schema$ListServicesResponse {
    /**
     * Continuation token for fetching the next page of results.
     */
    nextPageToken: string;
    /**
     * The services belonging to the requested application.
     */
    services: Schema$Service[];
}
/**
 * Response message for Versions.ListVersions.
 */
export interface Schema$ListVersionsResponse {
    /**
     * Continuation token for fetching the next page of results.
     */
    nextPageToken: string;
    /**
     * The versions belonging to the requested service.
     */
    versions: Schema$Version[];
}
/**
 * Health checking configuration for VM instances. Unhealthy instances are
 * killed and replaced with new instances.
 */
export interface Schema$LivenessCheck {
    /**
     * Interval between health checks.
     */
    checkInterval: string;
    /**
     * Number of consecutive failed checks required before considering the VM
     * unhealthy.
     */
    failureThreshold: number;
    /**
     * Host header to send when performing a HTTP Liveness check. Example:
     * "myapp.appspot.com"
     */
    host: string;
    /**
     * The initial delay before starting to execute the checks.
     */
    initialDelay: string;
    /**
     * The request path.
     */
    path: string;
    /**
     * Number of consecutive successful checks required before considering the VM
     * healthy.
     */
    successThreshold: number;
    /**
     * Time before the check is considered failed.
     */
    timeout: string;
}
/**
 * A resource that represents Google Cloud Platform location.
 */
export interface Schema$Location {
    /**
     * The friendly name for this location, typically a nearby city name. For
     * example, "Tokyo".
     */
    displayName: string;
    /**
     * Cross-service attributes for the location. For example
     * {"cloud.googleapis.com/region": "us-east1"}
     */
    labels: any;
    /**
     * The canonical id for this location. For example: "us-east1".
     */
    locationId: string;
    /**
     * Service-specific metadata. For example the available capacity at the given
     * location.
     */
    metadata: any;
    /**
     * Resource name for the location, which may vary between implementations. For
     * example: "projects/example-project/locations/us-east1"
     */
    name: string;
}
/**
 * Metadata for the given google.cloud.location.Location.
 */
export interface Schema$LocationMetadata {
    /**
     * App Engine flexible environment is available in the given
     * location.@OutputOnly
     */
    flexibleEnvironmentAvailable: boolean;
    /**
     * App Engine standard environment is available in the given
     * location.@OutputOnly
     */
    standardEnvironmentAvailable: boolean;
}
/**
 * A certificate managed by App Engine.
 */
export interface Schema$ManagedCertificate {
    /**
     * Time at which the certificate was last renewed. The renewal process is
     * fully managed. Certificate renewal will automatically occur before the
     * certificate expires. Renewal errors can be tracked via
     * ManagementStatus.@OutputOnly
     */
    lastRenewalTime: string;
    /**
     * Status of certificate management. Refers to the most recent certificate
     * acquisition or renewal attempt.@OutputOnly
     */
    status: string;
}
/**
 * A service with manual scaling runs continuously, allowing you to perform
 * complex initialization and rely on the state of its memory over time.
 */
export interface Schema$ManualScaling {
    /**
     * Number of instances to assign to the service at the start. This number can
     * later be altered by using the Modules API
     * (https://cloud.google.com/appengine/docs/python/modules/functions)
     * set_num_instances() function.
     */
    instances: number;
}
/**
 * Extra network settings. Only applicable in the App Engine flexible
 * environment.
 */
export interface Schema$Network {
    /**
     * List of ports, or port pairs, to forward from the virtual machine to the
     * application container. Only applicable in the App Engine flexible
     * environment.
     */
    forwardedPorts: string[];
    /**
     * Tag to apply to the instance during creation. Only applicable in the App
     * Engine flexible environment.
     */
    instanceTag: string;
    /**
     * Google Compute Engine network where the virtual machines are created.
     * Specify the short name, not the resource path.Defaults to default.
     */
    name: string;
    /**
     * Enable session affinity.
     */
    sessionAffinity: boolean;
    /**
     * Google Cloud Platform sub-network where the virtual machines are created.
     * Specify the short name, not the resource path.If a subnetwork name is
     * specified, a network name will also be required unless it is for the
     * default network. If the network that the instance is being created in is a
     * Legacy network, then the IP address is allocated from the IPv4Range. If the
     * network that the instance is being created in is an auto Subnet Mode
     * Network, then only network name should be specified (not the
     * subnetwork_name) and the IP address is created from the IPCidrRange of the
     * subnetwork that exists in that zone for that network. If the network that
     * the instance is being created in is a custom Subnet Mode Network, then the
     * subnetwork_name must be specified and the IP address is created from the
     * IPCidrRange of the subnetwork.If specified, the subnetwork must exist in
     * the same region as the App Engine flexible environment application.
     */
    subnetworkName: string;
}
/**
 * Target scaling by network usage. Only applicable in the App Engine flexible
 * environment.
 */
export interface Schema$NetworkUtilization {
    /**
     * Target bytes received per second.
     */
    targetReceivedBytesPerSecond: number;
    /**
     * Target packets received per second.
     */
    targetReceivedPacketsPerSecond: number;
    /**
     * Target bytes sent per second.
     */
    targetSentBytesPerSecond: number;
    /**
     * Target packets sent per second.
     */
    targetSentPacketsPerSecond: number;
}
/**
 * This resource represents a long-running operation that is the result of a
 * network API call.
 */
export interface Schema$Operation {
    /**
     * If the value is false, it means the operation is still in progress. If
     * true, the operation is completed, and either error or response is
     * available.
     */
    done: boolean;
    /**
     * The error result of the operation in case of failure or cancellation.
     */
    error: Schema$Status;
    /**
     * Service-specific metadata associated with the operation. It typically
     * contains progress information and common metadata such as create time. Some
     * services might not provide such metadata. Any method that returns a
     * long-running operation should document the metadata type, if any.
     */
    metadata: any;
    /**
     * The server-assigned name, which is only unique within the same service that
     * originally returns it. If you use the default HTTP mapping, the name should
     * have the format of operations/some/unique/name.
     */
    name: string;
    /**
     * The normal response of the operation in case of success. If the original
     * method returns no data on success, such as Delete, the response is
     * google.protobuf.Empty. If the original method is standard
     * Get/Create/Update, the response should be the resource. For other methods,
     * the response should have the type XxxResponse, where Xxx is the original
     * method name. For example, if the original method name is TakeSnapshot(),
     * the inferred response type is TakeSnapshotResponse.
     */
    response: any;
}
/**
 * Metadata for the given google.longrunning.Operation.
 */
export interface Schema$OperationMetadata {
    /**
     * Timestamp that this operation completed.@OutputOnly
     */
    endTime: string;
    /**
     * Timestamp that this operation was created.@OutputOnly
     */
    insertTime: string;
    /**
     * API method that initiated this operation. Example:
     * google.appengine.v1beta4.Version.CreateVersion.@OutputOnly
     */
    method: string;
    /**
     * Type of this operation. Deprecated, use method field instead. Example:
     * "create_version".@OutputOnly
     */
    operationType: string;
    /**
     * Name of the resource that this operation is acting on. Example:
     * apps/myapp/modules/default.@OutputOnly
     */
    target: string;
    /**
     * User who requested this operation.@OutputOnly
     */
    user: string;
}
/**
 * Metadata for the given google.longrunning.Operation.
 */
export interface Schema$OperationMetadataV1 {
    createVersionMetadata: Schema$CreateVersionMetadataV1;
    /**
     * Time that this operation completed.@OutputOnly
     */
    endTime: string;
    /**
     * Ephemeral message that may change every time the operation is polled.
     * @OutputOnly
     */
    ephemeralMessage: string;
    /**
     * Time that this operation was created.@OutputOnly
     */
    insertTime: string;
    /**
     * API method that initiated this operation. Example:
     * google.appengine.v1.Versions.CreateVersion.@OutputOnly
     */
    method: string;
    /**
     * Name of the resource that this operation is acting on. Example:
     * apps/myapp/services/default.@OutputOnly
     */
    target: string;
    /**
     * User who requested this operation.@OutputOnly
     */
    user: string;
    /**
     * Durable messages that persist on every operation poll. @OutputOnly
     */
    warning: string[];
}
/**
 * Metadata for the given google.longrunning.Operation.
 */
export interface Schema$OperationMetadataV1Alpha {
    createVersionMetadata: Schema$CreateVersionMetadataV1Alpha;
    /**
     * Time that this operation completed.@OutputOnly
     */
    endTime: string;
    /**
     * Ephemeral message that may change every time the operation is polled.
     * @OutputOnly
     */
    ephemeralMessage: string;
    /**
     * Time that this operation was created.@OutputOnly
     */
    insertTime: string;
    /**
     * API method that initiated this operation. Example:
     * google.appengine.v1alpha.Versions.CreateVersion.@OutputOnly
     */
    method: string;
    /**
     * Name of the resource that this operation is acting on. Example:
     * apps/myapp/services/default.@OutputOnly
     */
    target: string;
    /**
     * User who requested this operation.@OutputOnly
     */
    user: string;
    /**
     * Durable messages that persist on every operation poll. @OutputOnly
     */
    warning: string[];
}
/**
 * Metadata for the given google.longrunning.Operation.
 */
export interface Schema$OperationMetadataV1Beta {
    createVersionMetadata: Schema$CreateVersionMetadataV1Beta;
    /**
     * Time that this operation completed.@OutputOnly
     */
    endTime: string;
    /**
     * Ephemeral message that may change every time the operation is polled.
     * @OutputOnly
     */
    ephemeralMessage: string;
    /**
     * Time that this operation was created.@OutputOnly
     */
    insertTime: string;
    /**
     * API method that initiated this operation. Example:
     * google.appengine.v1beta.Versions.CreateVersion.@OutputOnly
     */
    method: string;
    /**
     * Name of the resource that this operation is acting on. Example:
     * apps/myapp/services/default.@OutputOnly
     */
    target: string;
    /**
     * User who requested this operation.@OutputOnly
     */
    user: string;
    /**
     * Durable messages that persist on every operation poll. @OutputOnly
     */
    warning: string[];
}
/**
 * Metadata for the given google.longrunning.Operation.
 */
export interface Schema$OperationMetadataV1Beta5 {
    /**
     * Timestamp that this operation completed.@OutputOnly
     */
    endTime: string;
    /**
     * Timestamp that this operation was created.@OutputOnly
     */
    insertTime: string;
    /**
     * API method name that initiated this operation. Example:
     * google.appengine.v1beta5.Version.CreateVersion.@OutputOnly
     */
    method: string;
    /**
     * Name of the resource that this operation is acting on. Example:
     * apps/myapp/services/default.@OutputOnly
     */
    target: string;
    /**
     * User who requested this operation.@OutputOnly
     */
    user: string;
}
/**
 * Readiness checking configuration for VM instances. Unhealthy instances are
 * removed from traffic rotation.
 */
export interface Schema$ReadinessCheck {
    /**
     * A maximum time limit on application initialization, measured from moment
     * the application successfully replies to a healthcheck until it is ready to
     * serve traffic.
     */
    appStartTimeout: string;
    /**
     * Interval between health checks.
     */
    checkInterval: string;
    /**
     * Number of consecutive failed checks required before removing traffic.
     */
    failureThreshold: number;
    /**
     * Host header to send when performing a HTTP Readiness check. Example:
     * "myapp.appspot.com"
     */
    host: string;
    /**
     * The request path.
     */
    path: string;
    /**
     * Number of consecutive successful checks required before receiving traffic.
     */
    successThreshold: number;
    /**
     * Time before the check is considered failed.
     */
    timeout: string;
}
/**
 * Request message for 'Applications.RepairApplication'.
 */
export interface Schema$RepairApplicationRequest {
}
/**
 * Target scaling by request utilization. Only applicable in the App Engine
 * flexible environment.
 */
export interface Schema$RequestUtilization {
    /**
     * Target number of concurrent requests.
     */
    targetConcurrentRequests: number;
    /**
     * Target requests per second.
     */
    targetRequestCountPerSecond: number;
}
/**
 * A DNS resource record.
 */
export interface Schema$ResourceRecord {
    /**
     * Relative name of the object affected by this record. Only applicable for
     * CNAME records. Example: 'www'.
     */
    name: string;
    /**
     * Data for this record. Values vary by record type, as defined in RFC 1035
     * (section 5) and RFC 1034 (section 3.6.1).
     */
    rrdata: string;
    /**
     * Resource record type. Example: AAAA.
     */
    type: string;
}
/**
 * Machine resources for a version.
 */
export interface Schema$Resources {
    /**
     * Number of CPU cores needed.
     */
    cpu: number;
    /**
     * Disk size (GB) needed.
     */
    diskGb: number;
    /**
     * Memory (GB) needed.
     */
    memoryGb: number;
    /**
     * User specified volumes.
     */
    volumes: Schema$Volume[];
}
/**
 * Executes a script to handle the request that matches the URL pattern.
 */
export interface Schema$ScriptHandler {
    /**
     * Path to the script from the application root directory.
     */
    scriptPath: string;
}
/**
 * A Service resource is a logical component of an application that can share
 * state and communicate in a secure fashion with other services. For example,
 * an application that handles customer requests might include separate services
 * to handle tasks such as backend data analysis or API requests from mobile
 * devices. Each service has a collection of versions that define a specific set
 * of code used to implement the functionality of that service.
 */
export interface Schema$Service {
    /**
     * Relative name of the service within the application. Example:
     * default.@OutputOnly
     */
    id: string;
    /**
     * Full path to the Service resource in the API. Example:
     * apps/myapp/services/default.@OutputOnly
     */
    name: string;
    /**
     * Mapping that defines fractional HTTP traffic diversion to different
     * versions within the service.
     */
    split: Schema$TrafficSplit;
}
/**
 * SSL configuration for a DomainMapping resource.
 */
export interface Schema$SslSettings {
    /**
     * ID of the AuthorizedCertificate resource configuring SSL for the
     * application. Clearing this field will remove SSL support.By default, a
     * managed certificate is automatically created for every domain mapping. To
     * omit SSL support or to configure SSL manually, specify
     * SslManagementType.MANUAL on a CREATE or UPDATE request. You must be
     * authorized to administer the AuthorizedCertificate resource to manually map
     * it to a DomainMapping resource. Example: 12345.
     */
    certificateId: string;
    /**
     * ID of the managed AuthorizedCertificate resource currently being
     * provisioned, if applicable. Until the new managed certificate has been
     * successfully provisioned, the previous SSL state will be preserved. Once
     * the provisioning process completes, the certificate_id field will reflect
     * the new managed certificate and this field will be left empty. To remove
     * SSL support while there is still a pending managed certificate, clear the
     * certificate_id field with an UpdateDomainMappingRequest.@OutputOnly
     */
    pendingManagedCertificateId: string;
    /**
     * SSL management type for this domain. If AUTOMATIC, a managed certificate is
     * automatically provisioned. If MANUAL, certificate_id must be manually
     * specified in order to configure SSL for this domain.
     */
    sslManagementType: string;
}
/**
 * Scheduler settings for standard environment.
 */
export interface Schema$StandardSchedulerSettings {
    /**
     * Maximum number of instances to run for this version. Set to zero to disable
     * max_instances configuration.
     */
    maxInstances: number;
    /**
     * Minimum number of instances to run for this version. Set to zero to disable
     * min_instances configuration.
     */
    minInstances: number;
    /**
     * Target CPU utilization ratio to maintain when scaling.
     */
    targetCpuUtilization: number;
    /**
     * Target throughput utilization ratio to maintain when scaling
     */
    targetThroughputUtilization: number;
}
/**
 * Files served directly to the user for a given URL, such as images, CSS
 * stylesheets, or JavaScript source files. Static file handlers describe which
 * files in the application directory are static files, and which URLs serve
 * them.
 */
export interface Schema$StaticFilesHandler {
    /**
     * Whether files should also be uploaded as code data. By default, files
     * declared in static file handlers are uploaded as static data and are only
     * served to end users; they cannot be read by the application. If enabled,
     * uploads are charged against both your code and static data storage resource
     * quotas.
     */
    applicationReadable: boolean;
    /**
     * Time a static file served by this handler should be cached by web proxies
     * and browsers.
     */
    expiration: string;
    /**
     * HTTP headers to use for all responses from these URLs.