googleapis

/** * 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'; /** * Google Cloud Runtime Configuration API * * The Runtime Configurator allows you to dynamically configure and expose * variables through Google Cloud Platform. In addition, you can also set * Watchers and Waiters that will watch for changes to your data and return * based on certain conditions. * * @example * const google = require('googleapis'); * const runtimeconfig = google.runtimeconfig('v1'); * * @namespace runtimeconfig * @type {Function} * @version v1 * @variation v1 * @param {object=} options Options for Runtimeconfig */ export declare class Runtimeconfig { _options: GlobalOptions; google: GoogleApis; root: this; operations: Resource$Operations; constructor(options: GlobalOptions, google: GoogleApis); getRoot(): this; } /** * The request message for Operations.CancelOperation. */ export interface Schema$CancelOperationRequest { } /** * 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 { } /** * 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[]; } /** * 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; } /** * The `Status` type defines a logical error model that is suitable for * different programming environments, including REST APIs and RPC APIs. It is * used by [gRPC](https://github.com/grpc). The error model is designed to be: * - Simple to use and understand for most users - Flexible enough to meet * unexpected needs # Overview The `Status` message contains three pieces of * data: error code, error message, and error details. The error code should be * an enum value of google.rpc.Code, but it may accept additional error codes if * needed. The error message should be a developer-facing English message that * helps developers *understand* and *resolve* the error. If a localized * user-facing error message is needed, put the localized message in the error * details or localize it in the client. The optional error details may contain * arbitrary information about the error. There is a predefined set of error * detail types in the package `google.rpc` that can be used for common error * conditions. # Language mapping The `Status` message is the logical * representation of the error model, but it is not necessarily the actual wire * format. When the `Status` message is exposed in different client libraries * and different wire protocols, it can be mapped differently. For example, it * will likely be mapped to some exceptions in Java, but more likely mapped to * some error codes in C. # Other uses The error model and the `Status` * message can be used in a variety of environments, either with or without * APIs, to provide a consistent developer experience across different * environments. Example uses of this error model include: - Partial errors. * If a service needs to return partial errors to the client, it may embed * the `Status` in the normal response to indicate the partial errors. - * Workflow errors. A typical workflow has multiple steps. Each step may have a * `Status` message for error reporting. - Batch operations. If a client uses * batch request and batch response, the `Status` message should be used * directly inside batch response, one for each error sub-response. - * Asynchronous operations. If an API call embeds asynchronous operation results * in its response, the status of those operations should be represented * directly using the `Status` message. - Logging. If some API errors are * stored in logs, the message `Status` could be used directly after any * stripping needed for security/privacy reasons. */ export interface Schema$Status { /** * The status code, which should be an enum value of google.rpc.Code. */ code: number; /** * A list of messages that carry the error details. There is a common set of * message types for APIs to use. */ details: any[]; /** * A developer-facing error message, which should be in English. Any * user-facing error message should be localized and sent in the * google.rpc.Status.details field, or localized by the client. */ message: string; } export declare class Resource$Operations { root: Runtimeconfig; constructor(root: Runtimeconfig); getRoot(): Runtimeconfig; /** * runtimeconfig.operations.cancel * @desc Starts asynchronous cancellation on a long-running operation. The * server makes a best effort to cancel the operation, but success is not * guaranteed. If the server doesn't support this method, it returns * `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation * or other methods to check whether the cancellation succeeded or whether the * operation completed despite cancellation. On successful cancellation, the * operation is not deleted; instead, it becomes an operation with an * Operation.error value with a google.rpc.Status.code of 1, corresponding to * `Code.CANCELLED`. * @alias runtimeconfig.operations.cancel * @memberOf! () * * @param {object} params Parameters for request * @param {string} params.name The name of the operation resource to be cancelled. * @param {().CancelOperationRequest} params.resource Request body data * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`. * @param {callback} callback The callback that handles the response. * @return {object} Request object */ cancel(params?: any, options?: MethodOptions): AxiosPromise<Schema$Empty>; cancel(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Empty>, callback?: BodyResponseCallback<Schema$Empty>): void; /** * runtimeconfig.operations.delete * @desc Deletes a long-running operation. This method indicates that the * client is no longer interested in the operation result. It does not cancel * the operation. If the server doesn't support this method, it returns * `google.rpc.Code.UNIMPLEMENTED`. * @alias runtimeconfig.operations.delete * @memberOf! () * * @param {object} params Parameters for request * @param {string} params.name The name of the operation resource to be deleted. * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`. * @param {callback} callback The callback that handles the response. * @return {object} Request object */ delete(params?: any, options?: MethodOptions): AxiosPromise<Schema$Empty>; delete(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Empty>, callback?: BodyResponseCallback<Schema$Empty>): void; /** * runtimeconfig.operations.list * @desc Lists operations that match the specified filter in the request. If * the server doesn't support this method, it returns `UNIMPLEMENTED`. NOTE: * the `name` binding allows API services to override the binding to use * different resource name schemes, such as `users/x/operations`. To override * the binding, API services can add a binding such as * `"/v1/{name=users/x}/operations"` to their service configuration. For * backwards compatibility, the default name includes the operations * collection id, however overriding users must ensure the name binding is the * parent resource, without the operations collection id. * @alias runtimeconfig.operations.list * @memberOf! () * * @param {object} params Parameters for request * @param {string=} params.filter The standard list filter. * @param {string} params.name The name of the operation's parent resource. * @param {integer=} params.pageSize The standard list page size. * @param {string=} params.pageToken The standard list page token. * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`. * @param {callback} callback The callback that handles the response. * @return {object} Request object */ list(params?: any, options?: MethodOptions): AxiosPromise<Schema$ListOperationsResponse>; list(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$ListOperationsResponse>, callback?: BodyResponseCallback<Schema$ListOperationsResponse>): void; }