google-ads-api-client
Version:
A friendly and exhaustive client to the google-ads-api, code generated directly from google's published protobuf schema.
258 lines (257 loc) • 9.77 kB
TypeScript
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
import type { IBinaryWriter } from "@protobuf-ts/runtime";
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
import type { IBinaryReader } from "@protobuf-ts/runtime";
import type { PartialMessage } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
/**
* Quota configuration helps to achieve fairness and budgeting in service
* usage.
*
* The metric based quota configuration works this way:
* - The service configuration defines a set of metrics.
* - For API calls, the quota.metric_rules maps methods to metrics with
* corresponding costs.
* - The quota.limits defines limits on the metrics, which will be used for
* quota checks at runtime.
*
* An example quota configuration in yaml format:
*
* quota:
* limits:
*
* - name: apiWriteQpsPerProject
* metric: library.googleapis.com/write_calls
* unit: "1/min/{project}" # rate limit for consumer projects
* values:
* STANDARD: 10000
*
*
* # The metric rules bind all methods to the read_calls metric,
* # except for the UpdateBook and DeleteBook methods. These two methods
* # are mapped to the write_calls metric, with the UpdateBook method
* # consuming at twice rate as the DeleteBook method.
* metric_rules:
* - selector: "*"
* metric_costs:
* library.googleapis.com/read_calls: 1
* - selector: google.example.library.v1.LibraryService.UpdateBook
* metric_costs:
* library.googleapis.com/write_calls: 2
* - selector: google.example.library.v1.LibraryService.DeleteBook
* metric_costs:
* library.googleapis.com/write_calls: 1
*
* Corresponding Metric definition:
*
* metrics:
* - name: library.googleapis.com/read_calls
* display_name: Read requests
* metric_kind: DELTA
* value_type: INT64
*
* - name: library.googleapis.com/write_calls
* display_name: Write requests
* metric_kind: DELTA
* value_type: INT64
*
*
*
* @generated from protobuf message google.api.Quota
*/
export interface Quota {
/**
* List of `QuotaLimit` definitions for the service.
*
* @generated from protobuf field: repeated google.api.QuotaLimit limits = 3;
*/
limits: QuotaLimit[];
/**
* List of `MetricRule` definitions, each one mapping a selected method to one
* or more metrics.
*
* @generated from protobuf field: repeated google.api.MetricRule metric_rules = 4;
*/
metricRules: MetricRule[];
}
/**
* Bind API methods to metrics. Binding a method to a metric causes that
* metric's configured quota behaviors to apply to the method call.
*
* @generated from protobuf message google.api.MetricRule
*/
export interface MetricRule {
/**
* Selects the methods to which this rule applies.
*
* Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
*
* @generated from protobuf field: string selector = 1;
*/
selector: string;
/**
* Metrics to update when the selected methods are called, and the associated
* cost applied to each metric.
*
* The key of the map is the metric name, and the values are the amount
* increased for the metric against which the quota limits are defined.
* The value must not be negative.
*
* @generated from protobuf field: map<string, int64> metric_costs = 2;
*/
metricCosts: {
[key: string]: bigint;
};
}
/**
* `QuotaLimit` defines a specific limit that applies over a specified duration
* for a limit type. There can be at most one limit for a duration and limit
* type combination defined within a `QuotaGroup`.
*
* @generated from protobuf message google.api.QuotaLimit
*/
export interface QuotaLimit {
/**
* Name of the quota limit.
*
* The name must be provided, and it must be unique within the service. The
* name can only include alphanumeric characters as well as '-'.
*
* The maximum length of the limit name is 64 characters.
*
* @generated from protobuf field: string name = 6;
*/
name: string;
/**
* Optional. User-visible, extended description for this quota limit.
* Should be used only when more context is needed to understand this limit
* than provided by the limit's display name (see: `display_name`).
*
* @generated from protobuf field: string description = 2;
*/
description: string;
/**
* Default number of tokens that can be consumed during the specified
* duration. This is the number of tokens assigned when a client
* application developer activates the service for his/her project.
*
* Specifying a value of 0 will block all requests. This can be used if you
* are provisioning quota to selected consumers and blocking others.
* Similarly, a value of -1 will indicate an unlimited quota. No other
* negative values are allowed.
*
* Used by group-based quotas only.
*
* @generated from protobuf field: int64 default_limit = 3;
*/
defaultLimit: bigint;
/**
* Maximum number of tokens that can be consumed during the specified
* duration. Client application developers can override the default limit up
* to this maximum. If specified, this value cannot be set to a value less
* than the default limit. If not specified, it is set to the default limit.
*
* To allow clients to apply overrides with no upper bound, set this to -1,
* indicating unlimited maximum quota.
*
* Used by group-based quotas only.
*
* @generated from protobuf field: int64 max_limit = 4;
*/
maxLimit: bigint;
/**
* Free tier value displayed in the Developers Console for this limit.
* The free tier is the number of tokens that will be subtracted from the
* billed amount when billing is enabled.
* This field can only be set on a limit with duration "1d", in a billable
* group; it is invalid on any other limit. If this field is not set, it
* defaults to 0, indicating that there is no free tier for this service.
*
* Used by group-based quotas only.
*
* @generated from protobuf field: int64 free_tier = 7;
*/
freeTier: bigint;
/**
* Duration of this limit in textual notation. Must be "100s" or "1d".
*
* Used by group-based quotas only.
*
* @generated from protobuf field: string duration = 5;
*/
duration: string;
/**
* The name of the metric this quota limit applies to. The quota limits with
* the same metric will be checked together during runtime. The metric must be
* defined within the service config.
*
* @generated from protobuf field: string metric = 8;
*/
metric: string;
/**
* Specify the unit of the quota limit. It uses the same syntax as
* [Metric.unit][]. The supported unit kinds are determined by the quota
* backend system.
*
* Here are some examples:
* * "1/min/{project}" for quota per minute per project.
*
* Note: the order of unit components is insignificant.
* The "1" at the beginning is required to follow the metric unit syntax.
*
* @generated from protobuf field: string unit = 9;
*/
unit: string;
/**
* Tiered limit values. You must specify this as a key:value pair, with an
* integer value that is the maximum number of requests allowed for the
* specified unit. Currently only STANDARD is supported.
*
* @generated from protobuf field: map<string, int64> values = 10;
*/
values: {
[key: string]: bigint;
};
/**
* User-visible display name for this limit.
* Optional. If not set, the UI will provide a default display name based on
* the quota configuration. This field can be used to override the default
* display name generated from the configuration.
*
* @generated from protobuf field: string display_name = 12;
*/
displayName: string;
}
declare class Quota$Type extends MessageType<Quota> {
constructor();
create(value?: PartialMessage<Quota>): Quota;
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Quota): Quota;
internalBinaryWrite(message: Quota, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
* @generated MessageType for protobuf message google.api.Quota
*/
export declare const Quota: Quota$Type;
declare class MetricRule$Type extends MessageType<MetricRule> {
constructor();
create(value?: PartialMessage<MetricRule>): MetricRule;
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MetricRule): MetricRule;
private binaryReadMap2;
internalBinaryWrite(message: MetricRule, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
* @generated MessageType for protobuf message google.api.MetricRule
*/
export declare const MetricRule: MetricRule$Type;
declare class QuotaLimit$Type extends MessageType<QuotaLimit> {
constructor();
create(value?: PartialMessage<QuotaLimit>): QuotaLimit;
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: QuotaLimit): QuotaLimit;
private binaryReadMap10;
internalBinaryWrite(message: QuotaLimit, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
* @generated MessageType for protobuf message google.api.QuotaLimit
*/
export declare const QuotaLimit: QuotaLimit$Type;
export {};