googleapis
Version:
Google APIs Client Library for Node.js
1,204 lines • 52.6 kB
TypeScript
/**
* 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 Service Control API
*
* Google Service Control provides control plane functionality to managed
* services, such as logging, monitoring, and status checks.
*
* @example
* const google = require('googleapis');
* const servicecontrol = google.servicecontrol('v1');
*
* @namespace servicecontrol
* @type {Function}
* @version v1
* @variation v1
* @param {object=} options Options for Servicecontrol
*/
export declare class Servicecontrol {
_options: GlobalOptions;
google: GoogleApis;
root: this;
services: Resource$Services;
constructor(options: GlobalOptions, google: GoogleApis);
getRoot(): this;
}
export interface Schema$AllocateInfo {
/**
* A list of label keys that were unused by the server in processing the
* request. Thus, for similar requests repeated in a certain future time
* window, the caller can choose to ignore these labels in the requests to
* achieve better client-side cache hits and quota aggregation.
*/
unusedArguments: string[];
}
/**
* Request message for the AllocateQuota method.
*/
export interface Schema$AllocateQuotaRequest {
/**
* Operation that describes the quota allocation.
*/
allocateOperation: Schema$QuotaOperation;
/**
* Specifies which version of service configuration should be used to process
* the request. If unspecified or no matching version can be found, the latest
* one will be used.
*/
serviceConfigId: string;
}
/**
* Response message for the AllocateQuota method.
*/
export interface Schema$AllocateQuotaResponse {
/**
* Indicates the decision of the allocate.
*/
allocateErrors: Schema$QuotaError[];
/**
* WARNING: DO NOT use this field until this warning message is removed.
*/
allocateInfo: Schema$AllocateInfo;
/**
* The same operation_id value used in the AllocateQuotaRequest. Used for
* logging and diagnostics purposes.
*/
operationId: string;
/**
* Quota metrics to indicate the result of allocation. Depending on the
* request, one or more of the following metrics will be included: 1. Per
* quota group or per quota metric incremental usage will be specified using
* the following delta metric :
* "serviceruntime.googleapis.com/api/consumer/quota_used_count" 2.
* The quota limit reached condition will be specified using the following
* boolean metric : "serviceruntime.googleapis.com/quota/exceeded"
*/
quotaMetrics: Schema$MetricValueSet[];
/**
* ID of the actual config used to process the request.
*/
serviceConfigId: string;
}
/**
* Common audit log format for Google Cloud Platform API operations.
*/
export interface Schema$AuditLog {
/**
* Authentication information.
*/
authenticationInfo: Schema$AuthenticationInfo;
/**
* Authorization information. If there are multiple resources or permissions
* involved, then there is one AuthorizationInfo element for each {resource,
* permission} tuple.
*/
authorizationInfo: Schema$AuthorizationInfo[];
/**
* Other service-specific data about the request, response, and other
* information associated with the current audited event.
*/
metadata: any;
/**
* The name of the service method or operation. For API calls, this should be
* the name of the API method. For example,
* "google.datastore.v1.Datastore.RunQuery"
* "google.logging.v1.LoggingService.DeleteLog"
*/
methodName: string;
/**
* The number of items returned from a List or Query API method, if
* applicable.
*/
numResponseItems: string;
/**
* The operation request. This may not include all request parameters, such as
* those that are too large, privacy-sensitive, or duplicated elsewhere in the
* log record. It should never include user-generated data, such as file
* contents. When the JSON object represented here has a proto equivalent, the
* proto name will be indicated in the `@type` property.
*/
request: any;
/**
* Metadata about the operation.
*/
requestMetadata: Schema$RequestMetadata;
/**
* The resource or collection that is the target of the operation. The name is
* a scheme-less URI, not including the API service name. For example:
* "shelves/SHELF_ID/books"
* "shelves/SHELF_ID/books/BOOK_ID"
*/
resourceName: string;
/**
* The operation response. This may not include all response elements, such as
* those that are too large, privacy-sensitive, or duplicated elsewhere in the
* log record. It should never include user-generated data, such as file
* contents. When the JSON object represented here has a proto equivalent, the
* proto name will be indicated in the `@type` property.
*/
response: any;
/**
* Deprecated, use `metadata` field instead. Other service-specific data about
* the request, response, and other activities.
*/
serviceData: any;
/**
* The name of the API service performing the operation. For example,
* `"datastore.googleapis.com"`.
*/
serviceName: string;
/**
* The status of the overall operation.
*/
status: Schema$Status;
}
/**
* Authentication information for the operation.
*/
export interface Schema$AuthenticationInfo {
/**
* The authority selector specified by the requestor, if any. It is not
* guaranteed that the principal was allowed to use this authority.
*/
authoritySelector: string;
/**
* The email address of the authenticated user (or service account on behalf
* of third party principal) making the request. For privacy reasons, the
* principal email address is redacted for all read-only operations that fail
* with a "permission denied" error.
*/
principalEmail: string;
/**
* The third party identification (if any) of the authenticated user making
* the request. When the JSON object represented here has a proto equivalent,
* the proto name will be indicated in the `@type` property.
*/
thirdPartyPrincipal: any;
}
/**
* Authorization information for the operation.
*/
export interface Schema$AuthorizationInfo {
/**
* Whether or not authorization for `resource` and `permission` was granted.
*/
granted: boolean;
/**
* The required IAM permission.
*/
permission: string;
/**
* The resource being accessed, as a REST-style string. For example:
* bigquery.googleapis.com/projects/PROJECTID/datasets/DATASETID
*/
resource: string;
}
/**
* Defines the errors to be returned in
* google.api.servicecontrol.v1.CheckResponse.check_errors.
*/
export interface Schema$CheckError {
/**
* The error code.
*/
code: string;
/**
* Free-form text providing details on the error cause of the error.
*/
detail: string;
/**
* Subject to whom this error applies. See the specific code enum for more
* details on this field. For example: - “project:<project-id or
* project-number>” - “folder:<folder-id>” -
* “organization:<organization-id>”
*/
subject: string;
}
/**
* Contains additional information about the check operation.
*/
export interface Schema$CheckInfo {
/**
* Consumer info of this check.
*/
consumerInfo: Schema$ConsumerInfo;
/**
* A list of fields and label keys that are ignored by the server. The client
* doesn't need to send them for following requests to improve performance
* and allow better aggregation.
*/
unusedArguments: string[];
}
/**
* Request message for the Check method.
*/
export interface Schema$CheckRequest {
/**
* The operation to be checked.
*/
operation: Schema$Operation;
/**
* Requests the project settings to be returned as part of the check response.
*/
requestProjectSettings: boolean;
/**
* Specifies which version of service configuration should be used to process
* the request. If unspecified or no matching version can be found, the
* latest one will be used.
*/
serviceConfigId: string;
/**
* Indicates if service activation check should be skipped for this request.
* Default behavior is to perform the check and apply relevant quota.
*/
skipActivationCheck: boolean;
}
/**
* Response message for the Check method.
*/
export interface Schema$CheckResponse {
/**
* Indicate the decision of the check. If no check errors are present, the
* service should process the operation. Otherwise the service should use the
* list of errors to determine the appropriate action.
*/
checkErrors: Schema$CheckError[];
/**
* Feedback data returned from the server during processing a Check request.
*/
checkInfo: Schema$CheckInfo;
/**
* The same operation_id value used in the CheckRequest. Used for logging and
* diagnostics purposes.
*/
operationId: string;
/**
* Quota information for the check request associated with this response.
*/
quotaInfo: Schema$QuotaInfo;
/**
* The actual config id used to process the request.
*/
serviceConfigId: string;
}
/**
* `ConsumerInfo` provides information about the consumer project.
*/
export interface Schema$ConsumerInfo {
/**
* The Google cloud project number, e.g. 1234567890. A value of 0 indicates no
* project number is found.
*/
projectNumber: string;
}
/**
* Distribution represents a frequency distribution of double-valued sample
* points. It contains the size of the population of sample points plus
* additional optional information: - the arithmetic mean of the samples -
* the minimum and maximum of the samples - the sum-squared-deviation of the
* samples, used to compute variance - a histogram of the values of the sample
* points
*/
export interface Schema$Distribution {
/**
* The number of samples in each histogram bucket. `bucket_counts` are
* optional. If present, they must sum to the `count` value. The buckets are
* defined below in `bucket_option`. There are N buckets. `bucket_counts[0]`
* is the number of samples in the underflow bucket. `bucket_counts[1]` to
* `bucket_counts[N-1]` are the numbers of samples in each of the finite
* buckets. And `bucket_counts[N] is the number of samples in the overflow
* bucket. See the comments of `bucket_option` below for more details. Any
* suffix of trailing zeros may be omitted.
*/
bucketCounts: string[];
/**
* The total number of samples in the distribution. Must be >= 0.
*/
count: string;
/**
* Buckets with arbitrary user-provided width.
*/
explicitBuckets: Schema$ExplicitBuckets;
/**
* Buckets with exponentially growing width.
*/
exponentialBuckets: Schema$ExponentialBuckets;
/**
* Buckets with constant width.
*/
linearBuckets: Schema$LinearBuckets;
/**
* The maximum of the population of values. Ignored if `count` is zero.
*/
maximum: number;
/**
* The arithmetic mean of the samples in the distribution. If `count` is zero
* then this field must be zero.
*/
mean: number;
/**
* The minimum of the population of values. Ignored if `count` is zero.
*/
minimum: number;
/**
* The sum of squared deviations from the mean: Sum[i=1..count]((x_i -
* mean)^2) where each x_i is a sample values. If `count` is zero then this
* field must be zero, otherwise validation of the request fails.
*/
sumOfSquaredDeviation: number;
}
/**
* Request message for QuotaController.EndReconciliation.
*/
export interface Schema$EndReconciliationRequest {
/**
* Operation that describes the quota reconciliation.
*/
reconciliationOperation: Schema$QuotaOperation;
/**
* Specifies which version of service configuration should be used to process
* the request. If unspecified or no matching version can be found, the latest
* one will be used.
*/
serviceConfigId: string;
}
/**
* Response message for QuotaController.EndReconciliation.
*/
export interface Schema$EndReconciliationResponse {
/**
* The same operation_id value used in the EndReconciliationRequest. Used for
* logging and diagnostics purposes.
*/
operationId: string;
/**
* Metric values as tracked by One Platform before the adjustment was made.
* The following metrics will be included: 1. Per quota metric total usage
* will be specified using the following gauge metric:
* "serviceruntime.googleapis.com/allocation/consumer/quota_used_count"
* 2. Value for each quota limit associated with the metrics will be specified
* using the following gauge metric:
* "serviceruntime.googleapis.com/quota/limit" 3. Delta value of
* the usage after the reconciliation for limits associated with the metrics
* will be specified using the following metric:
* "serviceruntime.googleapis.com/allocation/reconciliation_delta"
* The delta value is defined as: new_usage_from_client -
* existing_value_in_spanner. This metric is not defined in
* serviceruntime.yaml or in Cloud Monarch. This metric is meant for
* callers' use only. Since this metric is not defined in the monitoring
* backend, reporting on this metric will result in an error.
*/
quotaMetrics: Schema$MetricValueSet[];
/**
* Indicates the decision of the reconciliation end.
*/
reconciliationErrors: Schema$QuotaError[];
/**
* ID of the actual config used to process the request.
*/
serviceConfigId: string;
}
/**
* Describing buckets with arbitrary user-provided width.
*/
export interface Schema$ExplicitBuckets {
/**
* 'bound' is a list of strictly increasing boundaries between
* buckets. Note that a list of length N-1 defines N buckets because of
* fenceposting. See comments on `bucket_options` for details. The i'th
* finite bucket covers the interval [bound[i-1], bound[i]) where i ranges
* from 1 to bound_size() - 1. Note that there are no finite buckets at all if
* 'bound' only contains a single element; in that special case the
* single bound defines the boundary between the underflow and overflow
* buckets. bucket number lower bound upper bound i ==
* 0 (underflow) -inf bound[i] 0 < i <
* bound_size() bound[i-1] bound[i] i == bound_size()
* (overflow) bound[i-1] +inf
*/
bounds: number[];
}
/**
* Describing buckets with exponentially growing width.
*/
export interface Schema$ExponentialBuckets {
/**
* The i'th exponential bucket covers the interval [scale *
* growth_factor^(i-1), scale * growth_factor^i) where i ranges from 1 to
* num_finite_buckets inclusive. Must be larger than 1.0.
*/
growthFactor: number;
/**
* The number of finite buckets. With the underflow and overflow buckets, the
* total number of buckets is `num_finite_buckets` + 2. See comments on
* `bucket_options` for details.
*/
numFiniteBuckets: number;
/**
* The i'th exponential bucket covers the interval [scale *
* growth_factor^(i-1), scale * growth_factor^i) where i ranges from 1 to
* num_finite_buckets inclusive. Must be > 0.
*/
scale: number;
}
/**
* Describing buckets with constant width.
*/
export interface Schema$LinearBuckets {
/**
* The number of finite buckets. With the underflow and overflow buckets, the
* total number of buckets is `num_finite_buckets` + 2. See comments on
* `bucket_options` for details.
*/
numFiniteBuckets: number;
/**
* The i'th linear bucket covers the interval [offset + (i-1) * width,
* offset + i * width) where i ranges from 1 to num_finite_buckets, inclusive.
*/
offset: number;
/**
* The i'th linear bucket covers the interval [offset + (i-1) * width,
* offset + i * width) where i ranges from 1 to num_finite_buckets, inclusive.
* Must be strictly positive.
*/
width: number;
}
/**
* An individual log entry.
*/
export interface Schema$LogEntry {
/**
* A unique ID for the log entry used for deduplication. If omitted, the
* implementation will generate one based on operation_id.
*/
insertId: string;
/**
* A set of user-defined (key, value) data that provides additional
* information about the log entry.
*/
labels: any;
/**
* Required. The log to which this log entry belongs. Examples:
* `"syslog"`, `"book_log"`.
*/
name: string;
/**
* The log entry payload, represented as a protocol buffer that is expressed
* as a JSON object. The only accepted type currently is AuditLog.
*/
protoPayload: any;
/**
* The severity of the log entry. The default value is `LogSeverity.DEFAULT`.
*/
severity: string;
/**
* The log entry payload, represented as a structure that is expressed as a
* JSON object.
*/
structPayload: any;
/**
* The log entry payload, represented as a Unicode string (UTF-8).
*/
textPayload: string;
/**
* The time the event described by the log entry occurred. If omitted,
* defaults to operation start time.
*/
timestamp: string;
}
/**
* Represents a single metric value.
*/
export interface Schema$MetricValue {
/**
* A boolean value.
*/
boolValue: boolean;
/**
* A distribution value.
*/
distributionValue: Schema$Distribution;
/**
* A double precision floating point value.
*/
doubleValue: number;
/**
* The end of the time period over which this metric value's measurement
* applies.
*/
endTime: string;
/**
* A signed 64-bit integer value.
*/
int64Value: string;
/**
* The labels describing the metric value. See comments on
* google.api.servicecontrol.v1.Operation.labels for the overriding
* relationship.
*/
labels: any;
/**
* A money value.
*/
moneyValue: Schema$Money;
/**
* The start of the time period over which this metric value's measurement
* applies. The time period has different semantics for different metric types
* (cumulative, delta, and gauge). See the metric definition documentation in
* the service configuration for details.
*/
startTime: string;
/**
* A text string value.
*/
stringValue: string;
}
/**
* Represents a set of metric values in the same metric. Each metric value in
* the set should have a unique combination of start time, end time, and label
* values.
*/
export interface Schema$MetricValueSet {
/**
* The metric name defined in the service configuration.
*/
metricName: string;
/**
* The values in this metric.
*/
metricValues: Schema$MetricValue[];
}
/**
* Represents an amount of money with its currency type.
*/
export interface Schema$Money {
/**
* The 3-letter currency code defined in ISO 4217.
*/
currencyCode: string;
/**
* Number of nano (10^-9) units of the amount. The value must be between
* -999,999,999 and +999,999,999 inclusive. If `units` is positive, `nanos`
* must be positive or zero. If `units` is zero, `nanos` can be positive,
* zero, or negative. If `units` is negative, `nanos` must be negative or
* zero. For example $-1.75 is represented as `units`=-1 and
* `nanos`=-750,000,000.
*/
nanos: number;
/**
* The whole units of the amount. For example if `currencyCode` is
* `"USD"`, then 1 unit is one US dollar.
*/
units: string;
}
/**
* Represents information regarding an operation.
*/
export interface Schema$Operation {
/**
* Identity of the consumer who is using the service. This field should be
* filled in for the operations initiated by a consumer, but not for
* service-initiated operations that are not related to a specific consumer.
* This can be in one of the following formats: project:<project_id>,
* project_number:<project_number>, api_key:<api_key>.
*/
consumerId: string;
/**
* End time of the operation. Required when the operation is used in
* ServiceController.Report, but optional when the operation is used in
* ServiceController.Check.
*/
endTime: string;
/**
* DO NOT USE. This is an experimental field.
*/
importance: string;
/**
* Labels describing the operation. Only the following labels are allowed: -
* Labels describing monitored resources as defined in the service
* configuration. - Default labels of metric values. When specified, labels
* defined in the metric value override these default. - The following
* labels defined by Google Cloud Platform: -
* `cloud.googleapis.com/location` describing the location where the operation
* happened, - `servicecontrol.googleapis.com/user_agent` describing the
* user agent of the API request, -
* `servicecontrol.googleapis.com/service_agent` describing the service used
* to handle the API request (e.g. ESP), -
* `servicecontrol.googleapis.com/platform` describing the platform where the
* API is served, such as App Engine, Compute Engine, or Kubernetes
* Engine.
*/
labels: any;
/**
* Represents information to be logged.
*/
logEntries: Schema$LogEntry[];
/**
* Represents information about this operation. Each MetricValueSet
* corresponds to a metric defined in the service configuration. The data type
* used in the MetricValueSet must agree with the data type specified in the
* metric definition. Within a single operation, it is not allowed to have
* more than one MetricValue instances that have the same metric names and
* identical label value combinations. If a request has such duplicated
* MetricValue instances, the entire request is rejected with an invalid
* argument error.
*/
metricValueSets: Schema$MetricValueSet[];
/**
* Identity of the operation. This must be unique within the scope of the
* service that generated the operation. If the service calls Check() and
* Report() on the same operation, the two calls should carry the same id.
* UUID version 4 is recommended, though not required. In scenarios where an
* operation is computed from existing information and an idempotent id is
* desirable for deduplication purpose, UUID version 5 is recommended. See RFC
* 4122 for details.
*/
operationId: string;
/**
* Fully qualified name of the operation. Reserved for future use.
*/
operationName: string;
/**
* Represents the properties needed for quota check. Applicable only if this
* operation is for a quota check request. If this is not specified, no quota
* check will be performed.
*/
quotaProperties: Schema$QuotaProperties;
/**
* DO NOT USE. This field is deprecated, use "resources" field
* instead. The resource name of the parent of a resource in the resource
* hierarchy. This can be in one of the following formats: -
* “projects/<project-id or project-number>” -
* “folders/<folder-id>” - “organizations/<organization-id>”
*/
resourceContainer: string;
/**
* The resources that are involved in the operation.
*/
resources: Schema$ResourceInfo[];
/**
* Required. Start time of the operation.
*/
startTime: string;
/**
* User defined labels for the resource that this operation is associated
* with. Only a combination of 1000 user labels per consumer project are
* allowed.
*/
userLabels: any;
}
/**
* Represents error information for QuotaOperation.
*/
export interface Schema$QuotaError {
/**
* Error code.
*/
code: string;
/**
* Free-form text that provides details on the cause of the error.
*/
description: string;
/**
* Subject to whom this error applies. See the specific enum for more details
* on this field. For example, "clientip:<ip address of
* client>" or "project:<Google developer project
* id>".
*/
subject: string;
}
/**
* Contains the quota information for a quota check response.
*/
export interface Schema$QuotaInfo {
/**
* Quota Metrics that have exceeded quota limits. For QuotaGroup-based quota,
* this is QuotaGroup.name For QuotaLimit-based quota, this is QuotaLimit.name
* See: google.api.Quota Deprecated: Use quota_metrics to get per quota group
* limit exceeded status.
*/
limitExceeded: string[];
/**
* Map of quota group name to the actual number of tokens consumed. If the
* quota check was not successful, then this will not be populated due to no
* quota consumption. We are not merging this field with
* 'quota_metrics' field because of the complexity of scaling in
* Chemist client code base. For simplicity, we will keep this field for
* Castor (that scales quota usage) and 'quota_metrics' for SuperQuota
* (that doesn't scale quota usage).
*/
quotaConsumed: any;
/**
* Quota metrics to indicate the usage. Depending on the check request, one or
* more of the following metrics will be included: 1. For rate quota, per
* quota group or per quota metric incremental usage will be specified using
* the following delta metric:
* "serviceruntime.googleapis.com/api/consumer/quota_used_count" 2.
* For allocation quota, per quota metric total usage will be specified using
* the following gauge metric:
* "serviceruntime.googleapis.com/allocation/consumer/quota_used_count"
* 3. For both rate quota and allocation quota, the quota limit reached
* condition will be specified using the following boolean metric:
* "serviceruntime.googleapis.com/quota/exceeded"
*/
quotaMetrics: Schema$MetricValueSet[];
}
/**
* Represents information regarding a quota operation.
*/
export interface Schema$QuotaOperation {
/**
* Identity of the consumer for whom this quota operation is being performed.
* This can be in one of the following formats: project:<project_id>,
* project_number:<project_number>, api_key:<api_key>.
*/
consumerId: string;
/**
* Labels describing the operation.
*/
labels: any;
/**
* Fully qualified name of the API method for which this quota operation is
* requested. This name is used for matching quota rules or metric rules and
* billing status rules defined in service configuration. This field should
* not be set if any of the following is true: (1) the quota operation is
* performed on non-API resources. (2) quota_metrics is set because the caller
* is doing quota override. Example of an RPC method name:
* google.example.library.v1.LibraryService.CreateShelf
*/
methodName: string;
/**
* Identity of the operation. This is expected to be unique within the scope
* of the service that generated the operation, and guarantees idempotency in
* case of retries. UUID version 4 is recommended, though not required. In
* scenarios where an operation is computed from existing information and an
* idempotent id is desirable for deduplication purpose, UUID version 5 is
* recommended. See RFC 4122 for details.
*/
operationId: string;
/**
* Represents information about this operation. Each MetricValueSet
* corresponds to a metric defined in the service configuration. The data type
* used in the MetricValueSet must agree with the data type specified in the
* metric definition. Within a single operation, it is not allowed to have
* more than one MetricValue instances that have the same metric names and
* identical label value combinations. If a request has such duplicated
* MetricValue instances, the entire request is rejected with an invalid
* argument error. This field is mutually exclusive with method_name.
*/
quotaMetrics: Schema$MetricValueSet[];
/**
* Quota mode for this operation.
*/
quotaMode: string;
}
/**
* Represents the properties needed for quota operations.
*/
export interface Schema$QuotaProperties {
/**
* Quota mode for this operation.
*/
quotaMode: string;
}
/**
* Request message for the ReleaseQuota method.
*/
export interface Schema$ReleaseQuotaRequest {
/**
* Operation that describes the quota release.
*/
releaseOperation: Schema$QuotaOperation;
/**
* Specifies which version of service configuration should be used to process
* the request. If unspecified or no matching version can be found, the latest
* one will be used.
*/
serviceConfigId: string;
}
/**
* Response message for the ReleaseQuota method.
*/
export interface Schema$ReleaseQuotaResponse {
/**
* The same operation_id value used in the ReleaseQuotaRequest. Used for
* logging and diagnostics purposes.
*/
operationId: string;
/**
* Quota metrics to indicate the result of release. Depending on the request,
* one or more of the following metrics will be included: 1. For rate quota,
* per quota group or per quota metric released amount will be specified using
* the following delta metric:
* "serviceruntime.googleapis.com/api/consumer/quota_refund_count"
* 2. For allocation quota, per quota metric total usage will be specified
* using the following gauge metric:
* "serviceruntime.googleapis.com/allocation/consumer/quota_used_count"
* 3. For allocation quota, value for each quota limit associated with the
* metrics will be specified using the following gauge metric:
* "serviceruntime.googleapis.com/quota/limit"
*/
quotaMetrics: Schema$MetricValueSet[];
/**
* Indicates the decision of the release.
*/
releaseErrors: Schema$QuotaError[];
/**
* ID of the actual config used to process the request.
*/
serviceConfigId: string;
}
/**
* Represents the processing error of one Operation in the request.
*/
export interface Schema$ReportError {
/**
* The Operation.operation_id value from the request.
*/
operationId: string;
/**
* Details of the error when processing the Operation.
*/
status: Schema$Status;
}
/**
* Contains additional info about the report operation.
*/
export interface Schema$ReportInfo {
/**
* The Operation.operation_id value from the request.
*/
operationId: string;
/**
* Quota usage info when processing the `Operation`.
*/
quotaInfo: Schema$QuotaInfo;
}
/**
* Request message for the Report method.
*/
export interface Schema$ReportRequest {
/**
* Operations to be reported. Typically the service should report one
* operation per request. Putting multiple operations into a single request is
* allowed, but should be used only when multiple operations are natually
* available at the time of the report. If multiple operations are in a
* single request, the total request size should be no larger than 1MB. See
* ReportResponse.report_errors for partial failure behavior.
*/
operations: Schema$Operation[];
/**
* Specifies which version of service config should be used to process the
* request. If unspecified or no matching version can be found, the latest
* one will be used.
*/
serviceConfigId: string;
}
/**
* Response message for the Report method.
*/
export interface Schema$ReportResponse {
/**
* Partial failures, one for each `Operation` in the request that failed
* processing. There are three possible combinations of the RPC status: 1.
* The combination of a successful RPC status and an empty `report_errors`
* list indicates a complete success where all `Operations` in the request
* are processed successfully. 2. The combination of a successful RPC status
* and a non-empty `report_errors` list indicates a partial success where
* some `Operations` in the request succeeded. Each `Operation` that
* failed processing has a corresponding item in this list. 3. A failed RPC
* status indicates a general non-deterministic failure. When this happens,
* it's impossible to know which of the 'Operations' in the
* request succeeded or failed.
*/
reportErrors: Schema$ReportError[];
/**
* Quota usage for each quota release `Operation` request. Fully or partially
* failed quota release request may or may not be present in
* `report_quota_info`. For example, a failed quota release request will have
* the current quota usage info when precise quota library returns the info. A
* deadline exceeded quota request will not have quota usage info. If there
* is no quota release request, report_quota_info will be empty.
*/
reportInfos: Schema$ReportInfo[];
/**
* The actual config id used to process the request.
*/
serviceConfigId: string;
}
/**
* Metadata about the request.
*/
export interface Schema$RequestMetadata {
/**
* The IP address of the caller. For caller from internet, this will be public
* IPv4 or IPv6 address. For caller from a Compute Engine VM with external IP
* address, this will be the VM's external IP address. For caller from a
* Compute Engine VM without external IP address, if the VM is in the same
* organization (or project) as the accessed resource, `caller_ip` will be the
* VM's internal IPv4 address, otherwise the `caller_ip` will be redacted
* to "gce-internal-ip". See
* https://cloud.google.com/compute/docs/vpc/ for more information.
*/
callerIp: string;
/**
* The network of the caller. Set only if the network host project is part of
* the same GCP organization (or project) as the accessed resource. See
* https://cloud.google.com/compute/docs/vpc/ for more information. This is a
* scheme-less URI full resource name. For example:
* "//compute.googleapis.com/projects/PROJECT_ID/global/networks/NETWORK_ID"
*/
callerNetwork: string;
/**
* The user agent of the caller. This information is not authenticated and
* should be treated accordingly. For example: +
* `google-api-python-client/1.4.0`: The request was made by the Google
* API client for Python. + `Cloud SDK Command Line Tool apitools-client/1.0
* gcloud/0.9.62`: The request was made by the Google Cloud SDK CLI
* (gcloud). + `AppEngine-Google; (+http://code.google.com/appengine; appid:
* s~my-project`: The request was made from the `my-project` App Engine
* app. NOLINT
*/
callerSuppliedUserAgent: string;
}
/**
* Describes a resource associated with this operation.
*/
export interface Schema$ResourceInfo {
/**
* The identifier of the parent of this resource instance. Must be in one of
* the following formats: - “projects/<project-id or
* project-number>” - “folders/<folder-id>” -
* “organizations/<organization-id>”
*/
resourceContainer: string;
/**
* Name of the resource. This is used for auditing purposes.
*/
resourceName: string;
}
/**
* Request message for QuotaController.StartReconciliation.
*/
export interface Schema$StartReconciliationRequest {
/**
* Operation that describes the quota reconciliation.
*/
reconciliationOperation: Schema$QuotaOperation;
/**
* Specifies which version of service configuration should be used to process
* the request. If unspecified or no matching version can be found, the latest
* one will be used.
*/
serviceConfigId: string;
}
/**
* Response message for QuotaController.StartReconciliation.
*/
export interface Schema$StartReconciliationResponse {
/**
* The same operation_id value used in the StartReconciliationRequest. Used
* for logging and diagnostics purposes.
*/
operationId: string;
/**
* Metric values as tracked by One Platform before the start of
* reconciliation. The following metrics will be included: 1. Per quota
* metric total usage will be specified using the following gauge metric:
* "serviceruntime.googleapis.com/allocation/consumer/quota_used_count"
* 2. Value for each quota limit associated with the metrics will be specified
* using the following gauge metric:
* "serviceruntime.googleapis.com/quota/limit"
*/
quotaMetrics: Schema$MetricValueSet[];
/**
* Indicates the decision of the reconciliation start.
*/
reconciliationErrors: Schema$QuotaError[];
/**
* ID of the actual config used to process the request.
*/
serviceConfigId: string;
}
/**
* 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$Services {
root: Servicecontrol;
constructor(root: Servicecontrol);
getRoot(): Servicecontrol;
/**
* servicecontrol.services.allocateQuota
* @desc Attempts to allocate quota for the specified consumer. It should be
* called before the operation is executed. This method requires the
* `servicemanagement.services.quota` permission on the specified service. For
* more information, see [Cloud IAM](https://cloud.google.com/iam). **NOTE:**
* The client **must** fail-open on server errors `INTERNAL`, `UNKNOWN`,
* `DEADLINE_EXCEEDED`, and `UNAVAILABLE`. To ensure system reliability, the
* server may inject these errors to prohibit any hard dependency on the quota
* functionality.
* @alias servicecontrol.services.allocateQuota
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.serviceName Name of the service as specified in the service configuration. For example, `"pubsub.googleapis.com"`. See google.api.Service for the definition of a service name.
* @param {().AllocateQuotaRequest} 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
*/
allocateQuota(params?: any, options?: MethodOptions): AxiosPromise<Schema$AllocateQuotaResponse>;
allocateQuota(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$AllocateQuotaResponse>, callback?: BodyResponseCallback<Schema$AllocateQuotaResponse>): void;
/**
* servicecontrol.services.check
* @desc Checks whether an operation on a service should be allowed to proceed
* based on the configuration of the service and related policies. It must be
* called before the operation is executed. If feasible, the client should
* cache the check results and reuse them for 60 seconds. In case of any
* server errors, the client should rely on the cached results for much longer
* time to avoid outage. WARNING: There is general 60s delay for the
* configuration and policy propagation, therefore callers MUST NOT depend on
* the `Check` method having the latest policy information. NOTE: the
* CheckRequest has the size limit of 64KB. This method requires the
* `servicemanagement.services.check` permission on the specified service. For
* more information, see [Cloud IAM](https://cloud.google.com/iam).
* @alias servicecontrol.services.check
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.serviceName The service name as specified in its service configuration. For example, `"pubsub.googleapis.com"`. See [google.api.Service](https://cloud.google.com/service-management/reference/rpc/google.api#google.api.Service) for the definition of a service name.
* @param {().CheckRequest} 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
*/
check(params?: any, options?: MethodOptions): AxiosPromise<Schema$CheckResponse>;
check(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$CheckResponse>, callback?: BodyResponseCallback<Schema$CheckResponse>): void;
/**
* servicecontrol.services.endReconciliation
* @desc Signals the quota controller that service ends the ongoing usage
* reconciliation. This method requires the
* `servicemanagement.services.quota` permission on the specified service. For
* more information, see [Google Cloud IAM](https://cloud.google.com/iam).
* @alias servicecontrol.services.endReconciliation
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.serviceName Name of the service as specified in the service configuration. For example, `"pubsub.googleapis.com"`. See google.api.Service for the definition of a service name.
* @param {().EndReconciliationRequest} 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
*/
endReconciliation(params?: any, options?: MethodOptions): AxiosPromise<Schema$EndReconciliationResponse>;
endReconciliation(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$EndReconciliationResponse>, callback?: BodyResponseCallback<Schema$EndReconciliationResponse>): void;
/**
* servicecontrol.services.releaseQuota
* @desc Releases previously allocated quota done through AllocateQuota
* method. This method requires the `servicemanagement.services.quota`
* permission on the specified service. For more information, see [Cloud
* IAM](https://cloud.google.com/iam). **NOTE:** The client **must**
* fail-open on server errors `INTERNAL`, `UNKNOWN`, `DEADLINE_EXCEEDED`, and
* `UNAVAILABLE`. To ensure system reliability, the server may inject these
* errors to prohibit any hard dependency on the quota functionality.
* @alias servicecontrol.services.releaseQuota
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.serviceName Name of the service as specified in the service configuration. For example, `"pubsub.googleapis.com"`. See google.api.Service for the definition of a service name.
* @param {().ReleaseQuotaRequest} 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
*/
releaseQuota(params?: any, options?: MethodOptions): AxiosPromise<Schema$ReleaseQuotaResponse>;
releaseQuota(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$ReleaseQuotaResponse>, callback?: BodyResponseCallback<Schema$ReleaseQuotaResponse>): void;
/**
* servicecontrol.services.report
* @desc Reports operation results to Google Service Control, such as logs and
* metrics. It should be called after an operation is completed. If feasible,
* the client should aggregate reporting data for up to 5 seconds to reduce
* API traffic. Limiting aggregation to 5 seconds is to reduce data loss
* during client crashes. Clients should carefully choose the aggregation time
* window to avoid data loss risk more than 0.01% for business and compliance
* reasons. NOTE: the ReportRequest has the size limit of 1MB. This method
* requires the `servicemanagement.services.report` permission on the
* specified service. For more information, see [Google Cloud
* IAM](https://cloud.google.com/iam).
* @alias servicecontrol.services.report
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.serviceName The service name as specified in its service configuration. For example, `"pubsub.googleapis.com"`. See [google.api.Service](https://cloud.google.com/service-management/reference/rpc/google.api#google.api.Service) for the definition of a service name.
* @param {().ReportRequest} 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
*/
report(params?: any, options?: MethodOptions): AxiosPromise<Schema$ReportResponse>;
report(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$ReportResponse>, callback?: BodyResponseCallback<Schema$ReportResponse>): vo