You've already forked npm-viz-sdk
Latest generation
This commit is contained in:
ci viz model
77
google/api/field_behavior.ts
Normal file
77
google/api/field_behavior.ts
Normal file
@@ -0,0 +1,77 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/api/field_behavior.proto" (package "google.api", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Copyright 2020 Google LLC
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
/**
|
||||
* An indicator of the behavior of a given field (for example, that a field
|
||||
* is required in requests, or given as output but ignored as input).
|
||||
* This **does not** change the behavior in protocol buffers itself; it only
|
||||
* denotes the behavior and may affect how API tooling handles the field.
|
||||
*
|
||||
* Note: This enum **may** receive new values in the future.
|
||||
*
|
||||
* @generated from protobuf enum google.api.FieldBehavior
|
||||
*/
|
||||
export enum FieldBehavior {
|
||||
/**
|
||||
* Conventional default for enums. Do not use this.
|
||||
*
|
||||
* @generated from protobuf enum value: FIELD_BEHAVIOR_UNSPECIFIED = 0;
|
||||
*/
|
||||
FIELD_BEHAVIOR_UNSPECIFIED = 0,
|
||||
/**
|
||||
* Specifically denotes a field as optional.
|
||||
* While all fields in protocol buffers are optional, this may be specified
|
||||
* for emphasis if appropriate.
|
||||
*
|
||||
* @generated from protobuf enum value: OPTIONAL = 1;
|
||||
*/
|
||||
OPTIONAL = 1,
|
||||
/**
|
||||
* Denotes a field as required.
|
||||
* This indicates that the field **must** be provided as part of the request,
|
||||
* and failure to do so will cause an error (usually `INVALID_ARGUMENT`).
|
||||
*
|
||||
* @generated from protobuf enum value: REQUIRED = 2;
|
||||
*/
|
||||
REQUIRED = 2,
|
||||
/**
|
||||
* Denotes a field as output only.
|
||||
* This indicates that the field is provided in responses, but including the
|
||||
* field in a request does nothing (the server *must* ignore it and
|
||||
* *must not* throw an error as a result of the field's presence).
|
||||
*
|
||||
* @generated from protobuf enum value: OUTPUT_ONLY = 3;
|
||||
*/
|
||||
OUTPUT_ONLY = 3,
|
||||
/**
|
||||
* Denotes a field as input only.
|
||||
* This indicates that the field is provided in requests, and the
|
||||
* corresponding field is not included in output.
|
||||
*
|
||||
* @generated from protobuf enum value: INPUT_ONLY = 4;
|
||||
*/
|
||||
INPUT_ONLY = 4,
|
||||
/**
|
||||
* Denotes a field as immutable.
|
||||
* This indicates that the field may be set once in a request to create a
|
||||
* resource, but may not be changed thereafter.
|
||||
*
|
||||
* @generated from protobuf enum value: IMMUTABLE = 5;
|
||||
*/
|
||||
IMMUTABLE = 5
|
||||
}
|
||||
687
google/api/http.ts
Normal file
687
google/api/http.ts
Normal file
@@ -0,0 +1,687 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/api/http.proto" (package "google.api", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Copyright 2020 Google LLC
|
||||
//
|
||||
// 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 type { BinaryWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryWriter } from "@protobuf-ts/runtime";
|
||||
import { WireType } from "@protobuf-ts/runtime";
|
||||
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryReader } from "@protobuf-ts/runtime";
|
||||
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
|
||||
import type { PartialMessage } from "@protobuf-ts/runtime";
|
||||
import { reflectionMergePartial } from "@protobuf-ts/runtime";
|
||||
import { MessageType } from "@protobuf-ts/runtime";
|
||||
/**
|
||||
* Defines the HTTP configuration for an API service. It contains a list of
|
||||
* [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method
|
||||
* to one or more HTTP REST API methods.
|
||||
*
|
||||
* @generated from protobuf message google.api.Http
|
||||
*/
|
||||
export interface Http {
|
||||
/**
|
||||
* A list of HTTP configuration rules that apply to individual API methods.
|
||||
*
|
||||
* **NOTE:** All service configuration rules follow "last one wins" order.
|
||||
*
|
||||
* @generated from protobuf field: repeated google.api.HttpRule rules = 1;
|
||||
*/
|
||||
rules: HttpRule[];
|
||||
/**
|
||||
* When set to true, URL path parameters will be fully URI-decoded except in
|
||||
* cases of single segment matches in reserved expansion, where "%2F" will be
|
||||
* left encoded.
|
||||
*
|
||||
* The default behavior is to not decode RFC 6570 reserved characters in multi
|
||||
* segment matches.
|
||||
*
|
||||
* @generated from protobuf field: bool fully_decode_reserved_expansion = 2;
|
||||
*/
|
||||
fullyDecodeReservedExpansion: boolean;
|
||||
}
|
||||
/**
|
||||
* # gRPC Transcoding
|
||||
*
|
||||
* gRPC Transcoding is a feature for mapping between a gRPC method and one or
|
||||
* more HTTP REST endpoints. It allows developers to build a single API service
|
||||
* that supports both gRPC APIs and REST APIs. Many systems, including [Google
|
||||
* APIs](https://github.com/googleapis/googleapis),
|
||||
* [Cloud Endpoints](https://cloud.google.com/endpoints), [gRPC
|
||||
* Gateway](https://github.com/grpc-ecosystem/grpc-gateway),
|
||||
* and [Envoy](https://github.com/envoyproxy/envoy) proxy support this feature
|
||||
* and use it for large scale production services.
|
||||
*
|
||||
* `HttpRule` defines the schema of the gRPC/REST mapping. The mapping specifies
|
||||
* how different portions of the gRPC request message are mapped to the URL
|
||||
* path, URL query parameters, and HTTP request body. It also controls how the
|
||||
* gRPC response message is mapped to the HTTP response body. `HttpRule` is
|
||||
* typically specified as an `google.api.http` annotation on the gRPC method.
|
||||
*
|
||||
* Each mapping specifies a URL path template and an HTTP method. The path
|
||||
* template may refer to one or more fields in the gRPC request message, as long
|
||||
* as each field is a non-repeated field with a primitive (non-message) type.
|
||||
* The path template controls how fields of the request message are mapped to
|
||||
* the URL path.
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* service Messaging {
|
||||
* rpc GetMessage(GetMessageRequest) returns (Message) {
|
||||
* option (google.api.http) = {
|
||||
* get: "/v1/{name=messages/*}"
|
||||
* };
|
||||
* }
|
||||
* }
|
||||
* message GetMessageRequest {
|
||||
* string name = 1; // Mapped to URL path.
|
||||
* }
|
||||
* message Message {
|
||||
* string text = 1; // The resource content.
|
||||
* }
|
||||
*
|
||||
* This enables an HTTP REST to gRPC mapping as below:
|
||||
*
|
||||
* HTTP | gRPC
|
||||
* -----|-----
|
||||
* `GET /v1/messages/123456` | `GetMessage(name: "messages/123456")`
|
||||
*
|
||||
* Any fields in the request message which are not bound by the path template
|
||||
* automatically become HTTP query parameters if there is no HTTP request body.
|
||||
* For example:
|
||||
*
|
||||
* service Messaging {
|
||||
* rpc GetMessage(GetMessageRequest) returns (Message) {
|
||||
* option (google.api.http) = {
|
||||
* get:"/v1/messages/{message_id}"
|
||||
* };
|
||||
* }
|
||||
* }
|
||||
* message GetMessageRequest {
|
||||
* message SubMessage {
|
||||
* string subfield = 1;
|
||||
* }
|
||||
* string message_id = 1; // Mapped to URL path.
|
||||
* int64 revision = 2; // Mapped to URL query parameter `revision`.
|
||||
* SubMessage sub = 3; // Mapped to URL query parameter `sub.subfield`.
|
||||
* }
|
||||
*
|
||||
* This enables a HTTP JSON to RPC mapping as below:
|
||||
*
|
||||
* HTTP | gRPC
|
||||
* -----|-----
|
||||
* `GET /v1/messages/123456?revision=2&sub.subfield=foo` |
|
||||
* `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield:
|
||||
* "foo"))`
|
||||
*
|
||||
* Note that fields which are mapped to URL query parameters must have a
|
||||
* primitive type or a repeated primitive type or a non-repeated message type.
|
||||
* In the case of a repeated type, the parameter can be repeated in the URL
|
||||
* as `...?param=A¶m=B`. In the case of a message type, each field of the
|
||||
* message is mapped to a separate parameter, such as
|
||||
* `...?foo.a=A&foo.b=B&foo.c=C`.
|
||||
*
|
||||
* For HTTP methods that allow a request body, the `body` field
|
||||
* specifies the mapping. Consider a REST update method on the
|
||||
* message resource collection:
|
||||
*
|
||||
* service Messaging {
|
||||
* rpc UpdateMessage(UpdateMessageRequest) returns (Message) {
|
||||
* option (google.api.http) = {
|
||||
* patch: "/v1/messages/{message_id}"
|
||||
* body: "message"
|
||||
* };
|
||||
* }
|
||||
* }
|
||||
* message UpdateMessageRequest {
|
||||
* string message_id = 1; // mapped to the URL
|
||||
* Message message = 2; // mapped to the body
|
||||
* }
|
||||
*
|
||||
* The following HTTP JSON to RPC mapping is enabled, where the
|
||||
* representation of the JSON in the request body is determined by
|
||||
* protos JSON encoding:
|
||||
*
|
||||
* HTTP | gRPC
|
||||
* -----|-----
|
||||
* `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id:
|
||||
* "123456" message { text: "Hi!" })`
|
||||
*
|
||||
* The special name `*` can be used in the body mapping to define that
|
||||
* every field not bound by the path template should be mapped to the
|
||||
* request body. This enables the following alternative definition of
|
||||
* the update method:
|
||||
*
|
||||
* service Messaging {
|
||||
* rpc UpdateMessage(Message) returns (Message) {
|
||||
* option (google.api.http) = {
|
||||
* patch: "/v1/messages/{message_id}"
|
||||
* body: "*"
|
||||
* };
|
||||
* }
|
||||
* }
|
||||
* message Message {
|
||||
* string message_id = 1;
|
||||
* string text = 2;
|
||||
* }
|
||||
*
|
||||
*
|
||||
* The following HTTP JSON to RPC mapping is enabled:
|
||||
*
|
||||
* HTTP | gRPC
|
||||
* -----|-----
|
||||
* `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id:
|
||||
* "123456" text: "Hi!")`
|
||||
*
|
||||
* Note that when using `*` in the body mapping, it is not possible to
|
||||
* have HTTP parameters, as all fields not bound by the path end in
|
||||
* the body. This makes this option more rarely used in practice when
|
||||
* defining REST APIs. The common usage of `*` is in custom methods
|
||||
* which don't use the URL at all for transferring data.
|
||||
*
|
||||
* It is possible to define multiple HTTP methods for one RPC by using
|
||||
* the `additional_bindings` option. Example:
|
||||
*
|
||||
* service Messaging {
|
||||
* rpc GetMessage(GetMessageRequest) returns (Message) {
|
||||
* option (google.api.http) = {
|
||||
* get: "/v1/messages/{message_id}"
|
||||
* additional_bindings {
|
||||
* get: "/v1/users/{user_id}/messages/{message_id}"
|
||||
* }
|
||||
* };
|
||||
* }
|
||||
* }
|
||||
* message GetMessageRequest {
|
||||
* string message_id = 1;
|
||||
* string user_id = 2;
|
||||
* }
|
||||
*
|
||||
* This enables the following two alternative HTTP JSON to RPC mappings:
|
||||
*
|
||||
* HTTP | gRPC
|
||||
* -----|-----
|
||||
* `GET /v1/messages/123456` | `GetMessage(message_id: "123456")`
|
||||
* `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id:
|
||||
* "123456")`
|
||||
*
|
||||
* ## Rules for HTTP mapping
|
||||
*
|
||||
* 1. Leaf request fields (recursive expansion nested messages in the request
|
||||
* message) are classified into three categories:
|
||||
* - Fields referred by the path template. They are passed via the URL path.
|
||||
* - Fields referred by the [HttpRule.body][google.api.HttpRule.body]. They are passed via the HTTP
|
||||
* request body.
|
||||
* - All other fields are passed via the URL query parameters, and the
|
||||
* parameter name is the field path in the request message. A repeated
|
||||
* field can be represented as multiple query parameters under the same
|
||||
* name.
|
||||
* 2. If [HttpRule.body][google.api.HttpRule.body] is "*", there is no URL query parameter, all fields
|
||||
* are passed via URL path and HTTP request body.
|
||||
* 3. If [HttpRule.body][google.api.HttpRule.body] is omitted, there is no HTTP request body, all
|
||||
* fields are passed via URL path and URL query parameters.
|
||||
*
|
||||
* ### Path template syntax
|
||||
*
|
||||
* Template = "/" Segments [ Verb ] ;
|
||||
* Segments = Segment { "/" Segment } ;
|
||||
* Segment = "*" | "**" | LITERAL | Variable ;
|
||||
* Variable = "{" FieldPath [ "=" Segments ] "}" ;
|
||||
* FieldPath = IDENT { "." IDENT } ;
|
||||
* Verb = ":" LITERAL ;
|
||||
*
|
||||
* The syntax `*` matches a single URL path segment. The syntax `**` matches
|
||||
* zero or more URL path segments, which must be the last part of the URL path
|
||||
* except the `Verb`.
|
||||
*
|
||||
* The syntax `Variable` matches part of the URL path as specified by its
|
||||
* template. A variable template must not contain other variables. If a variable
|
||||
* matches a single path segment, its template may be omitted, e.g. `{var}`
|
||||
* is equivalent to `{var=*}`.
|
||||
*
|
||||
* The syntax `LITERAL` matches literal text in the URL path. If the `LITERAL`
|
||||
* contains any reserved character, such characters should be percent-encoded
|
||||
* before the matching.
|
||||
*
|
||||
* If a variable contains exactly one path segment, such as `"{var}"` or
|
||||
* `"{var=*}"`, when such a variable is expanded into a URL path on the client
|
||||
* side, all characters except `[-_.~0-9a-zA-Z]` are percent-encoded. The
|
||||
* server side does the reverse decoding. Such variables show up in the
|
||||
* [Discovery
|
||||
* Document](https://developers.google.com/discovery/v1/reference/apis) as
|
||||
* `{var}`.
|
||||
*
|
||||
* If a variable contains multiple path segments, such as `"{var=foo/*}"`
|
||||
* or `"{var=**}"`, when such a variable is expanded into a URL path on the
|
||||
* client side, all characters except `[-_.~/0-9a-zA-Z]` are percent-encoded.
|
||||
* The server side does the reverse decoding, except "%2F" and "%2f" are left
|
||||
* unchanged. Such variables show up in the
|
||||
* [Discovery
|
||||
* Document](https://developers.google.com/discovery/v1/reference/apis) as
|
||||
* `{+var}`.
|
||||
*
|
||||
* ## Using gRPC API Service Configuration
|
||||
*
|
||||
* gRPC API Service Configuration (service config) is a configuration language
|
||||
* for configuring a gRPC service to become a user-facing product. The
|
||||
* service config is simply the YAML representation of the `google.api.Service`
|
||||
* proto message.
|
||||
*
|
||||
* As an alternative to annotating your proto file, you can configure gRPC
|
||||
* transcoding in your service config YAML files. You do this by specifying a
|
||||
* `HttpRule` that maps the gRPC method to a REST endpoint, achieving the same
|
||||
* effect as the proto annotation. This can be particularly useful if you
|
||||
* have a proto that is reused in multiple services. Note that any transcoding
|
||||
* specified in the service config will override any matching transcoding
|
||||
* configuration in the proto.
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* http:
|
||||
* rules:
|
||||
* # Selects a gRPC method and applies HttpRule to it.
|
||||
* - selector: example.v1.Messaging.GetMessage
|
||||
* get: /v1/messages/{message_id}/{sub.subfield}
|
||||
*
|
||||
* ## Special notes
|
||||
*
|
||||
* When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the
|
||||
* proto to JSON conversion must follow the [proto3
|
||||
* specification](https://developers.google.com/protocol-buffers/docs/proto3#json).
|
||||
*
|
||||
* While the single segment variable follows the semantics of
|
||||
* [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String
|
||||
* Expansion, the multi segment variable **does not** follow RFC 6570 Section
|
||||
* 3.2.3 Reserved Expansion. The reason is that the Reserved Expansion
|
||||
* does not expand special characters like `?` and `#`, which would lead
|
||||
* to invalid URLs. As the result, gRPC Transcoding uses a custom encoding
|
||||
* for multi segment variables.
|
||||
*
|
||||
* The path variables **must not** refer to any repeated or mapped field,
|
||||
* because client libraries are not capable of handling such variable expansion.
|
||||
*
|
||||
* The path variables **must not** capture the leading "/" character. The reason
|
||||
* is that the most common use case "{var}" does not capture the leading "/"
|
||||
* character. For consistency, all path variables must share the same behavior.
|
||||
*
|
||||
* Repeated message fields must not be mapped to URL query parameters, because
|
||||
* no client library can support such complicated mapping.
|
||||
*
|
||||
* If an API needs to use a JSON array for request or response body, it can map
|
||||
* the request or response body to a repeated field. However, some gRPC
|
||||
* Transcoding implementations may not support this feature.
|
||||
*
|
||||
* @generated from protobuf message google.api.HttpRule
|
||||
*/
|
||||
export interface HttpRule {
|
||||
/**
|
||||
* Selects a method to which this rule applies.
|
||||
*
|
||||
* Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
|
||||
*
|
||||
* @generated from protobuf field: string selector = 1;
|
||||
*/
|
||||
selector: string;
|
||||
/**
|
||||
* @generated from protobuf oneof: pattern
|
||||
*/
|
||||
pattern: {
|
||||
oneofKind: "get";
|
||||
/**
|
||||
* Maps to HTTP GET. Used for listing and getting information about
|
||||
* resources.
|
||||
*
|
||||
* @generated from protobuf field: string get = 2;
|
||||
*/
|
||||
get: string;
|
||||
} | {
|
||||
oneofKind: "put";
|
||||
/**
|
||||
* Maps to HTTP PUT. Used for replacing a resource.
|
||||
*
|
||||
* @generated from protobuf field: string put = 3;
|
||||
*/
|
||||
put: string;
|
||||
} | {
|
||||
oneofKind: "post";
|
||||
/**
|
||||
* Maps to HTTP POST. Used for creating a resource or performing an action.
|
||||
*
|
||||
* @generated from protobuf field: string post = 4;
|
||||
*/
|
||||
post: string;
|
||||
} | {
|
||||
oneofKind: "delete";
|
||||
/**
|
||||
* Maps to HTTP DELETE. Used for deleting a resource.
|
||||
*
|
||||
* @generated from protobuf field: string delete = 5;
|
||||
*/
|
||||
delete: string;
|
||||
} | {
|
||||
oneofKind: "patch";
|
||||
/**
|
||||
* Maps to HTTP PATCH. Used for updating a resource.
|
||||
*
|
||||
* @generated from protobuf field: string patch = 6;
|
||||
*/
|
||||
patch: string;
|
||||
} | {
|
||||
oneofKind: "custom";
|
||||
/**
|
||||
* The custom pattern is used for specifying an HTTP method that is not
|
||||
* included in the `pattern` field, such as HEAD, or "*" to leave the
|
||||
* HTTP method unspecified for this rule. The wild-card rule is useful
|
||||
* for services that provide content to Web (HTML) clients.
|
||||
*
|
||||
* @generated from protobuf field: google.api.CustomHttpPattern custom = 8;
|
||||
*/
|
||||
custom: CustomHttpPattern;
|
||||
} | {
|
||||
oneofKind: undefined;
|
||||
};
|
||||
/**
|
||||
* The name of the request field whose value is mapped to the HTTP request
|
||||
* body, or `*` for mapping all request fields not captured by the path
|
||||
* pattern to the HTTP body, or omitted for not having any HTTP request body.
|
||||
*
|
||||
* NOTE: the referred field must be present at the top-level of the request
|
||||
* message type.
|
||||
*
|
||||
* @generated from protobuf field: string body = 7;
|
||||
*/
|
||||
body: string;
|
||||
/**
|
||||
* Optional. The name of the response field whose value is mapped to the HTTP
|
||||
* response body. When omitted, the entire response message will be used
|
||||
* as the HTTP response body.
|
||||
*
|
||||
* NOTE: The referred field must be present at the top-level of the response
|
||||
* message type.
|
||||
*
|
||||
* @generated from protobuf field: string response_body = 12;
|
||||
*/
|
||||
responseBody: string;
|
||||
/**
|
||||
* Additional HTTP bindings for the selector. Nested bindings must
|
||||
* not contain an `additional_bindings` field themselves (that is,
|
||||
* the nesting may only be one level deep).
|
||||
*
|
||||
* @generated from protobuf field: repeated google.api.HttpRule additional_bindings = 11;
|
||||
*/
|
||||
additionalBindings: HttpRule[];
|
||||
}
|
||||
/**
|
||||
* A custom pattern is used for defining custom HTTP verb.
|
||||
*
|
||||
* @generated from protobuf message google.api.CustomHttpPattern
|
||||
*/
|
||||
export interface CustomHttpPattern {
|
||||
/**
|
||||
* The name of this custom HTTP verb.
|
||||
*
|
||||
* @generated from protobuf field: string kind = 1;
|
||||
*/
|
||||
kind: string;
|
||||
/**
|
||||
* The path matched by this custom verb.
|
||||
*
|
||||
* @generated from protobuf field: string path = 2;
|
||||
*/
|
||||
path: string;
|
||||
}
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Http$Type extends MessageType<Http> {
|
||||
constructor() {
|
||||
super("google.api.Http", [
|
||||
{ no: 1, name: "rules", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => HttpRule },
|
||||
{ no: 2, name: "fully_decode_reserved_expansion", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<Http>): Http {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.rules = [];
|
||||
message.fullyDecodeReservedExpansion = false;
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Http>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Http): Http {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* repeated google.api.HttpRule rules */ 1:
|
||||
message.rules.push(HttpRule.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
case /* bool fully_decode_reserved_expansion */ 2:
|
||||
message.fullyDecodeReservedExpansion = reader.bool();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Http, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* repeated google.api.HttpRule rules = 1; */
|
||||
for (let i = 0; i < message.rules.length; i++)
|
||||
HttpRule.internalBinaryWrite(message.rules[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
|
||||
/* bool fully_decode_reserved_expansion = 2; */
|
||||
if (message.fullyDecodeReservedExpansion !== false)
|
||||
writer.tag(2, WireType.Varint).bool(message.fullyDecodeReservedExpansion);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.api.Http
|
||||
*/
|
||||
export const Http = new Http$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class HttpRule$Type extends MessageType<HttpRule> {
|
||||
constructor() {
|
||||
super("google.api.HttpRule", [
|
||||
{ no: 1, name: "selector", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 2, name: "get", kind: "scalar", oneof: "pattern", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 3, name: "put", kind: "scalar", oneof: "pattern", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 4, name: "post", kind: "scalar", oneof: "pattern", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 5, name: "delete", kind: "scalar", oneof: "pattern", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 6, name: "patch", kind: "scalar", oneof: "pattern", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 8, name: "custom", kind: "message", oneof: "pattern", T: () => CustomHttpPattern },
|
||||
{ no: 7, name: "body", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 12, name: "response_body", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 11, name: "additional_bindings", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => HttpRule }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<HttpRule>): HttpRule {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.selector = "";
|
||||
message.pattern = { oneofKind: undefined };
|
||||
message.body = "";
|
||||
message.responseBody = "";
|
||||
message.additionalBindings = [];
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<HttpRule>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HttpRule): HttpRule {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* string selector */ 1:
|
||||
message.selector = reader.string();
|
||||
break;
|
||||
case /* string get */ 2:
|
||||
message.pattern = {
|
||||
oneofKind: "get",
|
||||
get: reader.string()
|
||||
};
|
||||
break;
|
||||
case /* string put */ 3:
|
||||
message.pattern = {
|
||||
oneofKind: "put",
|
||||
put: reader.string()
|
||||
};
|
||||
break;
|
||||
case /* string post */ 4:
|
||||
message.pattern = {
|
||||
oneofKind: "post",
|
||||
post: reader.string()
|
||||
};
|
||||
break;
|
||||
case /* string delete */ 5:
|
||||
message.pattern = {
|
||||
oneofKind: "delete",
|
||||
delete: reader.string()
|
||||
};
|
||||
break;
|
||||
case /* string patch */ 6:
|
||||
message.pattern = {
|
||||
oneofKind: "patch",
|
||||
patch: reader.string()
|
||||
};
|
||||
break;
|
||||
case /* google.api.CustomHttpPattern custom */ 8:
|
||||
message.pattern = {
|
||||
oneofKind: "custom",
|
||||
custom: CustomHttpPattern.internalBinaryRead(reader, reader.uint32(), options, (message.pattern as any).custom)
|
||||
};
|
||||
break;
|
||||
case /* string body */ 7:
|
||||
message.body = reader.string();
|
||||
break;
|
||||
case /* string response_body */ 12:
|
||||
message.responseBody = reader.string();
|
||||
break;
|
||||
case /* repeated google.api.HttpRule additional_bindings */ 11:
|
||||
message.additionalBindings.push(HttpRule.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: HttpRule, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* string selector = 1; */
|
||||
if (message.selector !== "")
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.selector);
|
||||
/* string get = 2; */
|
||||
if (message.pattern.oneofKind === "get")
|
||||
writer.tag(2, WireType.LengthDelimited).string(message.pattern.get);
|
||||
/* string put = 3; */
|
||||
if (message.pattern.oneofKind === "put")
|
||||
writer.tag(3, WireType.LengthDelimited).string(message.pattern.put);
|
||||
/* string post = 4; */
|
||||
if (message.pattern.oneofKind === "post")
|
||||
writer.tag(4, WireType.LengthDelimited).string(message.pattern.post);
|
||||
/* string delete = 5; */
|
||||
if (message.pattern.oneofKind === "delete")
|
||||
writer.tag(5, WireType.LengthDelimited).string(message.pattern.delete);
|
||||
/* string patch = 6; */
|
||||
if (message.pattern.oneofKind === "patch")
|
||||
writer.tag(6, WireType.LengthDelimited).string(message.pattern.patch);
|
||||
/* google.api.CustomHttpPattern custom = 8; */
|
||||
if (message.pattern.oneofKind === "custom")
|
||||
CustomHttpPattern.internalBinaryWrite(message.pattern.custom, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
|
||||
/* string body = 7; */
|
||||
if (message.body !== "")
|
||||
writer.tag(7, WireType.LengthDelimited).string(message.body);
|
||||
/* string response_body = 12; */
|
||||
if (message.responseBody !== "")
|
||||
writer.tag(12, WireType.LengthDelimited).string(message.responseBody);
|
||||
/* repeated google.api.HttpRule additional_bindings = 11; */
|
||||
for (let i = 0; i < message.additionalBindings.length; i++)
|
||||
HttpRule.internalBinaryWrite(message.additionalBindings[i], writer.tag(11, WireType.LengthDelimited).fork(), options).join();
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.api.HttpRule
|
||||
*/
|
||||
export const HttpRule = new HttpRule$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class CustomHttpPattern$Type extends MessageType<CustomHttpPattern> {
|
||||
constructor() {
|
||||
super("google.api.CustomHttpPattern", [
|
||||
{ no: 1, name: "kind", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 2, name: "path", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<CustomHttpPattern>): CustomHttpPattern {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.kind = "";
|
||||
message.path = "";
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<CustomHttpPattern>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CustomHttpPattern): CustomHttpPattern {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* string kind */ 1:
|
||||
message.kind = reader.string();
|
||||
break;
|
||||
case /* string path */ 2:
|
||||
message.path = reader.string();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: CustomHttpPattern, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* string kind = 1; */
|
||||
if (message.kind !== "")
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.kind);
|
||||
/* string path = 2; */
|
||||
if (message.path !== "")
|
||||
writer.tag(2, WireType.LengthDelimited).string(message.path);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.api.CustomHttpPattern
|
||||
*/
|
||||
export const CustomHttpPattern = new CustomHttpPattern$Type();
|
||||
155
google/api/httpbody.ts
Normal file
155
google/api/httpbody.ts
Normal file
@@ -0,0 +1,155 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/api/httpbody.proto" (package "google.api", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Copyright 2020 Google LLC
|
||||
//
|
||||
// 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 type { BinaryWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryWriter } from "@protobuf-ts/runtime";
|
||||
import { WireType } from "@protobuf-ts/runtime";
|
||||
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryReader } from "@protobuf-ts/runtime";
|
||||
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
|
||||
import type { PartialMessage } from "@protobuf-ts/runtime";
|
||||
import { reflectionMergePartial } from "@protobuf-ts/runtime";
|
||||
import { MessageType } from "@protobuf-ts/runtime";
|
||||
import { Any } from "../protobuf/any";
|
||||
/**
|
||||
* Message that represents an arbitrary HTTP body. It should only be used for
|
||||
* payload formats that can't be represented as JSON, such as raw binary or
|
||||
* an HTML page.
|
||||
*
|
||||
*
|
||||
* This message can be used both in streaming and non-streaming API methods in
|
||||
* the request as well as the response.
|
||||
*
|
||||
* It can be used as a top-level request field, which is convenient if one
|
||||
* wants to extract parameters from either the URL or HTTP template into the
|
||||
* request fields and also want access to the raw HTTP body.
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* message GetResourceRequest {
|
||||
* // A unique request id.
|
||||
* string request_id = 1;
|
||||
*
|
||||
* // The raw HTTP body is bound to this field.
|
||||
* google.api.HttpBody http_body = 2;
|
||||
* }
|
||||
*
|
||||
* service ResourceService {
|
||||
* rpc GetResource(GetResourceRequest) returns (google.api.HttpBody);
|
||||
* rpc UpdateResource(google.api.HttpBody) returns
|
||||
* (google.protobuf.Empty);
|
||||
* }
|
||||
*
|
||||
* Example with streaming methods:
|
||||
*
|
||||
* service CaldavService {
|
||||
* rpc GetCalendar(stream google.api.HttpBody)
|
||||
* returns (stream google.api.HttpBody);
|
||||
* rpc UpdateCalendar(stream google.api.HttpBody)
|
||||
* returns (stream google.api.HttpBody);
|
||||
* }
|
||||
*
|
||||
* Use of this type only changes how the request and response bodies are
|
||||
* handled, all other features will continue to work unchanged.
|
||||
*
|
||||
* @generated from protobuf message google.api.HttpBody
|
||||
*/
|
||||
export interface HttpBody {
|
||||
/**
|
||||
* The HTTP Content-Type header value specifying the content type of the body.
|
||||
*
|
||||
* @generated from protobuf field: string content_type = 1;
|
||||
*/
|
||||
contentType: string;
|
||||
/**
|
||||
* The HTTP request/response body as raw binary.
|
||||
*
|
||||
* @generated from protobuf field: bytes data = 2;
|
||||
*/
|
||||
data: Uint8Array;
|
||||
/**
|
||||
* Application specific response metadata. Must be set in the first response
|
||||
* for streaming APIs.
|
||||
*
|
||||
* @generated from protobuf field: repeated google.protobuf.Any extensions = 3;
|
||||
*/
|
||||
extensions: Any[];
|
||||
}
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class HttpBody$Type extends MessageType<HttpBody> {
|
||||
constructor() {
|
||||
super("google.api.HttpBody", [
|
||||
{ no: 1, name: "content_type", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 2, name: "data", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
|
||||
{ no: 3, name: "extensions", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Any }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<HttpBody>): HttpBody {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.contentType = "";
|
||||
message.data = new Uint8Array(0);
|
||||
message.extensions = [];
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<HttpBody>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HttpBody): HttpBody {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* string content_type */ 1:
|
||||
message.contentType = reader.string();
|
||||
break;
|
||||
case /* bytes data */ 2:
|
||||
message.data = reader.bytes();
|
||||
break;
|
||||
case /* repeated google.protobuf.Any extensions */ 3:
|
||||
message.extensions.push(Any.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: HttpBody, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* string content_type = 1; */
|
||||
if (message.contentType !== "")
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.contentType);
|
||||
/* bytes data = 2; */
|
||||
if (message.data.length)
|
||||
writer.tag(2, WireType.LengthDelimited).bytes(message.data);
|
||||
/* repeated google.protobuf.Any extensions = 3; */
|
||||
for (let i = 0; i < message.extensions.length; i++)
|
||||
Any.internalBinaryWrite(message.extensions[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.api.HttpBody
|
||||
*/
|
||||
export const HttpBody = new HttpBody$Type();
|
||||
319
google/protobuf/any.ts
Normal file
319
google/protobuf/any.ts
Normal file
@@ -0,0 +1,319 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/protobuf/any.proto" (package "google.protobuf", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryWriter } from "@protobuf-ts/runtime";
|
||||
import { WireType } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryReader } from "@protobuf-ts/runtime";
|
||||
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
|
||||
import type { PartialMessage } from "@protobuf-ts/runtime";
|
||||
import { reflectionMergePartial } from "@protobuf-ts/runtime";
|
||||
import { isJsonObject } from "@protobuf-ts/runtime";
|
||||
import { typeofJsonValue } from "@protobuf-ts/runtime";
|
||||
import type { JsonValue } from "@protobuf-ts/runtime";
|
||||
import { jsonWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { JsonReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { JsonWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { IMessageType } from "@protobuf-ts/runtime";
|
||||
import { MessageType } from "@protobuf-ts/runtime";
|
||||
/**
|
||||
* `Any` contains an arbitrary serialized protocol buffer message along with a
|
||||
* URL that describes the type of the serialized message.
|
||||
*
|
||||
* Protobuf library provides support to pack/unpack Any values in the form
|
||||
* of utility functions or additional generated methods of the Any type.
|
||||
*
|
||||
* Example 1: Pack and unpack a message in C++.
|
||||
*
|
||||
* Foo foo = ...;
|
||||
* Any any;
|
||||
* any.PackFrom(foo);
|
||||
* ...
|
||||
* if (any.UnpackTo(&foo)) {
|
||||
* ...
|
||||
* }
|
||||
*
|
||||
* Example 2: Pack and unpack a message in Java.
|
||||
*
|
||||
* Foo foo = ...;
|
||||
* Any any = Any.pack(foo);
|
||||
* ...
|
||||
* if (any.is(Foo.class)) {
|
||||
* foo = any.unpack(Foo.class);
|
||||
* }
|
||||
*
|
||||
* Example 3: Pack and unpack a message in Python.
|
||||
*
|
||||
* foo = Foo(...)
|
||||
* any = Any()
|
||||
* any.Pack(foo)
|
||||
* ...
|
||||
* if any.Is(Foo.DESCRIPTOR):
|
||||
* any.Unpack(foo)
|
||||
* ...
|
||||
*
|
||||
* Example 4: Pack and unpack a message in Go
|
||||
*
|
||||
* foo := &pb.Foo{...}
|
||||
* any, err := ptypes.MarshalAny(foo)
|
||||
* ...
|
||||
* foo := &pb.Foo{}
|
||||
* if err := ptypes.UnmarshalAny(any, foo); err != nil {
|
||||
* ...
|
||||
* }
|
||||
*
|
||||
* The pack methods provided by protobuf library will by default use
|
||||
* 'type.googleapis.com/full.type.name' as the type URL and the unpack
|
||||
* methods only use the fully qualified type name after the last '/'
|
||||
* in the type URL, for example "foo.bar.com/x/y.z" will yield type
|
||||
* name "y.z".
|
||||
*
|
||||
*
|
||||
* JSON
|
||||
* ====
|
||||
* The JSON representation of an `Any` value uses the regular
|
||||
* representation of the deserialized, embedded message, with an
|
||||
* additional field `@type` which contains the type URL. Example:
|
||||
*
|
||||
* package google.profile;
|
||||
* message Person {
|
||||
* string first_name = 1;
|
||||
* string last_name = 2;
|
||||
* }
|
||||
*
|
||||
* {
|
||||
* "@type": "type.googleapis.com/google.profile.Person",
|
||||
* "firstName": <string>,
|
||||
* "lastName": <string>
|
||||
* }
|
||||
*
|
||||
* If the embedded message type is well-known and has a custom JSON
|
||||
* representation, that representation will be embedded adding a field
|
||||
* `value` which holds the custom JSON in addition to the `@type`
|
||||
* field. Example (for message [google.protobuf.Duration][]):
|
||||
*
|
||||
* {
|
||||
* "@type": "type.googleapis.com/google.protobuf.Duration",
|
||||
* "value": "1.212s"
|
||||
* }
|
||||
*
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Any
|
||||
*/
|
||||
export interface Any {
|
||||
/**
|
||||
* A URL/resource name that uniquely identifies the type of the serialized
|
||||
* protocol buffer message. This string must contain at least
|
||||
* one "/" character. The last segment of the URL's path must represent
|
||||
* the fully qualified name of the type (as in
|
||||
* `path/google.protobuf.Duration`). The name should be in a canonical form
|
||||
* (e.g., leading "." is not accepted).
|
||||
*
|
||||
* In practice, teams usually precompile into the binary all types that they
|
||||
* expect it to use in the context of Any. However, for URLs which use the
|
||||
* scheme `http`, `https`, or no scheme, one can optionally set up a type
|
||||
* server that maps type URLs to message definitions as follows:
|
||||
*
|
||||
* * If no scheme is provided, `https` is assumed.
|
||||
* * An HTTP GET on the URL must yield a [google.protobuf.Type][]
|
||||
* value in binary format, or produce an error.
|
||||
* * Applications are allowed to cache lookup results based on the
|
||||
* URL, or have them precompiled into a binary to avoid any
|
||||
* lookup. Therefore, binary compatibility needs to be preserved
|
||||
* on changes to types. (Use versioned type names to manage
|
||||
* breaking changes.)
|
||||
*
|
||||
* Note: this functionality is not currently available in the official
|
||||
* protobuf release, and it is not used for type URLs beginning with
|
||||
* type.googleapis.com.
|
||||
*
|
||||
* Schemes other than `http`, `https` (or the empty scheme) might be
|
||||
* used with implementation specific semantics.
|
||||
*
|
||||
*
|
||||
* @generated from protobuf field: string type_url = 1;
|
||||
*/
|
||||
typeUrl: string;
|
||||
/**
|
||||
* Must be a valid serialized protocol buffer of the above specified type.
|
||||
*
|
||||
* @generated from protobuf field: bytes value = 2;
|
||||
*/
|
||||
value: Uint8Array;
|
||||
}
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Any$Type extends MessageType<Any> {
|
||||
constructor() {
|
||||
super("google.protobuf.Any", [
|
||||
{ no: 1, name: "type_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 2, name: "value", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Pack the message into a new `Any`.
|
||||
*
|
||||
* Uses 'type.googleapis.com/full.type.name' as the type URL.
|
||||
*/
|
||||
pack<T extends object>(message: T, type: IMessageType<T>): Any {
|
||||
return {
|
||||
typeUrl: this.typeNameToUrl(type.typeName), value: type.toBinary(message),
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Unpack the message from the `Any`.
|
||||
*/
|
||||
unpack<T extends object>(any: Any, type: IMessageType<T>, options?: Partial<BinaryReadOptions>): T {
|
||||
if (!this.contains(any, type))
|
||||
throw new Error("Cannot unpack google.protobuf.Any with typeUrl '" + any.typeUrl + "' as " + type.typeName + ".");
|
||||
return type.fromBinary(any.value, options);
|
||||
}
|
||||
/**
|
||||
* Does the given `Any` contain a packed message of the given type?
|
||||
*/
|
||||
contains(any: Any, type: IMessageType<any> | string): boolean {
|
||||
if (!any.typeUrl.length)
|
||||
return false;
|
||||
let wants = typeof type == "string" ? type : type.typeName;
|
||||
let has = this.typeUrlToName(any.typeUrl);
|
||||
return wants === has;
|
||||
}
|
||||
/**
|
||||
* Convert the message to canonical JSON value.
|
||||
*
|
||||
* You have to provide the `typeRegistry` option so that the
|
||||
* packed message can be converted to JSON.
|
||||
*
|
||||
* The `typeRegistry` option is also required to read
|
||||
* `google.protobuf.Any` from JSON format.
|
||||
*/
|
||||
internalJsonWrite(any: Any, options: JsonWriteOptions): JsonValue {
|
||||
if (any.typeUrl === "")
|
||||
return {};
|
||||
let typeName = this.typeUrlToName(any.typeUrl);
|
||||
let opt = jsonWriteOptions(options);
|
||||
let type = opt.typeRegistry?.find(t => t.typeName === typeName);
|
||||
if (!type)
|
||||
throw new globalThis.Error("Unable to convert google.protobuf.Any with typeUrl '" + any.typeUrl + "' to JSON. The specified type " + typeName + " is not available in the type registry.");
|
||||
let value = type.fromBinary(any.value, { readUnknownField: false });
|
||||
let json = type.internalJsonWrite(value, opt);
|
||||
if (typeName.startsWith("google.protobuf.") || !isJsonObject(json))
|
||||
json = { value: json };
|
||||
json["@type"] = any.typeUrl;
|
||||
return json;
|
||||
}
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Any): Any {
|
||||
if (!isJsonObject(json))
|
||||
throw new globalThis.Error("Unable to parse google.protobuf.Any from JSON " + typeofJsonValue(json) + ".");
|
||||
if (typeof json["@type"] != "string" || json["@type"] == "")
|
||||
return this.create();
|
||||
let typeName = this.typeUrlToName(json["@type"]);
|
||||
let type = options?.typeRegistry?.find(t => t.typeName == typeName);
|
||||
if (!type)
|
||||
throw new globalThis.Error("Unable to parse google.protobuf.Any from JSON. The specified type " + typeName + " is not available in the type registry.");
|
||||
let value;
|
||||
if (typeName.startsWith("google.protobuf.") && json.hasOwnProperty("value"))
|
||||
value = type.fromJson(json["value"], options);
|
||||
else {
|
||||
let copy = Object.assign({}, json);
|
||||
delete copy["@type"];
|
||||
value = type.fromJson(copy, options);
|
||||
}
|
||||
if (target === undefined)
|
||||
target = this.create();
|
||||
target.typeUrl = json["@type"];
|
||||
target.value = type.toBinary(value);
|
||||
return target;
|
||||
}
|
||||
typeNameToUrl(name: string): string {
|
||||
if (!name.length)
|
||||
throw new Error("invalid type name: " + name);
|
||||
return "type.googleapis.com/" + name;
|
||||
}
|
||||
typeUrlToName(url: string): string {
|
||||
if (!url.length)
|
||||
throw new Error("invalid type url: " + url);
|
||||
let slash = url.lastIndexOf("/");
|
||||
let name = slash > 0 ? url.substring(slash + 1) : url;
|
||||
if (!name.length)
|
||||
throw new Error("invalid type url: " + url);
|
||||
return name;
|
||||
}
|
||||
create(value?: PartialMessage<Any>): Any {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.typeUrl = "";
|
||||
message.value = new Uint8Array(0);
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Any>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Any): Any {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* string type_url */ 1:
|
||||
message.typeUrl = reader.string();
|
||||
break;
|
||||
case /* bytes value */ 2:
|
||||
message.value = reader.bytes();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Any, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* string type_url = 1; */
|
||||
if (message.typeUrl !== "")
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.typeUrl);
|
||||
/* bytes value = 2; */
|
||||
if (message.value.length)
|
||||
writer.tag(2, WireType.LengthDelimited).bytes(message.value);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Any
|
||||
*/
|
||||
export const Any = new Any$Type();
|
||||
515
google/protobuf/api.ts
Normal file
515
google/protobuf/api.ts
Normal file
@@ -0,0 +1,515 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/protobuf/api.proto" (package "google.protobuf", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryWriter } from "@protobuf-ts/runtime";
|
||||
import { WireType } from "@protobuf-ts/runtime";
|
||||
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryReader } from "@protobuf-ts/runtime";
|
||||
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
|
||||
import type { PartialMessage } from "@protobuf-ts/runtime";
|
||||
import { reflectionMergePartial } from "@protobuf-ts/runtime";
|
||||
import { MessageType } from "@protobuf-ts/runtime";
|
||||
import { Syntax } from "./type";
|
||||
import { SourceContext } from "./source_context";
|
||||
import { Option } from "./type";
|
||||
/**
|
||||
* Api is a light-weight descriptor for an API Interface.
|
||||
*
|
||||
* Interfaces are also described as "protocol buffer services" in some contexts,
|
||||
* such as by the "service" keyword in a .proto file, but they are different
|
||||
* from API Services, which represent a concrete implementation of an interface
|
||||
* as opposed to simply a description of methods and bindings. They are also
|
||||
* sometimes simply referred to as "APIs" in other contexts, such as the name of
|
||||
* this message itself. See https://cloud.google.com/apis/design/glossary for
|
||||
* detailed terminology.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Api
|
||||
*/
|
||||
export interface Api {
|
||||
/**
|
||||
* The fully qualified name of this interface, including package name
|
||||
* followed by the interface's simple name.
|
||||
*
|
||||
* @generated from protobuf field: string name = 1;
|
||||
*/
|
||||
name: string;
|
||||
/**
|
||||
* The methods of this interface, in unspecified order.
|
||||
*
|
||||
* @generated from protobuf field: repeated google.protobuf.Method methods = 2;
|
||||
*/
|
||||
methods: Method[];
|
||||
/**
|
||||
* Any metadata attached to the interface.
|
||||
*
|
||||
* @generated from protobuf field: repeated google.protobuf.Option options = 3;
|
||||
*/
|
||||
options: Option[];
|
||||
/**
|
||||
* A version string for this interface. If specified, must have the form
|
||||
* `major-version.minor-version`, as in `1.10`. If the minor version is
|
||||
* omitted, it defaults to zero. If the entire version field is empty, the
|
||||
* major version is derived from the package name, as outlined below. If the
|
||||
* field is not empty, the version in the package name will be verified to be
|
||||
* consistent with what is provided here.
|
||||
*
|
||||
* The versioning schema uses [semantic
|
||||
* versioning](http://semver.org) where the major version number
|
||||
* indicates a breaking change and the minor version an additive,
|
||||
* non-breaking change. Both version numbers are signals to users
|
||||
* what to expect from different versions, and should be carefully
|
||||
* chosen based on the product plan.
|
||||
*
|
||||
* The major version is also reflected in the package name of the
|
||||
* interface, which must end in `v<major-version>`, as in
|
||||
* `google.feature.v1`. For major versions 0 and 1, the suffix can
|
||||
* be omitted. Zero major versions must only be used for
|
||||
* experimental, non-GA interfaces.
|
||||
*
|
||||
*
|
||||
*
|
||||
* @generated from protobuf field: string version = 4;
|
||||
*/
|
||||
version: string;
|
||||
/**
|
||||
* Source context for the protocol buffer service represented by this
|
||||
* message.
|
||||
*
|
||||
* @generated from protobuf field: google.protobuf.SourceContext source_context = 5;
|
||||
*/
|
||||
sourceContext?: SourceContext;
|
||||
/**
|
||||
* Included interfaces. See [Mixin][].
|
||||
*
|
||||
* @generated from protobuf field: repeated google.protobuf.Mixin mixins = 6;
|
||||
*/
|
||||
mixins: Mixin[];
|
||||
/**
|
||||
* The source syntax of the service.
|
||||
*
|
||||
* @generated from protobuf field: google.protobuf.Syntax syntax = 7;
|
||||
*/
|
||||
syntax: Syntax;
|
||||
}
|
||||
/**
|
||||
* Method represents a method of an API interface.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Method
|
||||
*/
|
||||
export interface Method {
|
||||
/**
|
||||
* The simple name of this method.
|
||||
*
|
||||
* @generated from protobuf field: string name = 1;
|
||||
*/
|
||||
name: string;
|
||||
/**
|
||||
* A URL of the input message type.
|
||||
*
|
||||
* @generated from protobuf field: string request_type_url = 2;
|
||||
*/
|
||||
requestTypeUrl: string;
|
||||
/**
|
||||
* If true, the request is streamed.
|
||||
*
|
||||
* @generated from protobuf field: bool request_streaming = 3;
|
||||
*/
|
||||
requestStreaming: boolean;
|
||||
/**
|
||||
* The URL of the output message type.
|
||||
*
|
||||
* @generated from protobuf field: string response_type_url = 4;
|
||||
*/
|
||||
responseTypeUrl: string;
|
||||
/**
|
||||
* If true, the response is streamed.
|
||||
*
|
||||
* @generated from protobuf field: bool response_streaming = 5;
|
||||
*/
|
||||
responseStreaming: boolean;
|
||||
/**
|
||||
* Any metadata attached to the method.
|
||||
*
|
||||
* @generated from protobuf field: repeated google.protobuf.Option options = 6;
|
||||
*/
|
||||
options: Option[];
|
||||
/**
|
||||
* The source syntax of this method.
|
||||
*
|
||||
* @generated from protobuf field: google.protobuf.Syntax syntax = 7;
|
||||
*/
|
||||
syntax: Syntax;
|
||||
}
|
||||
/**
|
||||
* Declares an API Interface to be included in this interface. The including
|
||||
* interface must redeclare all the methods from the included interface, but
|
||||
* documentation and options are inherited as follows:
|
||||
*
|
||||
* - If after comment and whitespace stripping, the documentation
|
||||
* string of the redeclared method is empty, it will be inherited
|
||||
* from the original method.
|
||||
*
|
||||
* - Each annotation belonging to the service config (http,
|
||||
* visibility) which is not set in the redeclared method will be
|
||||
* inherited.
|
||||
*
|
||||
* - If an http annotation is inherited, the path pattern will be
|
||||
* modified as follows. Any version prefix will be replaced by the
|
||||
* version of the including interface plus the [root][] path if
|
||||
* specified.
|
||||
*
|
||||
* Example of a simple mixin:
|
||||
*
|
||||
* package google.acl.v1;
|
||||
* service AccessControl {
|
||||
* // Get the underlying ACL object.
|
||||
* rpc GetAcl(GetAclRequest) returns (Acl) {
|
||||
* option (google.api.http).get = "/v1/{resource=**}:getAcl";
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* package google.storage.v2;
|
||||
* service Storage {
|
||||
* rpc GetAcl(GetAclRequest) returns (Acl);
|
||||
*
|
||||
* // Get a data record.
|
||||
* rpc GetData(GetDataRequest) returns (Data) {
|
||||
* option (google.api.http).get = "/v2/{resource=**}";
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* Example of a mixin configuration:
|
||||
*
|
||||
* apis:
|
||||
* - name: google.storage.v2.Storage
|
||||
* mixins:
|
||||
* - name: google.acl.v1.AccessControl
|
||||
*
|
||||
* The mixin construct implies that all methods in `AccessControl` are
|
||||
* also declared with same name and request/response types in
|
||||
* `Storage`. A documentation generator or annotation processor will
|
||||
* see the effective `Storage.GetAcl` method after inherting
|
||||
* documentation and annotations as follows:
|
||||
*
|
||||
* service Storage {
|
||||
* // Get the underlying ACL object.
|
||||
* rpc GetAcl(GetAclRequest) returns (Acl) {
|
||||
* option (google.api.http).get = "/v2/{resource=**}:getAcl";
|
||||
* }
|
||||
* ...
|
||||
* }
|
||||
*
|
||||
* Note how the version in the path pattern changed from `v1` to `v2`.
|
||||
*
|
||||
* If the `root` field in the mixin is specified, it should be a
|
||||
* relative path under which inherited HTTP paths are placed. Example:
|
||||
*
|
||||
* apis:
|
||||
* - name: google.storage.v2.Storage
|
||||
* mixins:
|
||||
* - name: google.acl.v1.AccessControl
|
||||
* root: acls
|
||||
*
|
||||
* This implies the following inherited HTTP annotation:
|
||||
*
|
||||
* service Storage {
|
||||
* // Get the underlying ACL object.
|
||||
* rpc GetAcl(GetAclRequest) returns (Acl) {
|
||||
* option (google.api.http).get = "/v2/acls/{resource=**}:getAcl";
|
||||
* }
|
||||
* ...
|
||||
* }
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Mixin
|
||||
*/
|
||||
export interface Mixin {
|
||||
/**
|
||||
* The fully qualified name of the interface which is included.
|
||||
*
|
||||
* @generated from protobuf field: string name = 1;
|
||||
*/
|
||||
name: string;
|
||||
/**
|
||||
* If non-empty specifies a path under which inherited HTTP paths
|
||||
* are rooted.
|
||||
*
|
||||
* @generated from protobuf field: string root = 2;
|
||||
*/
|
||||
root: string;
|
||||
}
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Api$Type extends MessageType<Api> {
|
||||
constructor() {
|
||||
super("google.protobuf.Api", [
|
||||
{ no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 2, name: "methods", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Method },
|
||||
{ no: 3, name: "options", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Option },
|
||||
{ no: 4, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 5, name: "source_context", kind: "message", T: () => SourceContext },
|
||||
{ no: 6, name: "mixins", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Mixin },
|
||||
{ no: 7, name: "syntax", kind: "enum", T: () => ["google.protobuf.Syntax", Syntax, "SYNTAX_"] }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<Api>): Api {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.name = "";
|
||||
message.methods = [];
|
||||
message.options = [];
|
||||
message.version = "";
|
||||
message.mixins = [];
|
||||
message.syntax = 0;
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Api>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Api): Api {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* string name */ 1:
|
||||
message.name = reader.string();
|
||||
break;
|
||||
case /* repeated google.protobuf.Method methods */ 2:
|
||||
message.methods.push(Method.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
case /* repeated google.protobuf.Option options */ 3:
|
||||
message.options.push(Option.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
case /* string version */ 4:
|
||||
message.version = reader.string();
|
||||
break;
|
||||
case /* google.protobuf.SourceContext source_context */ 5:
|
||||
message.sourceContext = SourceContext.internalBinaryRead(reader, reader.uint32(), options, message.sourceContext);
|
||||
break;
|
||||
case /* repeated google.protobuf.Mixin mixins */ 6:
|
||||
message.mixins.push(Mixin.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
case /* google.protobuf.Syntax syntax */ 7:
|
||||
message.syntax = reader.int32();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Api, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* string name = 1; */
|
||||
if (message.name !== "")
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.name);
|
||||
/* repeated google.protobuf.Method methods = 2; */
|
||||
for (let i = 0; i < message.methods.length; i++)
|
||||
Method.internalBinaryWrite(message.methods[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
|
||||
/* repeated google.protobuf.Option options = 3; */
|
||||
for (let i = 0; i < message.options.length; i++)
|
||||
Option.internalBinaryWrite(message.options[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
||||
/* string version = 4; */
|
||||
if (message.version !== "")
|
||||
writer.tag(4, WireType.LengthDelimited).string(message.version);
|
||||
/* google.protobuf.SourceContext source_context = 5; */
|
||||
if (message.sourceContext)
|
||||
SourceContext.internalBinaryWrite(message.sourceContext, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
|
||||
/* repeated google.protobuf.Mixin mixins = 6; */
|
||||
for (let i = 0; i < message.mixins.length; i++)
|
||||
Mixin.internalBinaryWrite(message.mixins[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join();
|
||||
/* google.protobuf.Syntax syntax = 7; */
|
||||
if (message.syntax !== 0)
|
||||
writer.tag(7, WireType.Varint).int32(message.syntax);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Api
|
||||
*/
|
||||
export const Api = new Api$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Method$Type extends MessageType<Method> {
|
||||
constructor() {
|
||||
super("google.protobuf.Method", [
|
||||
{ no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 2, name: "request_type_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 3, name: "request_streaming", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
|
||||
{ no: 4, name: "response_type_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 5, name: "response_streaming", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
|
||||
{ no: 6, name: "options", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Option },
|
||||
{ no: 7, name: "syntax", kind: "enum", T: () => ["google.protobuf.Syntax", Syntax, "SYNTAX_"] }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<Method>): Method {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.name = "";
|
||||
message.requestTypeUrl = "";
|
||||
message.requestStreaming = false;
|
||||
message.responseTypeUrl = "";
|
||||
message.responseStreaming = false;
|
||||
message.options = [];
|
||||
message.syntax = 0;
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Method>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Method): Method {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* string name */ 1:
|
||||
message.name = reader.string();
|
||||
break;
|
||||
case /* string request_type_url */ 2:
|
||||
message.requestTypeUrl = reader.string();
|
||||
break;
|
||||
case /* bool request_streaming */ 3:
|
||||
message.requestStreaming = reader.bool();
|
||||
break;
|
||||
case /* string response_type_url */ 4:
|
||||
message.responseTypeUrl = reader.string();
|
||||
break;
|
||||
case /* bool response_streaming */ 5:
|
||||
message.responseStreaming = reader.bool();
|
||||
break;
|
||||
case /* repeated google.protobuf.Option options */ 6:
|
||||
message.options.push(Option.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
case /* google.protobuf.Syntax syntax */ 7:
|
||||
message.syntax = reader.int32();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Method, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* string name = 1; */
|
||||
if (message.name !== "")
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.name);
|
||||
/* string request_type_url = 2; */
|
||||
if (message.requestTypeUrl !== "")
|
||||
writer.tag(2, WireType.LengthDelimited).string(message.requestTypeUrl);
|
||||
/* bool request_streaming = 3; */
|
||||
if (message.requestStreaming !== false)
|
||||
writer.tag(3, WireType.Varint).bool(message.requestStreaming);
|
||||
/* string response_type_url = 4; */
|
||||
if (message.responseTypeUrl !== "")
|
||||
writer.tag(4, WireType.LengthDelimited).string(message.responseTypeUrl);
|
||||
/* bool response_streaming = 5; */
|
||||
if (message.responseStreaming !== false)
|
||||
writer.tag(5, WireType.Varint).bool(message.responseStreaming);
|
||||
/* repeated google.protobuf.Option options = 6; */
|
||||
for (let i = 0; i < message.options.length; i++)
|
||||
Option.internalBinaryWrite(message.options[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join();
|
||||
/* google.protobuf.Syntax syntax = 7; */
|
||||
if (message.syntax !== 0)
|
||||
writer.tag(7, WireType.Varint).int32(message.syntax);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Method
|
||||
*/
|
||||
export const Method = new Method$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Mixin$Type extends MessageType<Mixin> {
|
||||
constructor() {
|
||||
super("google.protobuf.Mixin", [
|
||||
{ no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 2, name: "root", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<Mixin>): Mixin {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.name = "";
|
||||
message.root = "";
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Mixin>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Mixin): Mixin {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* string name */ 1:
|
||||
message.name = reader.string();
|
||||
break;
|
||||
case /* string root */ 2:
|
||||
message.root = reader.string();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Mixin, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* string name = 1; */
|
||||
if (message.name !== "")
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.name);
|
||||
/* string root = 2; */
|
||||
if (message.root !== "")
|
||||
writer.tag(2, WireType.LengthDelimited).string(message.root);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Mixin
|
||||
*/
|
||||
export const Mixin = new Mixin$Type();
|
||||
478
google/protobuf/compiler/plugin.ts
Normal file
478
google/protobuf/compiler/plugin.ts
Normal file
@@ -0,0 +1,478 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/protobuf/compiler/plugin.proto" (package "google.protobuf.compiler", syntax proto2)
|
||||
// tslint:disable
|
||||
//
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
//
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
//
|
||||
// WARNING: The plugin interface is currently EXPERIMENTAL and is subject to
|
||||
// change.
|
||||
//
|
||||
// protoc (aka the Protocol Compiler) can be extended via plugins. A plugin is
|
||||
// just a program that reads a CodeGeneratorRequest from stdin and writes a
|
||||
// CodeGeneratorResponse to stdout.
|
||||
//
|
||||
// Plugins written using C++ can use google/protobuf/compiler/plugin.h instead
|
||||
// of dealing with the raw protocol defined here.
|
||||
//
|
||||
// A plugin executable needs only to be placed somewhere in the path. The
|
||||
// plugin should be named "protoc-gen-$NAME", and will then be used when the
|
||||
// flag "--${NAME}_out" is passed to protoc.
|
||||
//
|
||||
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryWriter } from "@protobuf-ts/runtime";
|
||||
import { WireType } from "@protobuf-ts/runtime";
|
||||
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryReader } from "@protobuf-ts/runtime";
|
||||
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
|
||||
import type { PartialMessage } from "@protobuf-ts/runtime";
|
||||
import { reflectionMergePartial } from "@protobuf-ts/runtime";
|
||||
import { MessageType } from "@protobuf-ts/runtime";
|
||||
import { FileDescriptorProto } from "../descriptor";
|
||||
/**
|
||||
* The version number of protocol compiler.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.compiler.Version
|
||||
*/
|
||||
export interface Version {
|
||||
/**
|
||||
* @generated from protobuf field: optional int32 major = 1;
|
||||
*/
|
||||
major?: number;
|
||||
/**
|
||||
* @generated from protobuf field: optional int32 minor = 2;
|
||||
*/
|
||||
minor?: number;
|
||||
/**
|
||||
* @generated from protobuf field: optional int32 patch = 3;
|
||||
*/
|
||||
patch?: number;
|
||||
/**
|
||||
* A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
|
||||
* be empty for mainline stable releases.
|
||||
*
|
||||
* @generated from protobuf field: optional string suffix = 4;
|
||||
*/
|
||||
suffix?: string;
|
||||
}
|
||||
/**
|
||||
* An encoded CodeGeneratorRequest is written to the plugin's stdin.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.compiler.CodeGeneratorRequest
|
||||
*/
|
||||
export interface CodeGeneratorRequest {
|
||||
/**
|
||||
* The .proto files that were explicitly listed on the command-line. The
|
||||
* code generator should generate code only for these files. Each file's
|
||||
* descriptor will be included in proto_file, below.
|
||||
*
|
||||
* @generated from protobuf field: repeated string file_to_generate = 1;
|
||||
*/
|
||||
fileToGenerate: string[];
|
||||
/**
|
||||
* The generator parameter passed on the command-line.
|
||||
*
|
||||
* @generated from protobuf field: optional string parameter = 2;
|
||||
*/
|
||||
parameter?: string;
|
||||
/**
|
||||
* FileDescriptorProtos for all files in files_to_generate and everything
|
||||
* they import. The files will appear in topological order, so each file
|
||||
* appears before any file that imports it.
|
||||
*
|
||||
* protoc guarantees that all proto_files will be written after
|
||||
* the fields above, even though this is not technically guaranteed by the
|
||||
* protobuf wire format. This theoretically could allow a plugin to stream
|
||||
* in the FileDescriptorProtos and handle them one by one rather than read
|
||||
* the entire set into memory at once. However, as of this writing, this
|
||||
* is not similarly optimized on protoc's end -- it will store all fields in
|
||||
* memory at once before sending them to the plugin.
|
||||
*
|
||||
* Type names of fields and extensions in the FileDescriptorProto are always
|
||||
* fully qualified.
|
||||
*
|
||||
* @generated from protobuf field: repeated google.protobuf.FileDescriptorProto proto_file = 15;
|
||||
*/
|
||||
protoFile: FileDescriptorProto[];
|
||||
/**
|
||||
* The version number of protocol compiler.
|
||||
*
|
||||
* @generated from protobuf field: optional google.protobuf.compiler.Version compiler_version = 3;
|
||||
*/
|
||||
compilerVersion?: Version;
|
||||
}
|
||||
/**
|
||||
* The plugin writes an encoded CodeGeneratorResponse to stdout.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.compiler.CodeGeneratorResponse
|
||||
*/
|
||||
export interface CodeGeneratorResponse {
|
||||
/**
|
||||
* Error message. If non-empty, code generation failed. The plugin process
|
||||
* should exit with status code zero even if it reports an error in this way.
|
||||
*
|
||||
* This should be used to indicate errors in .proto files which prevent the
|
||||
* code generator from generating correct code. Errors which indicate a
|
||||
* problem in protoc itself -- such as the input CodeGeneratorRequest being
|
||||
* unparseable -- should be reported by writing a message to stderr and
|
||||
* exiting with a non-zero status code.
|
||||
*
|
||||
* @generated from protobuf field: optional string error = 1;
|
||||
*/
|
||||
error?: string;
|
||||
/**
|
||||
* @generated from protobuf field: repeated google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
|
||||
*/
|
||||
file: CodeGeneratorResponse_File[];
|
||||
}
|
||||
/**
|
||||
* Represents a single generated file.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.compiler.CodeGeneratorResponse.File
|
||||
*/
|
||||
export interface CodeGeneratorResponse_File {
|
||||
/**
|
||||
* The file name, relative to the output directory. The name must not
|
||||
* contain "." or ".." components and must be relative, not be absolute (so,
|
||||
* the file cannot lie outside the output directory). "/" must be used as
|
||||
* the path separator, not "\".
|
||||
*
|
||||
* If the name is omitted, the content will be appended to the previous
|
||||
* file. This allows the generator to break large files into small chunks,
|
||||
* and allows the generated text to be streamed back to protoc so that large
|
||||
* files need not reside completely in memory at one time. Note that as of
|
||||
* this writing protoc does not optimize for this -- it will read the entire
|
||||
* CodeGeneratorResponse before writing files to disk.
|
||||
*
|
||||
* @generated from protobuf field: optional string name = 1;
|
||||
*/
|
||||
name?: string;
|
||||
/**
|
||||
* If non-empty, indicates that the named file should already exist, and the
|
||||
* content here is to be inserted into that file at a defined insertion
|
||||
* point. This feature allows a code generator to extend the output
|
||||
* produced by another code generator. The original generator may provide
|
||||
* insertion points by placing special annotations in the file that look
|
||||
* like:
|
||||
* @@protoc_insertion_point(NAME)
|
||||
* The annotation can have arbitrary text before and after it on the line,
|
||||
* which allows it to be placed in a comment. NAME should be replaced with
|
||||
* an identifier naming the point -- this is what other generators will use
|
||||
* as the insertion_point. Code inserted at this point will be placed
|
||||
* immediately above the line containing the insertion point (thus multiple
|
||||
* insertions to the same point will come out in the order they were added).
|
||||
* The double-@ is intended to make it unlikely that the generated code
|
||||
* could contain things that look like insertion points by accident.
|
||||
*
|
||||
* For example, the C++ code generator places the following line in the
|
||||
* .pb.h files that it generates:
|
||||
* // @@protoc_insertion_point(namespace_scope)
|
||||
* This line appears within the scope of the file's package namespace, but
|
||||
* outside of any particular class. Another plugin can then specify the
|
||||
* insertion_point "namespace_scope" to generate additional classes or
|
||||
* other declarations that should be placed in this scope.
|
||||
*
|
||||
* Note that if the line containing the insertion point begins with
|
||||
* whitespace, the same whitespace will be added to every line of the
|
||||
* inserted text. This is useful for languages like Python, where
|
||||
* indentation matters. In these languages, the insertion point comment
|
||||
* should be indented the same amount as any inserted code will need to be
|
||||
* in order to work correctly in that context.
|
||||
*
|
||||
* The code generator that generates the initial file and the one which
|
||||
* inserts into it must both run as part of a single invocation of protoc.
|
||||
* Code generators are executed in the order in which they appear on the
|
||||
* command line.
|
||||
*
|
||||
* If |insertion_point| is present, |name| must also be present.
|
||||
*
|
||||
* @generated from protobuf field: optional string insertion_point = 2;
|
||||
*/
|
||||
insertionPoint?: string;
|
||||
/**
|
||||
* The file contents.
|
||||
*
|
||||
* @generated from protobuf field: optional string content = 15;
|
||||
*/
|
||||
content?: string;
|
||||
}
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Version$Type extends MessageType<Version> {
|
||||
constructor() {
|
||||
super("google.protobuf.compiler.Version", [
|
||||
{ no: 1, name: "major", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ },
|
||||
{ no: 2, name: "minor", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ },
|
||||
{ no: 3, name: "patch", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ },
|
||||
{ no: 4, name: "suffix", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<Version>): Version {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Version>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Version): Version {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* optional int32 major */ 1:
|
||||
message.major = reader.int32();
|
||||
break;
|
||||
case /* optional int32 minor */ 2:
|
||||
message.minor = reader.int32();
|
||||
break;
|
||||
case /* optional int32 patch */ 3:
|
||||
message.patch = reader.int32();
|
||||
break;
|
||||
case /* optional string suffix */ 4:
|
||||
message.suffix = reader.string();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Version, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* optional int32 major = 1; */
|
||||
if (message.major !== undefined)
|
||||
writer.tag(1, WireType.Varint).int32(message.major);
|
||||
/* optional int32 minor = 2; */
|
||||
if (message.minor !== undefined)
|
||||
writer.tag(2, WireType.Varint).int32(message.minor);
|
||||
/* optional int32 patch = 3; */
|
||||
if (message.patch !== undefined)
|
||||
writer.tag(3, WireType.Varint).int32(message.patch);
|
||||
/* optional string suffix = 4; */
|
||||
if (message.suffix !== undefined)
|
||||
writer.tag(4, WireType.LengthDelimited).string(message.suffix);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.compiler.Version
|
||||
*/
|
||||
export const Version = new Version$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class CodeGeneratorRequest$Type extends MessageType<CodeGeneratorRequest> {
|
||||
constructor() {
|
||||
super("google.protobuf.compiler.CodeGeneratorRequest", [
|
||||
{ no: 1, name: "file_to_generate", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 2, name: "parameter", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 15, name: "proto_file", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FileDescriptorProto },
|
||||
{ no: 3, name: "compiler_version", kind: "message", T: () => Version }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<CodeGeneratorRequest>): CodeGeneratorRequest {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.fileToGenerate = [];
|
||||
message.protoFile = [];
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<CodeGeneratorRequest>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CodeGeneratorRequest): CodeGeneratorRequest {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* repeated string file_to_generate */ 1:
|
||||
message.fileToGenerate.push(reader.string());
|
||||
break;
|
||||
case /* optional string parameter */ 2:
|
||||
message.parameter = reader.string();
|
||||
break;
|
||||
case /* repeated google.protobuf.FileDescriptorProto proto_file */ 15:
|
||||
message.protoFile.push(FileDescriptorProto.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
case /* optional google.protobuf.compiler.Version compiler_version */ 3:
|
||||
message.compilerVersion = Version.internalBinaryRead(reader, reader.uint32(), options, message.compilerVersion);
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: CodeGeneratorRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* repeated string file_to_generate = 1; */
|
||||
for (let i = 0; i < message.fileToGenerate.length; i++)
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.fileToGenerate[i]);
|
||||
/* optional string parameter = 2; */
|
||||
if (message.parameter !== undefined)
|
||||
writer.tag(2, WireType.LengthDelimited).string(message.parameter);
|
||||
/* repeated google.protobuf.FileDescriptorProto proto_file = 15; */
|
||||
for (let i = 0; i < message.protoFile.length; i++)
|
||||
FileDescriptorProto.internalBinaryWrite(message.protoFile[i], writer.tag(15, WireType.LengthDelimited).fork(), options).join();
|
||||
/* optional google.protobuf.compiler.Version compiler_version = 3; */
|
||||
if (message.compilerVersion)
|
||||
Version.internalBinaryWrite(message.compilerVersion, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.compiler.CodeGeneratorRequest
|
||||
*/
|
||||
export const CodeGeneratorRequest = new CodeGeneratorRequest$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class CodeGeneratorResponse$Type extends MessageType<CodeGeneratorResponse> {
|
||||
constructor() {
|
||||
super("google.protobuf.compiler.CodeGeneratorResponse", [
|
||||
{ no: 1, name: "error", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 15, name: "file", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => CodeGeneratorResponse_File }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<CodeGeneratorResponse>): CodeGeneratorResponse {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.file = [];
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<CodeGeneratorResponse>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CodeGeneratorResponse): CodeGeneratorResponse {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* optional string error */ 1:
|
||||
message.error = reader.string();
|
||||
break;
|
||||
case /* repeated google.protobuf.compiler.CodeGeneratorResponse.File file */ 15:
|
||||
message.file.push(CodeGeneratorResponse_File.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: CodeGeneratorResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* optional string error = 1; */
|
||||
if (message.error !== undefined)
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.error);
|
||||
/* repeated google.protobuf.compiler.CodeGeneratorResponse.File file = 15; */
|
||||
for (let i = 0; i < message.file.length; i++)
|
||||
CodeGeneratorResponse_File.internalBinaryWrite(message.file[i], writer.tag(15, WireType.LengthDelimited).fork(), options).join();
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.compiler.CodeGeneratorResponse
|
||||
*/
|
||||
export const CodeGeneratorResponse = new CodeGeneratorResponse$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class CodeGeneratorResponse_File$Type extends MessageType<CodeGeneratorResponse_File> {
|
||||
constructor() {
|
||||
super("google.protobuf.compiler.CodeGeneratorResponse.File", [
|
||||
{ no: 1, name: "name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 2, name: "insertion_point", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 15, name: "content", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<CodeGeneratorResponse_File>): CodeGeneratorResponse_File {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<CodeGeneratorResponse_File>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CodeGeneratorResponse_File): CodeGeneratorResponse_File {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* optional string name */ 1:
|
||||
message.name = reader.string();
|
||||
break;
|
||||
case /* optional string insertion_point */ 2:
|
||||
message.insertionPoint = reader.string();
|
||||
break;
|
||||
case /* optional string content */ 15:
|
||||
message.content = reader.string();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: CodeGeneratorResponse_File, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* optional string name = 1; */
|
||||
if (message.name !== undefined)
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.name);
|
||||
/* optional string insertion_point = 2; */
|
||||
if (message.insertionPoint !== undefined)
|
||||
writer.tag(2, WireType.LengthDelimited).string(message.insertionPoint);
|
||||
/* optional string content = 15; */
|
||||
if (message.content !== undefined)
|
||||
writer.tag(15, WireType.LengthDelimited).string(message.content);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.compiler.CodeGeneratorResponse.File
|
||||
*/
|
||||
export const CodeGeneratorResponse_File = new CodeGeneratorResponse_File$Type();
|
||||
3422
google/protobuf/descriptor.ts
Normal file
3422
google/protobuf/descriptor.ts
Normal file
File diff suppressed because it is too large
Load Diff
231
google/protobuf/duration.ts
Normal file
231
google/protobuf/duration.ts
Normal file
@@ -0,0 +1,231 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/protobuf/duration.proto" (package "google.protobuf", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryWriter } from "@protobuf-ts/runtime";
|
||||
import { WireType } from "@protobuf-ts/runtime";
|
||||
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryReader } from "@protobuf-ts/runtime";
|
||||
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
|
||||
import type { PartialMessage } from "@protobuf-ts/runtime";
|
||||
import { reflectionMergePartial } from "@protobuf-ts/runtime";
|
||||
import { typeofJsonValue } from "@protobuf-ts/runtime";
|
||||
import type { JsonValue } from "@protobuf-ts/runtime";
|
||||
import type { JsonReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { JsonWriteOptions } from "@protobuf-ts/runtime";
|
||||
import { PbLong } from "@protobuf-ts/runtime";
|
||||
import { MessageType } from "@protobuf-ts/runtime";
|
||||
/**
|
||||
* A Duration represents a signed, fixed-length span of time represented
|
||||
* as a count of seconds and fractions of seconds at nanosecond
|
||||
* resolution. It is independent of any calendar and concepts like "day"
|
||||
* or "month". It is related to Timestamp in that the difference between
|
||||
* two Timestamp values is a Duration and it can be added or subtracted
|
||||
* from a Timestamp. Range is approximately +-10,000 years.
|
||||
*
|
||||
* # Examples
|
||||
*
|
||||
* Example 1: Compute Duration from two Timestamps in pseudo code.
|
||||
*
|
||||
* Timestamp start = ...;
|
||||
* Timestamp end = ...;
|
||||
* Duration duration = ...;
|
||||
*
|
||||
* duration.seconds = end.seconds - start.seconds;
|
||||
* duration.nanos = end.nanos - start.nanos;
|
||||
*
|
||||
* if (duration.seconds < 0 && duration.nanos > 0) {
|
||||
* duration.seconds += 1;
|
||||
* duration.nanos -= 1000000000;
|
||||
* } else if (duration.seconds > 0 && duration.nanos < 0) {
|
||||
* duration.seconds -= 1;
|
||||
* duration.nanos += 1000000000;
|
||||
* }
|
||||
*
|
||||
* Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
|
||||
*
|
||||
* Timestamp start = ...;
|
||||
* Duration duration = ...;
|
||||
* Timestamp end = ...;
|
||||
*
|
||||
* end.seconds = start.seconds + duration.seconds;
|
||||
* end.nanos = start.nanos + duration.nanos;
|
||||
*
|
||||
* if (end.nanos < 0) {
|
||||
* end.seconds -= 1;
|
||||
* end.nanos += 1000000000;
|
||||
* } else if (end.nanos >= 1000000000) {
|
||||
* end.seconds += 1;
|
||||
* end.nanos -= 1000000000;
|
||||
* }
|
||||
*
|
||||
* Example 3: Compute Duration from datetime.timedelta in Python.
|
||||
*
|
||||
* td = datetime.timedelta(days=3, minutes=10)
|
||||
* duration = Duration()
|
||||
* duration.FromTimedelta(td)
|
||||
*
|
||||
* # JSON Mapping
|
||||
*
|
||||
* In JSON format, the Duration type is encoded as a string rather than an
|
||||
* object, where the string ends in the suffix "s" (indicating seconds) and
|
||||
* is preceded by the number of seconds, with nanoseconds expressed as
|
||||
* fractional seconds. For example, 3 seconds with 0 nanoseconds should be
|
||||
* encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
|
||||
* be expressed in JSON format as "3.000000001s", and 3 seconds and 1
|
||||
* microsecond should be expressed in JSON format as "3.000001s".
|
||||
*
|
||||
*
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Duration
|
||||
*/
|
||||
export interface Duration {
|
||||
/**
|
||||
* Signed seconds of the span of time. Must be from -315,576,000,000
|
||||
* to +315,576,000,000 inclusive. Note: these bounds are computed from:
|
||||
* 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
|
||||
*
|
||||
* @generated from protobuf field: int64 seconds = 1;
|
||||
*/
|
||||
seconds: bigint;
|
||||
/**
|
||||
* Signed fractions of a second at nanosecond resolution of the span
|
||||
* of time. Durations less than one second are represented with a 0
|
||||
* `seconds` field and a positive or negative `nanos` field. For durations
|
||||
* of one second or more, a non-zero value for the `nanos` field must be
|
||||
* of the same sign as the `seconds` field. Must be from -999,999,999
|
||||
* to +999,999,999 inclusive.
|
||||
*
|
||||
* @generated from protobuf field: int32 nanos = 2;
|
||||
*/
|
||||
nanos: number;
|
||||
}
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Duration$Type extends MessageType<Duration> {
|
||||
constructor() {
|
||||
super("google.protobuf.Duration", [
|
||||
{ no: 1, name: "seconds", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
|
||||
{ no: 2, name: "nanos", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Encode `Duration` to JSON string like "3.000001s".
|
||||
*/
|
||||
internalJsonWrite(message: Duration, options: JsonWriteOptions): JsonValue {
|
||||
let s = PbLong.from(message.seconds).toNumber();
|
||||
if (s > 315576000000 || s < -315576000000)
|
||||
throw new Error("Duration value out of range.");
|
||||
let text = message.seconds.toString();
|
||||
if (s === 0 && message.nanos < 0)
|
||||
text = "-" + text;
|
||||
if (message.nanos !== 0) {
|
||||
let nanosStr = Math.abs(message.nanos).toString();
|
||||
nanosStr = "0".repeat(9 - nanosStr.length) + nanosStr;
|
||||
if (nanosStr.substring(3) === "000000")
|
||||
nanosStr = nanosStr.substring(0, 3);
|
||||
else if (nanosStr.substring(6) === "000")
|
||||
nanosStr = nanosStr.substring(0, 6);
|
||||
text += "." + nanosStr;
|
||||
}
|
||||
return text + "s";
|
||||
}
|
||||
/**
|
||||
* Decode `Duration` from JSON string like "3.000001s"
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Duration): Duration {
|
||||
if (typeof json !== "string")
|
||||
throw new Error("Unable to parse Duration from JSON " + typeofJsonValue(json) + ". Expected string.");
|
||||
let match = json.match(/^(-?)([0-9]+)(?:\.([0-9]+))?s/);
|
||||
if (match === null)
|
||||
throw new Error("Unable to parse Duration from JSON string. Invalid format.");
|
||||
if (!target)
|
||||
target = this.create();
|
||||
let [, sign, secs, nanos] = match;
|
||||
let longSeconds = PbLong.from(sign + secs);
|
||||
if (longSeconds.toNumber() > 315576000000 || longSeconds.toNumber() < -315576000000)
|
||||
throw new Error("Unable to parse Duration from JSON string. Value out of range.");
|
||||
target.seconds = longSeconds.toBigInt();
|
||||
if (typeof nanos == "string") {
|
||||
let nanosStr = sign + nanos + "0".repeat(9 - nanos.length);
|
||||
target.nanos = parseInt(nanosStr);
|
||||
}
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<Duration>): Duration {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.seconds = 0n;
|
||||
message.nanos = 0;
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Duration>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Duration): Duration {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* int64 seconds */ 1:
|
||||
message.seconds = reader.int64().toBigInt();
|
||||
break;
|
||||
case /* int32 nanos */ 2:
|
||||
message.nanos = reader.int32();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Duration, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* int64 seconds = 1; */
|
||||
if (message.seconds !== 0n)
|
||||
writer.tag(1, WireType.Varint).int64(message.seconds);
|
||||
/* int32 nanos = 2; */
|
||||
if (message.nanos !== 0)
|
||||
writer.tag(2, WireType.Varint).int32(message.nanos);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Duration
|
||||
*/
|
||||
export const Duration = new Duration$Type();
|
||||
95
google/protobuf/empty.ts
Normal file
95
google/protobuf/empty.ts
Normal file
@@ -0,0 +1,95 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/protobuf/empty.proto" (package "google.protobuf", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
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 { UnknownFieldHandler } from "@protobuf-ts/runtime";
|
||||
import type { PartialMessage } from "@protobuf-ts/runtime";
|
||||
import { reflectionMergePartial } from "@protobuf-ts/runtime";
|
||||
import { MessageType } from "@protobuf-ts/runtime";
|
||||
/**
|
||||
* 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 `{}`.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Empty
|
||||
*/
|
||||
export interface Empty {
|
||||
}
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Empty$Type extends MessageType<Empty> {
|
||||
constructor() {
|
||||
super("google.protobuf.Empty", []);
|
||||
}
|
||||
create(value?: PartialMessage<Empty>): Empty {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Empty>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Empty): Empty {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Empty, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Empty
|
||||
*/
|
||||
export const Empty = new Empty$Type();
|
||||
336
google/protobuf/field_mask.ts
Normal file
336
google/protobuf/field_mask.ts
Normal file
@@ -0,0 +1,336 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/protobuf/field_mask.proto" (package "google.protobuf", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryWriter } from "@protobuf-ts/runtime";
|
||||
import { WireType } from "@protobuf-ts/runtime";
|
||||
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryReader } from "@protobuf-ts/runtime";
|
||||
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
|
||||
import type { PartialMessage } from "@protobuf-ts/runtime";
|
||||
import { reflectionMergePartial } from "@protobuf-ts/runtime";
|
||||
import { typeofJsonValue } from "@protobuf-ts/runtime";
|
||||
import type { JsonValue } from "@protobuf-ts/runtime";
|
||||
import { lowerCamelCase } from "@protobuf-ts/runtime";
|
||||
import type { JsonReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { JsonWriteOptions } from "@protobuf-ts/runtime";
|
||||
import { MessageType } from "@protobuf-ts/runtime";
|
||||
/**
|
||||
* `FieldMask` represents a set of symbolic field paths, for example:
|
||||
*
|
||||
* paths: "f.a"
|
||||
* paths: "f.b.d"
|
||||
*
|
||||
* Here `f` represents a field in some root message, `a` and `b`
|
||||
* fields in the message found in `f`, and `d` a field found in the
|
||||
* message in `f.b`.
|
||||
*
|
||||
* Field masks are used to specify a subset of fields that should be
|
||||
* returned by a get operation or modified by an update operation.
|
||||
* Field masks also have a custom JSON encoding (see below).
|
||||
*
|
||||
* # Field Masks in Projections
|
||||
*
|
||||
* When used in the context of a projection, a response message or
|
||||
* sub-message is filtered by the API to only contain those fields as
|
||||
* specified in the mask. For example, if the mask in the previous
|
||||
* example is applied to a response message as follows:
|
||||
*
|
||||
* f {
|
||||
* a : 22
|
||||
* b {
|
||||
* d : 1
|
||||
* x : 2
|
||||
* }
|
||||
* y : 13
|
||||
* }
|
||||
* z: 8
|
||||
*
|
||||
* The result will not contain specific values for fields x,y and z
|
||||
* (their value will be set to the default, and omitted in proto text
|
||||
* output):
|
||||
*
|
||||
*
|
||||
* f {
|
||||
* a : 22
|
||||
* b {
|
||||
* d : 1
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* A repeated field is not allowed except at the last position of a
|
||||
* paths string.
|
||||
*
|
||||
* If a FieldMask object is not present in a get operation, the
|
||||
* operation applies to all fields (as if a FieldMask of all fields
|
||||
* had been specified).
|
||||
*
|
||||
* Note that a field mask does not necessarily apply to the
|
||||
* top-level response message. In case of a REST get operation, the
|
||||
* field mask applies directly to the response, but in case of a REST
|
||||
* list operation, the mask instead applies to each individual message
|
||||
* in the returned resource list. In case of a REST custom method,
|
||||
* other definitions may be used. Where the mask applies will be
|
||||
* clearly documented together with its declaration in the API. In
|
||||
* any case, the effect on the returned resource/resources is required
|
||||
* behavior for APIs.
|
||||
*
|
||||
* # Field Masks in Update Operations
|
||||
*
|
||||
* A field mask in update operations specifies which fields of the
|
||||
* targeted resource are going to be updated. The API is required
|
||||
* to only change the values of the fields as specified in the mask
|
||||
* and leave the others untouched. If a resource is passed in to
|
||||
* describe the updated values, the API ignores the values of all
|
||||
* fields not covered by the mask.
|
||||
*
|
||||
* If a repeated field is specified for an update operation, new values will
|
||||
* be appended to the existing repeated field in the target resource. Note that
|
||||
* a repeated field is only allowed in the last position of a `paths` string.
|
||||
*
|
||||
* If a sub-message is specified in the last position of the field mask for an
|
||||
* update operation, then new value will be merged into the existing sub-message
|
||||
* in the target resource.
|
||||
*
|
||||
* For example, given the target message:
|
||||
*
|
||||
* f {
|
||||
* b {
|
||||
* d: 1
|
||||
* x: 2
|
||||
* }
|
||||
* c: [1]
|
||||
* }
|
||||
*
|
||||
* And an update message:
|
||||
*
|
||||
* f {
|
||||
* b {
|
||||
* d: 10
|
||||
* }
|
||||
* c: [2]
|
||||
* }
|
||||
*
|
||||
* then if the field mask is:
|
||||
*
|
||||
* paths: ["f.b", "f.c"]
|
||||
*
|
||||
* then the result will be:
|
||||
*
|
||||
* f {
|
||||
* b {
|
||||
* d: 10
|
||||
* x: 2
|
||||
* }
|
||||
* c: [1, 2]
|
||||
* }
|
||||
*
|
||||
* An implementation may provide options to override this default behavior for
|
||||
* repeated and message fields.
|
||||
*
|
||||
* In order to reset a field's value to the default, the field must
|
||||
* be in the mask and set to the default value in the provided resource.
|
||||
* Hence, in order to reset all fields of a resource, provide a default
|
||||
* instance of the resource and set all fields in the mask, or do
|
||||
* not provide a mask as described below.
|
||||
*
|
||||
* If a field mask is not present on update, the operation applies to
|
||||
* all fields (as if a field mask of all fields has been specified).
|
||||
* Note that in the presence of schema evolution, this may mean that
|
||||
* fields the client does not know and has therefore not filled into
|
||||
* the request will be reset to their default. If this is unwanted
|
||||
* behavior, a specific service may require a client to always specify
|
||||
* a field mask, producing an error if not.
|
||||
*
|
||||
* As with get operations, the location of the resource which
|
||||
* describes the updated values in the request message depends on the
|
||||
* operation kind. In any case, the effect of the field mask is
|
||||
* required to be honored by the API.
|
||||
*
|
||||
* ## Considerations for HTTP REST
|
||||
*
|
||||
* The HTTP kind of an update operation which uses a field mask must
|
||||
* be set to PATCH instead of PUT in order to satisfy HTTP semantics
|
||||
* (PUT must only be used for full updates).
|
||||
*
|
||||
* # JSON Encoding of Field Masks
|
||||
*
|
||||
* In JSON, a field mask is encoded as a single string where paths are
|
||||
* separated by a comma. Fields name in each path are converted
|
||||
* to/from lower-camel naming conventions.
|
||||
*
|
||||
* As an example, consider the following message declarations:
|
||||
*
|
||||
* message Profile {
|
||||
* User user = 1;
|
||||
* Photo photo = 2;
|
||||
* }
|
||||
* message User {
|
||||
* string display_name = 1;
|
||||
* string address = 2;
|
||||
* }
|
||||
*
|
||||
* In proto a field mask for `Profile` may look as such:
|
||||
*
|
||||
* mask {
|
||||
* paths: "user.display_name"
|
||||
* paths: "photo"
|
||||
* }
|
||||
*
|
||||
* In JSON, the same mask is represented as below:
|
||||
*
|
||||
* {
|
||||
* mask: "user.displayName,photo"
|
||||
* }
|
||||
*
|
||||
* # Field Masks and Oneof Fields
|
||||
*
|
||||
* Field masks treat fields in oneofs just as regular fields. Consider the
|
||||
* following message:
|
||||
*
|
||||
* message SampleMessage {
|
||||
* oneof test_oneof {
|
||||
* string name = 4;
|
||||
* SubMessage sub_message = 9;
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* The field mask can be:
|
||||
*
|
||||
* mask {
|
||||
* paths: "name"
|
||||
* }
|
||||
*
|
||||
* Or:
|
||||
*
|
||||
* mask {
|
||||
* paths: "sub_message"
|
||||
* }
|
||||
*
|
||||
* Note that oneof type names ("test_oneof" in this case) cannot be used in
|
||||
* paths.
|
||||
*
|
||||
* ## Field Mask Verification
|
||||
*
|
||||
* The implementation of any API method which has a FieldMask type field in the
|
||||
* request should verify the included field paths, and return an
|
||||
* `INVALID_ARGUMENT` error if any path is unmappable.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.FieldMask
|
||||
*/
|
||||
export interface FieldMask {
|
||||
/**
|
||||
* The set of field mask paths.
|
||||
*
|
||||
* @generated from protobuf field: repeated string paths = 1;
|
||||
*/
|
||||
paths: string[];
|
||||
}
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class FieldMask$Type extends MessageType<FieldMask> {
|
||||
constructor() {
|
||||
super("google.protobuf.FieldMask", [
|
||||
{ no: 1, name: "paths", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Encode `FieldMask` to JSON object.
|
||||
*/
|
||||
internalJsonWrite(message: FieldMask, options: JsonWriteOptions): JsonValue {
|
||||
const invalidFieldMaskJsonRegex = /[A-Z]|(_([.0-9_]|$))/g;
|
||||
return message.paths.map(p => {
|
||||
if (invalidFieldMaskJsonRegex.test(p))
|
||||
throw new Error("Unable to encode FieldMask to JSON. lowerCamelCase of path name \"" + p + "\" is irreversible.");
|
||||
return lowerCamelCase(p);
|
||||
}).join(",");
|
||||
}
|
||||
/**
|
||||
* Decode `FieldMask` from JSON object.
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: FieldMask): FieldMask {
|
||||
if (typeof json !== "string")
|
||||
throw new Error("Unable to parse FieldMask from JSON " + typeofJsonValue(json) + ". Expected string.");
|
||||
if (!target)
|
||||
target = this.create();
|
||||
if (json === "")
|
||||
return target;
|
||||
let camelToSnake = (str: string) => {
|
||||
if (str.includes("_"))
|
||||
throw new Error("Unable to parse FieldMask from JSON. Path names must be lowerCamelCase.");
|
||||
let sc = str.replace(/[A-Z]/g, letter => "_" + letter.toLowerCase());
|
||||
return sc;
|
||||
};
|
||||
target.paths = json.split(",").map(camelToSnake);
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<FieldMask>): FieldMask {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.paths = [];
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<FieldMask>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FieldMask): FieldMask {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* repeated string paths */ 1:
|
||||
message.paths.push(reader.string());
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: FieldMask, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* repeated string paths = 1; */
|
||||
for (let i = 0; i < message.paths.length; i++)
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.paths[i]);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.FieldMask
|
||||
*/
|
||||
export const FieldMask = new FieldMask$Type();
|
||||
105
google/protobuf/source_context.ts
Normal file
105
google/protobuf/source_context.ts
Normal file
@@ -0,0 +1,105 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/protobuf/source_context.proto" (package "google.protobuf", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryWriter } from "@protobuf-ts/runtime";
|
||||
import { WireType } from "@protobuf-ts/runtime";
|
||||
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryReader } from "@protobuf-ts/runtime";
|
||||
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
|
||||
import type { PartialMessage } from "@protobuf-ts/runtime";
|
||||
import { reflectionMergePartial } from "@protobuf-ts/runtime";
|
||||
import { MessageType } from "@protobuf-ts/runtime";
|
||||
/**
|
||||
* `SourceContext` represents information about the source of a
|
||||
* protobuf element, like the file in which it is defined.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.SourceContext
|
||||
*/
|
||||
export interface SourceContext {
|
||||
/**
|
||||
* The path-qualified name of the .proto file that contained the associated
|
||||
* protobuf element. For example: `"google/protobuf/source_context.proto"`.
|
||||
*
|
||||
* @generated from protobuf field: string file_name = 1;
|
||||
*/
|
||||
fileName: string;
|
||||
}
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class SourceContext$Type extends MessageType<SourceContext> {
|
||||
constructor() {
|
||||
super("google.protobuf.SourceContext", [
|
||||
{ no: 1, name: "file_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<SourceContext>): SourceContext {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.fileName = "";
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<SourceContext>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SourceContext): SourceContext {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* string file_name */ 1:
|
||||
message.fileName = reader.string();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: SourceContext, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* string file_name = 1; */
|
||||
if (message.fileName !== "")
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.fileName);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.SourceContext
|
||||
*/
|
||||
export const SourceContext = new SourceContext$Type();
|
||||
482
google/protobuf/struct.ts
Normal file
482
google/protobuf/struct.ts
Normal file
@@ -0,0 +1,482 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/protobuf/struct.proto" (package "google.protobuf", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryWriter } from "@protobuf-ts/runtime";
|
||||
import { WireType } from "@protobuf-ts/runtime";
|
||||
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryReader } from "@protobuf-ts/runtime";
|
||||
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
|
||||
import type { PartialMessage } from "@protobuf-ts/runtime";
|
||||
import { reflectionMergePartial } from "@protobuf-ts/runtime";
|
||||
import { isJsonObject } from "@protobuf-ts/runtime";
|
||||
import { typeofJsonValue } from "@protobuf-ts/runtime";
|
||||
import type { JsonValue } from "@protobuf-ts/runtime";
|
||||
import type { JsonReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { JsonWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { JsonObject } from "@protobuf-ts/runtime";
|
||||
import { MessageType } from "@protobuf-ts/runtime";
|
||||
/**
|
||||
* `Struct` represents a structured data value, consisting of fields
|
||||
* which map to dynamically typed values. In some languages, `Struct`
|
||||
* might be supported by a native representation. For example, in
|
||||
* scripting languages like JS a struct is represented as an
|
||||
* object. The details of that representation are described together
|
||||
* with the proto support for the language.
|
||||
*
|
||||
* The JSON representation for `Struct` is JSON object.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Struct
|
||||
*/
|
||||
export interface Struct {
|
||||
/**
|
||||
* Unordered map of dynamically typed values.
|
||||
*
|
||||
* @generated from protobuf field: map<string, google.protobuf.Value> fields = 1;
|
||||
*/
|
||||
fields: {
|
||||
[key: string]: Value;
|
||||
};
|
||||
}
|
||||
/**
|
||||
* `Value` represents a dynamically typed value which can be either
|
||||
* null, a number, a string, a boolean, a recursive struct value, or a
|
||||
* list of values. A producer of value is expected to set one of that
|
||||
* variants, absence of any variant indicates an error.
|
||||
*
|
||||
* The JSON representation for `Value` is JSON value.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Value
|
||||
*/
|
||||
export interface Value {
|
||||
/**
|
||||
* @generated from protobuf oneof: kind
|
||||
*/
|
||||
kind: {
|
||||
oneofKind: "nullValue";
|
||||
/**
|
||||
* Represents a null value.
|
||||
*
|
||||
* @generated from protobuf field: google.protobuf.NullValue null_value = 1;
|
||||
*/
|
||||
nullValue: NullValue;
|
||||
} | {
|
||||
oneofKind: "numberValue";
|
||||
/**
|
||||
* Represents a double value.
|
||||
*
|
||||
* @generated from protobuf field: double number_value = 2;
|
||||
*/
|
||||
numberValue: number;
|
||||
} | {
|
||||
oneofKind: "stringValue";
|
||||
/**
|
||||
* Represents a string value.
|
||||
*
|
||||
* @generated from protobuf field: string string_value = 3;
|
||||
*/
|
||||
stringValue: string;
|
||||
} | {
|
||||
oneofKind: "boolValue";
|
||||
/**
|
||||
* Represents a boolean value.
|
||||
*
|
||||
* @generated from protobuf field: bool bool_value = 4;
|
||||
*/
|
||||
boolValue: boolean;
|
||||
} | {
|
||||
oneofKind: "structValue";
|
||||
/**
|
||||
* Represents a structured value.
|
||||
*
|
||||
* @generated from protobuf field: google.protobuf.Struct struct_value = 5;
|
||||
*/
|
||||
structValue: Struct;
|
||||
} | {
|
||||
oneofKind: "listValue";
|
||||
/**
|
||||
* Represents a repeated `Value`.
|
||||
*
|
||||
* @generated from protobuf field: google.protobuf.ListValue list_value = 6;
|
||||
*/
|
||||
listValue: ListValue;
|
||||
} | {
|
||||
oneofKind: undefined;
|
||||
};
|
||||
}
|
||||
/**
|
||||
* `ListValue` is a wrapper around a repeated field of values.
|
||||
*
|
||||
* The JSON representation for `ListValue` is JSON array.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.ListValue
|
||||
*/
|
||||
export interface ListValue {
|
||||
/**
|
||||
* Repeated field of dynamically typed values.
|
||||
*
|
||||
* @generated from protobuf field: repeated google.protobuf.Value values = 1;
|
||||
*/
|
||||
values: Value[];
|
||||
}
|
||||
/**
|
||||
* `NullValue` is a singleton enumeration to represent the null value for the
|
||||
* `Value` type union.
|
||||
*
|
||||
* The JSON representation for `NullValue` is JSON `null`.
|
||||
*
|
||||
* @generated from protobuf enum google.protobuf.NullValue
|
||||
*/
|
||||
export enum NullValue {
|
||||
/**
|
||||
* Null value.
|
||||
*
|
||||
* @generated from protobuf enum value: NULL_VALUE = 0;
|
||||
*/
|
||||
NULL_VALUE = 0
|
||||
}
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Struct$Type extends MessageType<Struct> {
|
||||
constructor() {
|
||||
super("google.protobuf.Struct", [
|
||||
{ no: 1, name: "fields", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "message", T: () => Value } }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Encode `Struct` to JSON object.
|
||||
*/
|
||||
internalJsonWrite(message: Struct, options: JsonWriteOptions): JsonValue {
|
||||
let json: JsonObject = {};
|
||||
for (let [k, v] of Object.entries(message.fields)) {
|
||||
json[k] = Value.toJson(v);
|
||||
}
|
||||
return json;
|
||||
}
|
||||
/**
|
||||
* Decode `Struct` from JSON object.
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Struct): Struct {
|
||||
if (!isJsonObject(json))
|
||||
throw new globalThis.Error("Unable to parse message " + this.typeName + " from JSON " + typeofJsonValue(json) + ".");
|
||||
if (!target)
|
||||
target = this.create();
|
||||
for (let [k, v] of globalThis.Object.entries(json)) {
|
||||
target.fields[k] = Value.fromJson(v);
|
||||
}
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<Struct>): Struct {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.fields = {};
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Struct>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Struct): Struct {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* map<string, google.protobuf.Value> fields */ 1:
|
||||
this.binaryReadMap1(message.fields, reader, options);
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
private binaryReadMap1(map: Struct["fields"], reader: IBinaryReader, options: BinaryReadOptions): void {
|
||||
let len = reader.uint32(), end = reader.pos + len, key: keyof Struct["fields"] | undefined, val: Struct["fields"][any] | undefined;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case 1:
|
||||
key = reader.string();
|
||||
break;
|
||||
case 2:
|
||||
val = Value.internalBinaryRead(reader, reader.uint32(), options);
|
||||
break;
|
||||
default: throw new globalThis.Error("unknown map entry field for field google.protobuf.Struct.fields");
|
||||
}
|
||||
}
|
||||
map[key ?? ""] = val ?? Value.create();
|
||||
}
|
||||
internalBinaryWrite(message: Struct, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* map<string, google.protobuf.Value> fields = 1; */
|
||||
for (let k of globalThis.Object.keys(message.fields)) {
|
||||
writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
|
||||
writer.tag(2, WireType.LengthDelimited).fork();
|
||||
Value.internalBinaryWrite(message.fields[k], writer, options);
|
||||
writer.join().join();
|
||||
}
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Struct
|
||||
*/
|
||||
export const Struct = new Struct$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Value$Type extends MessageType<Value> {
|
||||
constructor() {
|
||||
super("google.protobuf.Value", [
|
||||
{ no: 1, name: "null_value", kind: "enum", oneof: "kind", T: () => ["google.protobuf.NullValue", NullValue] },
|
||||
{ no: 2, name: "number_value", kind: "scalar", oneof: "kind", T: 1 /*ScalarType.DOUBLE*/ },
|
||||
{ no: 3, name: "string_value", kind: "scalar", oneof: "kind", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 4, name: "bool_value", kind: "scalar", oneof: "kind", T: 8 /*ScalarType.BOOL*/ },
|
||||
{ no: 5, name: "struct_value", kind: "message", oneof: "kind", T: () => Struct },
|
||||
{ no: 6, name: "list_value", kind: "message", oneof: "kind", T: () => ListValue }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Encode `Value` to JSON value.
|
||||
*/
|
||||
internalJsonWrite(message: Value, options: JsonWriteOptions): JsonValue {
|
||||
if (message.kind.oneofKind === undefined)
|
||||
throw new globalThis.Error();
|
||||
switch (message.kind.oneofKind) {
|
||||
case undefined: throw new globalThis.Error();
|
||||
case "boolValue": return message.kind.boolValue;
|
||||
case "nullValue": return null;
|
||||
case "numberValue":
|
||||
let numberValue = message.kind.numberValue;
|
||||
if (typeof numberValue == "number" && !Number.isFinite(numberValue))
|
||||
throw new globalThis.Error();
|
||||
return numberValue;
|
||||
case "stringValue": return message.kind.stringValue;
|
||||
case "listValue":
|
||||
let listValueField = this.fields.find(f => f.no === 6);
|
||||
if (listValueField?.kind !== "message")
|
||||
throw new globalThis.Error();
|
||||
return listValueField.T().toJson(message.kind.listValue);
|
||||
case "structValue":
|
||||
let structValueField = this.fields.find(f => f.no === 5);
|
||||
if (structValueField?.kind !== "message")
|
||||
throw new globalThis.Error();
|
||||
return structValueField.T().toJson(message.kind.structValue);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Decode `Value` from JSON value.
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Value): Value {
|
||||
if (!target)
|
||||
target = this.create();
|
||||
switch (typeof json) {
|
||||
case "number":
|
||||
target.kind = { oneofKind: "numberValue", numberValue: json };
|
||||
break;
|
||||
case "string":
|
||||
target.kind = { oneofKind: "stringValue", stringValue: json };
|
||||
break;
|
||||
case "boolean":
|
||||
target.kind = { oneofKind: "boolValue", boolValue: json };
|
||||
break;
|
||||
case "object":
|
||||
if (json === null) {
|
||||
target.kind = { oneofKind: "nullValue", nullValue: NullValue.NULL_VALUE };
|
||||
}
|
||||
else if (globalThis.Array.isArray(json)) {
|
||||
target.kind = { oneofKind: "listValue", listValue: ListValue.fromJson(json) };
|
||||
}
|
||||
else {
|
||||
target.kind = { oneofKind: "structValue", structValue: Struct.fromJson(json) };
|
||||
}
|
||||
break;
|
||||
default: throw new globalThis.Error("Unable to parse " + this.typeName + " from JSON " + typeofJsonValue(json));
|
||||
}
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<Value>): Value {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.kind = { oneofKind: undefined };
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Value>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Value): Value {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* google.protobuf.NullValue null_value */ 1:
|
||||
message.kind = {
|
||||
oneofKind: "nullValue",
|
||||
nullValue: reader.int32()
|
||||
};
|
||||
break;
|
||||
case /* double number_value */ 2:
|
||||
message.kind = {
|
||||
oneofKind: "numberValue",
|
||||
numberValue: reader.double()
|
||||
};
|
||||
break;
|
||||
case /* string string_value */ 3:
|
||||
message.kind = {
|
||||
oneofKind: "stringValue",
|
||||
stringValue: reader.string()
|
||||
};
|
||||
break;
|
||||
case /* bool bool_value */ 4:
|
||||
message.kind = {
|
||||
oneofKind: "boolValue",
|
||||
boolValue: reader.bool()
|
||||
};
|
||||
break;
|
||||
case /* google.protobuf.Struct struct_value */ 5:
|
||||
message.kind = {
|
||||
oneofKind: "structValue",
|
||||
structValue: Struct.internalBinaryRead(reader, reader.uint32(), options, (message.kind as any).structValue)
|
||||
};
|
||||
break;
|
||||
case /* google.protobuf.ListValue list_value */ 6:
|
||||
message.kind = {
|
||||
oneofKind: "listValue",
|
||||
listValue: ListValue.internalBinaryRead(reader, reader.uint32(), options, (message.kind as any).listValue)
|
||||
};
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Value, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* google.protobuf.NullValue null_value = 1; */
|
||||
if (message.kind.oneofKind === "nullValue")
|
||||
writer.tag(1, WireType.Varint).int32(message.kind.nullValue);
|
||||
/* double number_value = 2; */
|
||||
if (message.kind.oneofKind === "numberValue")
|
||||
writer.tag(2, WireType.Bit64).double(message.kind.numberValue);
|
||||
/* string string_value = 3; */
|
||||
if (message.kind.oneofKind === "stringValue")
|
||||
writer.tag(3, WireType.LengthDelimited).string(message.kind.stringValue);
|
||||
/* bool bool_value = 4; */
|
||||
if (message.kind.oneofKind === "boolValue")
|
||||
writer.tag(4, WireType.Varint).bool(message.kind.boolValue);
|
||||
/* google.protobuf.Struct struct_value = 5; */
|
||||
if (message.kind.oneofKind === "structValue")
|
||||
Struct.internalBinaryWrite(message.kind.structValue, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
|
||||
/* google.protobuf.ListValue list_value = 6; */
|
||||
if (message.kind.oneofKind === "listValue")
|
||||
ListValue.internalBinaryWrite(message.kind.listValue, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Value
|
||||
*/
|
||||
export const Value = new Value$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class ListValue$Type extends MessageType<ListValue> {
|
||||
constructor() {
|
||||
super("google.protobuf.ListValue", [
|
||||
{ no: 1, name: "values", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Value }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Encode `ListValue` to JSON array.
|
||||
*/
|
||||
internalJsonWrite(message: ListValue, options: JsonWriteOptions): JsonValue {
|
||||
return message.values.map(v => Value.toJson(v));
|
||||
}
|
||||
/**
|
||||
* Decode `ListValue` from JSON array.
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: ListValue): ListValue {
|
||||
if (!globalThis.Array.isArray(json))
|
||||
throw new globalThis.Error("Unable to parse " + this.typeName + " from JSON " + typeofJsonValue(json));
|
||||
if (!target)
|
||||
target = this.create();
|
||||
let values = json.map(v => Value.fromJson(v));
|
||||
target.values.push(...values);
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<ListValue>): ListValue {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.values = [];
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<ListValue>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListValue): ListValue {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* repeated google.protobuf.Value values */ 1:
|
||||
message.values.push(Value.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: ListValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* repeated google.protobuf.Value values = 1; */
|
||||
for (let i = 0; i < message.values.length; i++)
|
||||
Value.internalBinaryWrite(message.values[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.ListValue
|
||||
*/
|
||||
export const ListValue = new ListValue$Type();
|
||||
281
google/protobuf/timestamp.ts
Normal file
281
google/protobuf/timestamp.ts
Normal file
@@ -0,0 +1,281 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/protobuf/timestamp.proto" (package "google.protobuf", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryWriter } from "@protobuf-ts/runtime";
|
||||
import { WireType } from "@protobuf-ts/runtime";
|
||||
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryReader } from "@protobuf-ts/runtime";
|
||||
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
|
||||
import type { PartialMessage } from "@protobuf-ts/runtime";
|
||||
import { reflectionMergePartial } from "@protobuf-ts/runtime";
|
||||
import { typeofJsonValue } from "@protobuf-ts/runtime";
|
||||
import type { JsonValue } from "@protobuf-ts/runtime";
|
||||
import type { JsonReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { JsonWriteOptions } from "@protobuf-ts/runtime";
|
||||
import { PbLong } from "@protobuf-ts/runtime";
|
||||
import { MessageType } from "@protobuf-ts/runtime";
|
||||
/**
|
||||
* A Timestamp represents a point in time independent of any time zone or local
|
||||
* calendar, encoded as a count of seconds and fractions of seconds at
|
||||
* nanosecond resolution. The count is relative to an epoch at UTC midnight on
|
||||
* January 1, 1970, in the proleptic Gregorian calendar which extends the
|
||||
* Gregorian calendar backwards to year one.
|
||||
*
|
||||
* All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
|
||||
* second table is needed for interpretation, using a [24-hour linear
|
||||
* smear](https://developers.google.com/time/smear).
|
||||
*
|
||||
* The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
|
||||
* restricting to that range, we ensure that we can convert to and from [RFC
|
||||
* 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
|
||||
*
|
||||
* # Examples
|
||||
*
|
||||
* Example 1: Compute Timestamp from POSIX `time()`.
|
||||
*
|
||||
* Timestamp timestamp;
|
||||
* timestamp.set_seconds(time(NULL));
|
||||
* timestamp.set_nanos(0);
|
||||
*
|
||||
* Example 2: Compute Timestamp from POSIX `gettimeofday()`.
|
||||
*
|
||||
* struct timeval tv;
|
||||
* gettimeofday(&tv, NULL);
|
||||
*
|
||||
* Timestamp timestamp;
|
||||
* timestamp.set_seconds(tv.tv_sec);
|
||||
* timestamp.set_nanos(tv.tv_usec * 1000);
|
||||
*
|
||||
* Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
|
||||
*
|
||||
* FILETIME ft;
|
||||
* GetSystemTimeAsFileTime(&ft);
|
||||
* UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
|
||||
*
|
||||
* // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
|
||||
* // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
|
||||
* Timestamp timestamp;
|
||||
* timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
|
||||
* timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
|
||||
*
|
||||
* Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
|
||||
*
|
||||
* long millis = System.currentTimeMillis();
|
||||
*
|
||||
* Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
|
||||
* .setNanos((int) ((millis % 1000) * 1000000)).build();
|
||||
*
|
||||
*
|
||||
* Example 5: Compute Timestamp from current time in Python.
|
||||
*
|
||||
* timestamp = Timestamp()
|
||||
* timestamp.GetCurrentTime()
|
||||
*
|
||||
* # JSON Mapping
|
||||
*
|
||||
* In JSON format, the Timestamp type is encoded as a string in the
|
||||
* [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
|
||||
* format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
|
||||
* where {year} is always expressed using four digits while {month}, {day},
|
||||
* {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
|
||||
* seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
|
||||
* are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
|
||||
* is required. A proto3 JSON serializer should always use UTC (as indicated by
|
||||
* "Z") when printing the Timestamp type and a proto3 JSON parser should be
|
||||
* able to accept both UTC and other timezones (as indicated by an offset).
|
||||
*
|
||||
* For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
|
||||
* 01:30 UTC on January 15, 2017.
|
||||
*
|
||||
* In JavaScript, one can convert a Date object to this format using the
|
||||
* standard
|
||||
* [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
|
||||
* method. In Python, a standard `datetime.datetime` object can be converted
|
||||
* to this format using
|
||||
* [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
|
||||
* the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
|
||||
* the Joda Time's [`ISODateTimeFormat.dateTime()`](
|
||||
* http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
|
||||
* ) to obtain a formatter capable of generating timestamps in this format.
|
||||
*
|
||||
*
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Timestamp
|
||||
*/
|
||||
export interface Timestamp {
|
||||
/**
|
||||
* Represents seconds of UTC time since Unix epoch
|
||||
* 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
|
||||
* 9999-12-31T23:59:59Z inclusive.
|
||||
*
|
||||
* @generated from protobuf field: int64 seconds = 1;
|
||||
*/
|
||||
seconds: bigint;
|
||||
/**
|
||||
* Non-negative fractions of a second at nanosecond resolution. Negative
|
||||
* second values with fractions must still have non-negative nanos values
|
||||
* that count forward in time. Must be from 0 to 999,999,999
|
||||
* inclusive.
|
||||
*
|
||||
* @generated from protobuf field: int32 nanos = 2;
|
||||
*/
|
||||
nanos: number;
|
||||
}
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Timestamp$Type extends MessageType<Timestamp> {
|
||||
constructor() {
|
||||
super("google.protobuf.Timestamp", [
|
||||
{ no: 1, name: "seconds", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
|
||||
{ no: 2, name: "nanos", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Creates a new `Timestamp` for the current time.
|
||||
*/
|
||||
now(): Timestamp {
|
||||
const msg = this.create();
|
||||
const ms = Date.now();
|
||||
msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt();
|
||||
msg.nanos = (ms % 1000) * 1000000;
|
||||
return msg;
|
||||
}
|
||||
/**
|
||||
* Converts a `Timestamp` to a JavaScript Date.
|
||||
*/
|
||||
toDate(message: Timestamp): Date {
|
||||
return new Date(PbLong.from(message.seconds).toNumber() * 1000 + Math.ceil(message.nanos / 1000000));
|
||||
}
|
||||
/**
|
||||
* Converts a JavaScript Date to a `Timestamp`.
|
||||
*/
|
||||
fromDate(date: Date): Timestamp {
|
||||
const msg = this.create();
|
||||
const ms = date.getTime();
|
||||
msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt();
|
||||
msg.nanos = (ms % 1000) * 1000000;
|
||||
return msg;
|
||||
}
|
||||
/**
|
||||
* In JSON format, the `Timestamp` type is encoded as a string
|
||||
* in the RFC 3339 format.
|
||||
*/
|
||||
internalJsonWrite(message: Timestamp, options: JsonWriteOptions): JsonValue {
|
||||
let ms = PbLong.from(message.seconds).toNumber() * 1000;
|
||||
if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z"))
|
||||
throw new Error("Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.");
|
||||
if (message.nanos < 0)
|
||||
throw new Error("Unable to encode invalid Timestamp to JSON. Nanos must not be negative.");
|
||||
let z = "Z";
|
||||
if (message.nanos > 0) {
|
||||
let nanosStr = (message.nanos + 1000000000).toString().substring(1);
|
||||
if (nanosStr.substring(3) === "000000")
|
||||
z = "." + nanosStr.substring(0, 3) + "Z";
|
||||
else if (nanosStr.substring(6) === "000")
|
||||
z = "." + nanosStr.substring(0, 6) + "Z";
|
||||
else
|
||||
z = "." + nanosStr + "Z";
|
||||
}
|
||||
return new Date(ms).toISOString().replace(".000Z", z);
|
||||
}
|
||||
/**
|
||||
* In JSON format, the `Timestamp` type is encoded as a string
|
||||
* in the RFC 3339 format.
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Timestamp): Timestamp {
|
||||
if (typeof json !== "string")
|
||||
throw new Error("Unable to parse Timestamp from JSON " + typeofJsonValue(json) + ".");
|
||||
let matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
|
||||
if (!matches)
|
||||
throw new Error("Unable to parse Timestamp from JSON. Invalid format.");
|
||||
let ms = Date.parse(matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z"));
|
||||
if (Number.isNaN(ms))
|
||||
throw new Error("Unable to parse Timestamp from JSON. Invalid value.");
|
||||
if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z"))
|
||||
throw new globalThis.Error("Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.");
|
||||
if (!target)
|
||||
target = this.create();
|
||||
target.seconds = PbLong.from(ms / 1000).toBigInt();
|
||||
target.nanos = 0;
|
||||
if (matches[7])
|
||||
target.nanos = (parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - 1000000000);
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<Timestamp>): Timestamp {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.seconds = 0n;
|
||||
message.nanos = 0;
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Timestamp>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Timestamp): Timestamp {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* int64 seconds */ 1:
|
||||
message.seconds = reader.int64().toBigInt();
|
||||
break;
|
||||
case /* int32 nanos */ 2:
|
||||
message.nanos = reader.int32();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Timestamp, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* int64 seconds = 1; */
|
||||
if (message.seconds !== 0n)
|
||||
writer.tag(1, WireType.Varint).int64(message.seconds);
|
||||
/* int32 nanos = 2; */
|
||||
if (message.nanos !== 0)
|
||||
writer.tag(2, WireType.Varint).int32(message.nanos);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Timestamp
|
||||
*/
|
||||
export const Timestamp = new Timestamp$Type();
|
||||
816
google/protobuf/type.ts
Normal file
816
google/protobuf/type.ts
Normal file
@@ -0,0 +1,816 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/protobuf/type.proto" (package "google.protobuf", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryWriter } from "@protobuf-ts/runtime";
|
||||
import { WireType } from "@protobuf-ts/runtime";
|
||||
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryReader } from "@protobuf-ts/runtime";
|
||||
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
|
||||
import type { PartialMessage } from "@protobuf-ts/runtime";
|
||||
import { reflectionMergePartial } from "@protobuf-ts/runtime";
|
||||
import { MessageType } from "@protobuf-ts/runtime";
|
||||
import { Any } from "./any";
|
||||
import { SourceContext } from "./source_context";
|
||||
/**
|
||||
* A protocol buffer message type.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Type
|
||||
*/
|
||||
export interface Type {
|
||||
/**
|
||||
* The fully qualified message name.
|
||||
*
|
||||
* @generated from protobuf field: string name = 1;
|
||||
*/
|
||||
name: string;
|
||||
/**
|
||||
* The list of fields.
|
||||
*
|
||||
* @generated from protobuf field: repeated google.protobuf.Field fields = 2;
|
||||
*/
|
||||
fields: Field[];
|
||||
/**
|
||||
* The list of types appearing in `oneof` definitions in this type.
|
||||
*
|
||||
* @generated from protobuf field: repeated string oneofs = 3;
|
||||
*/
|
||||
oneofs: string[];
|
||||
/**
|
||||
* The protocol buffer options.
|
||||
*
|
||||
* @generated from protobuf field: repeated google.protobuf.Option options = 4;
|
||||
*/
|
||||
options: Option[];
|
||||
/**
|
||||
* The source context.
|
||||
*
|
||||
* @generated from protobuf field: google.protobuf.SourceContext source_context = 5;
|
||||
*/
|
||||
sourceContext?: SourceContext;
|
||||
/**
|
||||
* The source syntax.
|
||||
*
|
||||
* @generated from protobuf field: google.protobuf.Syntax syntax = 6;
|
||||
*/
|
||||
syntax: Syntax;
|
||||
}
|
||||
/**
|
||||
* A single field of a message type.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Field
|
||||
*/
|
||||
export interface Field {
|
||||
/**
|
||||
* The field type.
|
||||
*
|
||||
* @generated from protobuf field: google.protobuf.Field.Kind kind = 1;
|
||||
*/
|
||||
kind: Field_Kind;
|
||||
/**
|
||||
* The field cardinality.
|
||||
*
|
||||
* @generated from protobuf field: google.protobuf.Field.Cardinality cardinality = 2;
|
||||
*/
|
||||
cardinality: Field_Cardinality;
|
||||
/**
|
||||
* The field number.
|
||||
*
|
||||
* @generated from protobuf field: int32 number = 3;
|
||||
*/
|
||||
number: number;
|
||||
/**
|
||||
* The field name.
|
||||
*
|
||||
* @generated from protobuf field: string name = 4;
|
||||
*/
|
||||
name: string;
|
||||
/**
|
||||
* The field type URL, without the scheme, for message or enumeration
|
||||
* types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
|
||||
*
|
||||
* @generated from protobuf field: string type_url = 6;
|
||||
*/
|
||||
typeUrl: string;
|
||||
/**
|
||||
* The index of the field type in `Type.oneofs`, for message or enumeration
|
||||
* types. The first type has index 1; zero means the type is not in the list.
|
||||
*
|
||||
* @generated from protobuf field: int32 oneof_index = 7;
|
||||
*/
|
||||
oneofIndex: number;
|
||||
/**
|
||||
* Whether to use alternative packed wire representation.
|
||||
*
|
||||
* @generated from protobuf field: bool packed = 8;
|
||||
*/
|
||||
packed: boolean;
|
||||
/**
|
||||
* The protocol buffer options.
|
||||
*
|
||||
* @generated from protobuf field: repeated google.protobuf.Option options = 9;
|
||||
*/
|
||||
options: Option[];
|
||||
/**
|
||||
* The field JSON name.
|
||||
*
|
||||
* @generated from protobuf field: string json_name = 10;
|
||||
*/
|
||||
jsonName: string;
|
||||
/**
|
||||
* The string value of the default value of this field. Proto2 syntax only.
|
||||
*
|
||||
* @generated from protobuf field: string default_value = 11;
|
||||
*/
|
||||
defaultValue: string;
|
||||
}
|
||||
/**
|
||||
* Basic field types.
|
||||
*
|
||||
* @generated from protobuf enum google.protobuf.Field.Kind
|
||||
*/
|
||||
export enum Field_Kind {
|
||||
/**
|
||||
* Field type unknown.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_UNKNOWN = 0;
|
||||
*/
|
||||
TYPE_UNKNOWN = 0,
|
||||
/**
|
||||
* Field type double.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_DOUBLE = 1;
|
||||
*/
|
||||
TYPE_DOUBLE = 1,
|
||||
/**
|
||||
* Field type float.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_FLOAT = 2;
|
||||
*/
|
||||
TYPE_FLOAT = 2,
|
||||
/**
|
||||
* Field type int64.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_INT64 = 3;
|
||||
*/
|
||||
TYPE_INT64 = 3,
|
||||
/**
|
||||
* Field type uint64.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_UINT64 = 4;
|
||||
*/
|
||||
TYPE_UINT64 = 4,
|
||||
/**
|
||||
* Field type int32.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_INT32 = 5;
|
||||
*/
|
||||
TYPE_INT32 = 5,
|
||||
/**
|
||||
* Field type fixed64.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_FIXED64 = 6;
|
||||
*/
|
||||
TYPE_FIXED64 = 6,
|
||||
/**
|
||||
* Field type fixed32.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_FIXED32 = 7;
|
||||
*/
|
||||
TYPE_FIXED32 = 7,
|
||||
/**
|
||||
* Field type bool.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_BOOL = 8;
|
||||
*/
|
||||
TYPE_BOOL = 8,
|
||||
/**
|
||||
* Field type string.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_STRING = 9;
|
||||
*/
|
||||
TYPE_STRING = 9,
|
||||
/**
|
||||
* Field type group. Proto2 syntax only, and deprecated.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_GROUP = 10;
|
||||
*/
|
||||
TYPE_GROUP = 10,
|
||||
/**
|
||||
* Field type message.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_MESSAGE = 11;
|
||||
*/
|
||||
TYPE_MESSAGE = 11,
|
||||
/**
|
||||
* Field type bytes.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_BYTES = 12;
|
||||
*/
|
||||
TYPE_BYTES = 12,
|
||||
/**
|
||||
* Field type uint32.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_UINT32 = 13;
|
||||
*/
|
||||
TYPE_UINT32 = 13,
|
||||
/**
|
||||
* Field type enum.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_ENUM = 14;
|
||||
*/
|
||||
TYPE_ENUM = 14,
|
||||
/**
|
||||
* Field type sfixed32.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_SFIXED32 = 15;
|
||||
*/
|
||||
TYPE_SFIXED32 = 15,
|
||||
/**
|
||||
* Field type sfixed64.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_SFIXED64 = 16;
|
||||
*/
|
||||
TYPE_SFIXED64 = 16,
|
||||
/**
|
||||
* Field type sint32.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_SINT32 = 17;
|
||||
*/
|
||||
TYPE_SINT32 = 17,
|
||||
/**
|
||||
* Field type sint64.
|
||||
*
|
||||
* @generated from protobuf enum value: TYPE_SINT64 = 18;
|
||||
*/
|
||||
TYPE_SINT64 = 18
|
||||
}
|
||||
/**
|
||||
* Whether a field is optional, required, or repeated.
|
||||
*
|
||||
* @generated from protobuf enum google.protobuf.Field.Cardinality
|
||||
*/
|
||||
export enum Field_Cardinality {
|
||||
/**
|
||||
* For fields with unknown cardinality.
|
||||
*
|
||||
* @generated from protobuf enum value: CARDINALITY_UNKNOWN = 0;
|
||||
*/
|
||||
UNKNOWN = 0,
|
||||
/**
|
||||
* For optional fields.
|
||||
*
|
||||
* @generated from protobuf enum value: CARDINALITY_OPTIONAL = 1;
|
||||
*/
|
||||
OPTIONAL = 1,
|
||||
/**
|
||||
* For required fields. Proto2 syntax only.
|
||||
*
|
||||
* @generated from protobuf enum value: CARDINALITY_REQUIRED = 2;
|
||||
*/
|
||||
REQUIRED = 2,
|
||||
/**
|
||||
* For repeated fields.
|
||||
*
|
||||
* @generated from protobuf enum value: CARDINALITY_REPEATED = 3;
|
||||
*/
|
||||
REPEATED = 3
|
||||
}
|
||||
/**
|
||||
* Enum type definition.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Enum
|
||||
*/
|
||||
export interface Enum {
|
||||
/**
|
||||
* Enum type name.
|
||||
*
|
||||
* @generated from protobuf field: string name = 1;
|
||||
*/
|
||||
name: string;
|
||||
/**
|
||||
* Enum value definitions.
|
||||
*
|
||||
* @generated from protobuf field: repeated google.protobuf.EnumValue enumvalue = 2;
|
||||
*/
|
||||
enumvalue: EnumValue[];
|
||||
/**
|
||||
* Protocol buffer options.
|
||||
*
|
||||
* @generated from protobuf field: repeated google.protobuf.Option options = 3;
|
||||
*/
|
||||
options: Option[];
|
||||
/**
|
||||
* The source context.
|
||||
*
|
||||
* @generated from protobuf field: google.protobuf.SourceContext source_context = 4;
|
||||
*/
|
||||
sourceContext?: SourceContext;
|
||||
/**
|
||||
* The source syntax.
|
||||
*
|
||||
* @generated from protobuf field: google.protobuf.Syntax syntax = 5;
|
||||
*/
|
||||
syntax: Syntax;
|
||||
}
|
||||
/**
|
||||
* Enum value definition.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.EnumValue
|
||||
*/
|
||||
export interface EnumValue {
|
||||
/**
|
||||
* Enum value name.
|
||||
*
|
||||
* @generated from protobuf field: string name = 1;
|
||||
*/
|
||||
name: string;
|
||||
/**
|
||||
* Enum value number.
|
||||
*
|
||||
* @generated from protobuf field: int32 number = 2;
|
||||
*/
|
||||
number: number;
|
||||
/**
|
||||
* Protocol buffer options.
|
||||
*
|
||||
* @generated from protobuf field: repeated google.protobuf.Option options = 3;
|
||||
*/
|
||||
options: Option[];
|
||||
}
|
||||
/**
|
||||
* A protocol buffer option, which can be attached to a message, field,
|
||||
* enumeration, etc.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Option
|
||||
*/
|
||||
export interface Option {
|
||||
/**
|
||||
* The option's name. For protobuf built-in options (options defined in
|
||||
* descriptor.proto), this is the short name. For example, `"map_entry"`.
|
||||
* For custom options, it should be the fully-qualified name. For example,
|
||||
* `"google.api.http"`.
|
||||
*
|
||||
* @generated from protobuf field: string name = 1;
|
||||
*/
|
||||
name: string;
|
||||
/**
|
||||
* The option's value packed in an Any message. If the value is a primitive,
|
||||
* the corresponding wrapper type defined in google/protobuf/wrappers.proto
|
||||
* should be used. If the value is an enum, it should be stored as an int32
|
||||
* value using the google.protobuf.Int32Value type.
|
||||
*
|
||||
* @generated from protobuf field: google.protobuf.Any value = 2;
|
||||
*/
|
||||
value?: Any;
|
||||
}
|
||||
/**
|
||||
* The syntax in which a protocol buffer element is defined.
|
||||
*
|
||||
* @generated from protobuf enum google.protobuf.Syntax
|
||||
*/
|
||||
export enum Syntax {
|
||||
/**
|
||||
* Syntax `proto2`.
|
||||
*
|
||||
* @generated from protobuf enum value: SYNTAX_PROTO2 = 0;
|
||||
*/
|
||||
PROTO2 = 0,
|
||||
/**
|
||||
* Syntax `proto3`.
|
||||
*
|
||||
* @generated from protobuf enum value: SYNTAX_PROTO3 = 1;
|
||||
*/
|
||||
PROTO3 = 1
|
||||
}
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Type$Type extends MessageType<Type> {
|
||||
constructor() {
|
||||
super("google.protobuf.Type", [
|
||||
{ no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 2, name: "fields", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Field },
|
||||
{ no: 3, name: "oneofs", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 4, name: "options", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Option },
|
||||
{ no: 5, name: "source_context", kind: "message", T: () => SourceContext },
|
||||
{ no: 6, name: "syntax", kind: "enum", T: () => ["google.protobuf.Syntax", Syntax, "SYNTAX_"] }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<Type>): Type {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.name = "";
|
||||
message.fields = [];
|
||||
message.oneofs = [];
|
||||
message.options = [];
|
||||
message.syntax = 0;
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Type>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Type): Type {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* string name */ 1:
|
||||
message.name = reader.string();
|
||||
break;
|
||||
case /* repeated google.protobuf.Field fields */ 2:
|
||||
message.fields.push(Field.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
case /* repeated string oneofs */ 3:
|
||||
message.oneofs.push(reader.string());
|
||||
break;
|
||||
case /* repeated google.protobuf.Option options */ 4:
|
||||
message.options.push(Option.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
case /* google.protobuf.SourceContext source_context */ 5:
|
||||
message.sourceContext = SourceContext.internalBinaryRead(reader, reader.uint32(), options, message.sourceContext);
|
||||
break;
|
||||
case /* google.protobuf.Syntax syntax */ 6:
|
||||
message.syntax = reader.int32();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Type, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* string name = 1; */
|
||||
if (message.name !== "")
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.name);
|
||||
/* repeated google.protobuf.Field fields = 2; */
|
||||
for (let i = 0; i < message.fields.length; i++)
|
||||
Field.internalBinaryWrite(message.fields[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
|
||||
/* repeated string oneofs = 3; */
|
||||
for (let i = 0; i < message.oneofs.length; i++)
|
||||
writer.tag(3, WireType.LengthDelimited).string(message.oneofs[i]);
|
||||
/* repeated google.protobuf.Option options = 4; */
|
||||
for (let i = 0; i < message.options.length; i++)
|
||||
Option.internalBinaryWrite(message.options[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
|
||||
/* google.protobuf.SourceContext source_context = 5; */
|
||||
if (message.sourceContext)
|
||||
SourceContext.internalBinaryWrite(message.sourceContext, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
|
||||
/* google.protobuf.Syntax syntax = 6; */
|
||||
if (message.syntax !== 0)
|
||||
writer.tag(6, WireType.Varint).int32(message.syntax);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Type
|
||||
*/
|
||||
export const Type = new Type$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Field$Type extends MessageType<Field> {
|
||||
constructor() {
|
||||
super("google.protobuf.Field", [
|
||||
{ no: 1, name: "kind", kind: "enum", T: () => ["google.protobuf.Field.Kind", Field_Kind] },
|
||||
{ no: 2, name: "cardinality", kind: "enum", T: () => ["google.protobuf.Field.Cardinality", Field_Cardinality, "CARDINALITY_"] },
|
||||
{ no: 3, name: "number", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
|
||||
{ no: 4, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 6, name: "type_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 7, name: "oneof_index", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
|
||||
{ no: 8, name: "packed", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
|
||||
{ no: 9, name: "options", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Option },
|
||||
{ no: 10, name: "json_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 11, name: "default_value", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<Field>): Field {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.kind = 0;
|
||||
message.cardinality = 0;
|
||||
message.number = 0;
|
||||
message.name = "";
|
||||
message.typeUrl = "";
|
||||
message.oneofIndex = 0;
|
||||
message.packed = false;
|
||||
message.options = [];
|
||||
message.jsonName = "";
|
||||
message.defaultValue = "";
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Field>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Field): Field {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* google.protobuf.Field.Kind kind */ 1:
|
||||
message.kind = reader.int32();
|
||||
break;
|
||||
case /* google.protobuf.Field.Cardinality cardinality */ 2:
|
||||
message.cardinality = reader.int32();
|
||||
break;
|
||||
case /* int32 number */ 3:
|
||||
message.number = reader.int32();
|
||||
break;
|
||||
case /* string name */ 4:
|
||||
message.name = reader.string();
|
||||
break;
|
||||
case /* string type_url */ 6:
|
||||
message.typeUrl = reader.string();
|
||||
break;
|
||||
case /* int32 oneof_index */ 7:
|
||||
message.oneofIndex = reader.int32();
|
||||
break;
|
||||
case /* bool packed */ 8:
|
||||
message.packed = reader.bool();
|
||||
break;
|
||||
case /* repeated google.protobuf.Option options */ 9:
|
||||
message.options.push(Option.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
case /* string json_name */ 10:
|
||||
message.jsonName = reader.string();
|
||||
break;
|
||||
case /* string default_value */ 11:
|
||||
message.defaultValue = reader.string();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Field, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* google.protobuf.Field.Kind kind = 1; */
|
||||
if (message.kind !== 0)
|
||||
writer.tag(1, WireType.Varint).int32(message.kind);
|
||||
/* google.protobuf.Field.Cardinality cardinality = 2; */
|
||||
if (message.cardinality !== 0)
|
||||
writer.tag(2, WireType.Varint).int32(message.cardinality);
|
||||
/* int32 number = 3; */
|
||||
if (message.number !== 0)
|
||||
writer.tag(3, WireType.Varint).int32(message.number);
|
||||
/* string name = 4; */
|
||||
if (message.name !== "")
|
||||
writer.tag(4, WireType.LengthDelimited).string(message.name);
|
||||
/* string type_url = 6; */
|
||||
if (message.typeUrl !== "")
|
||||
writer.tag(6, WireType.LengthDelimited).string(message.typeUrl);
|
||||
/* int32 oneof_index = 7; */
|
||||
if (message.oneofIndex !== 0)
|
||||
writer.tag(7, WireType.Varint).int32(message.oneofIndex);
|
||||
/* bool packed = 8; */
|
||||
if (message.packed !== false)
|
||||
writer.tag(8, WireType.Varint).bool(message.packed);
|
||||
/* repeated google.protobuf.Option options = 9; */
|
||||
for (let i = 0; i < message.options.length; i++)
|
||||
Option.internalBinaryWrite(message.options[i], writer.tag(9, WireType.LengthDelimited).fork(), options).join();
|
||||
/* string json_name = 10; */
|
||||
if (message.jsonName !== "")
|
||||
writer.tag(10, WireType.LengthDelimited).string(message.jsonName);
|
||||
/* string default_value = 11; */
|
||||
if (message.defaultValue !== "")
|
||||
writer.tag(11, WireType.LengthDelimited).string(message.defaultValue);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Field
|
||||
*/
|
||||
export const Field = new Field$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Enum$Type extends MessageType<Enum> {
|
||||
constructor() {
|
||||
super("google.protobuf.Enum", [
|
||||
{ no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 2, name: "enumvalue", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => EnumValue },
|
||||
{ no: 3, name: "options", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Option },
|
||||
{ no: 4, name: "source_context", kind: "message", T: () => SourceContext },
|
||||
{ no: 5, name: "syntax", kind: "enum", T: () => ["google.protobuf.Syntax", Syntax, "SYNTAX_"] }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<Enum>): Enum {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.name = "";
|
||||
message.enumvalue = [];
|
||||
message.options = [];
|
||||
message.syntax = 0;
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Enum>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Enum): Enum {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* string name */ 1:
|
||||
message.name = reader.string();
|
||||
break;
|
||||
case /* repeated google.protobuf.EnumValue enumvalue */ 2:
|
||||
message.enumvalue.push(EnumValue.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
case /* repeated google.protobuf.Option options */ 3:
|
||||
message.options.push(Option.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
case /* google.protobuf.SourceContext source_context */ 4:
|
||||
message.sourceContext = SourceContext.internalBinaryRead(reader, reader.uint32(), options, message.sourceContext);
|
||||
break;
|
||||
case /* google.protobuf.Syntax syntax */ 5:
|
||||
message.syntax = reader.int32();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Enum, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* string name = 1; */
|
||||
if (message.name !== "")
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.name);
|
||||
/* repeated google.protobuf.EnumValue enumvalue = 2; */
|
||||
for (let i = 0; i < message.enumvalue.length; i++)
|
||||
EnumValue.internalBinaryWrite(message.enumvalue[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
|
||||
/* repeated google.protobuf.Option options = 3; */
|
||||
for (let i = 0; i < message.options.length; i++)
|
||||
Option.internalBinaryWrite(message.options[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
||||
/* google.protobuf.SourceContext source_context = 4; */
|
||||
if (message.sourceContext)
|
||||
SourceContext.internalBinaryWrite(message.sourceContext, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
|
||||
/* google.protobuf.Syntax syntax = 5; */
|
||||
if (message.syntax !== 0)
|
||||
writer.tag(5, WireType.Varint).int32(message.syntax);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Enum
|
||||
*/
|
||||
export const Enum = new Enum$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class EnumValue$Type extends MessageType<EnumValue> {
|
||||
constructor() {
|
||||
super("google.protobuf.EnumValue", [
|
||||
{ no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 2, name: "number", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
|
||||
{ no: 3, name: "options", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Option }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<EnumValue>): EnumValue {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.name = "";
|
||||
message.number = 0;
|
||||
message.options = [];
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<EnumValue>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EnumValue): EnumValue {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* string name */ 1:
|
||||
message.name = reader.string();
|
||||
break;
|
||||
case /* int32 number */ 2:
|
||||
message.number = reader.int32();
|
||||
break;
|
||||
case /* repeated google.protobuf.Option options */ 3:
|
||||
message.options.push(Option.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: EnumValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* string name = 1; */
|
||||
if (message.name !== "")
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.name);
|
||||
/* int32 number = 2; */
|
||||
if (message.number !== 0)
|
||||
writer.tag(2, WireType.Varint).int32(message.number);
|
||||
/* repeated google.protobuf.Option options = 3; */
|
||||
for (let i = 0; i < message.options.length; i++)
|
||||
Option.internalBinaryWrite(message.options[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.EnumValue
|
||||
*/
|
||||
export const EnumValue = new EnumValue$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Option$Type extends MessageType<Option> {
|
||||
constructor() {
|
||||
super("google.protobuf.Option", [
|
||||
{ no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 2, name: "value", kind: "message", T: () => Any }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<Option>): Option {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.name = "";
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Option>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Option): Option {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* string name */ 1:
|
||||
message.name = reader.string();
|
||||
break;
|
||||
case /* google.protobuf.Any value */ 2:
|
||||
message.value = Any.internalBinaryRead(reader, reader.uint32(), options, message.value);
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Option, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* string name = 1; */
|
||||
if (message.name !== "")
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.name);
|
||||
/* google.protobuf.Any value = 2; */
|
||||
if (message.value)
|
||||
Any.internalBinaryWrite(message.value, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Option
|
||||
*/
|
||||
export const Option = new Option$Type();
|
||||
752
google/protobuf/wrappers.ts
Normal file
752
google/protobuf/wrappers.ts
Normal file
@@ -0,0 +1,752 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/protobuf/wrappers.proto" (package "google.protobuf", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// https://developers.google.com/protocol-buffers/
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
//
|
||||
// Wrappers for primitive (non-message) types. These types are useful
|
||||
// for embedding primitives in the `google.protobuf.Any` type and for places
|
||||
// where we need to distinguish between the absence of a primitive
|
||||
// typed field and its default value.
|
||||
//
|
||||
// These wrappers have no meaningful use within repeated fields as they lack
|
||||
// the ability to detect presence on individual elements.
|
||||
// These wrappers have no meaningful use within a map or a oneof since
|
||||
// individual entries of a map or fields of a oneof can already detect presence.
|
||||
//
|
||||
import { ScalarType } from "@protobuf-ts/runtime";
|
||||
import { LongType } from "@protobuf-ts/runtime";
|
||||
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryWriter } from "@protobuf-ts/runtime";
|
||||
import { WireType } from "@protobuf-ts/runtime";
|
||||
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryReader } from "@protobuf-ts/runtime";
|
||||
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
|
||||
import type { PartialMessage } from "@protobuf-ts/runtime";
|
||||
import { reflectionMergePartial } from "@protobuf-ts/runtime";
|
||||
import type { JsonValue } from "@protobuf-ts/runtime";
|
||||
import type { JsonReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { JsonWriteOptions } from "@protobuf-ts/runtime";
|
||||
import { MessageType } from "@protobuf-ts/runtime";
|
||||
/**
|
||||
* Wrapper message for `double`.
|
||||
*
|
||||
* The JSON representation for `DoubleValue` is JSON number.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.DoubleValue
|
||||
*/
|
||||
export interface DoubleValue {
|
||||
/**
|
||||
* The double value.
|
||||
*
|
||||
* @generated from protobuf field: double value = 1;
|
||||
*/
|
||||
value: number;
|
||||
}
|
||||
/**
|
||||
* Wrapper message for `float`.
|
||||
*
|
||||
* The JSON representation for `FloatValue` is JSON number.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.FloatValue
|
||||
*/
|
||||
export interface FloatValue {
|
||||
/**
|
||||
* The float value.
|
||||
*
|
||||
* @generated from protobuf field: float value = 1;
|
||||
*/
|
||||
value: number;
|
||||
}
|
||||
/**
|
||||
* Wrapper message for `int64`.
|
||||
*
|
||||
* The JSON representation for `Int64Value` is JSON string.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Int64Value
|
||||
*/
|
||||
export interface Int64Value {
|
||||
/**
|
||||
* The int64 value.
|
||||
*
|
||||
* @generated from protobuf field: int64 value = 1;
|
||||
*/
|
||||
value: bigint;
|
||||
}
|
||||
/**
|
||||
* Wrapper message for `uint64`.
|
||||
*
|
||||
* The JSON representation for `UInt64Value` is JSON string.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.UInt64Value
|
||||
*/
|
||||
export interface UInt64Value {
|
||||
/**
|
||||
* The uint64 value.
|
||||
*
|
||||
* @generated from protobuf field: uint64 value = 1;
|
||||
*/
|
||||
value: bigint;
|
||||
}
|
||||
/**
|
||||
* Wrapper message for `int32`.
|
||||
*
|
||||
* The JSON representation for `Int32Value` is JSON number.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.Int32Value
|
||||
*/
|
||||
export interface Int32Value {
|
||||
/**
|
||||
* The int32 value.
|
||||
*
|
||||
* @generated from protobuf field: int32 value = 1;
|
||||
*/
|
||||
value: number;
|
||||
}
|
||||
/**
|
||||
* Wrapper message for `uint32`.
|
||||
*
|
||||
* The JSON representation for `UInt32Value` is JSON number.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.UInt32Value
|
||||
*/
|
||||
export interface UInt32Value {
|
||||
/**
|
||||
* The uint32 value.
|
||||
*
|
||||
* @generated from protobuf field: uint32 value = 1;
|
||||
*/
|
||||
value: number;
|
||||
}
|
||||
/**
|
||||
* Wrapper message for `bool`.
|
||||
*
|
||||
* The JSON representation for `BoolValue` is JSON `true` and `false`.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.BoolValue
|
||||
*/
|
||||
export interface BoolValue {
|
||||
/**
|
||||
* The bool value.
|
||||
*
|
||||
* @generated from protobuf field: bool value = 1;
|
||||
*/
|
||||
value: boolean;
|
||||
}
|
||||
/**
|
||||
* Wrapper message for `string`.
|
||||
*
|
||||
* The JSON representation for `StringValue` is JSON string.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.StringValue
|
||||
*/
|
||||
export interface StringValue {
|
||||
/**
|
||||
* The string value.
|
||||
*
|
||||
* @generated from protobuf field: string value = 1;
|
||||
*/
|
||||
value: string;
|
||||
}
|
||||
/**
|
||||
* Wrapper message for `bytes`.
|
||||
*
|
||||
* The JSON representation for `BytesValue` is JSON string.
|
||||
*
|
||||
* @generated from protobuf message google.protobuf.BytesValue
|
||||
*/
|
||||
export interface BytesValue {
|
||||
/**
|
||||
* The bytes value.
|
||||
*
|
||||
* @generated from protobuf field: bytes value = 1;
|
||||
*/
|
||||
value: Uint8Array;
|
||||
}
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class DoubleValue$Type extends MessageType<DoubleValue> {
|
||||
constructor() {
|
||||
super("google.protobuf.DoubleValue", [
|
||||
{ no: 1, name: "value", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Encode `DoubleValue` to JSON number.
|
||||
*/
|
||||
internalJsonWrite(message: DoubleValue, options: JsonWriteOptions): JsonValue {
|
||||
return this.refJsonWriter.scalar(2, message.value, "value", false, true);
|
||||
}
|
||||
/**
|
||||
* Decode `DoubleValue` from JSON number.
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: DoubleValue): DoubleValue {
|
||||
if (!target)
|
||||
target = this.create();
|
||||
target.value = this.refJsonReader.scalar(json, 1, undefined, "value") as number;
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<DoubleValue>): DoubleValue {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.value = 0;
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<DoubleValue>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DoubleValue): DoubleValue {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* double value */ 1:
|
||||
message.value = reader.double();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: DoubleValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* double value = 1; */
|
||||
if (message.value !== 0)
|
||||
writer.tag(1, WireType.Bit64).double(message.value);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.DoubleValue
|
||||
*/
|
||||
export const DoubleValue = new DoubleValue$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class FloatValue$Type extends MessageType<FloatValue> {
|
||||
constructor() {
|
||||
super("google.protobuf.FloatValue", [
|
||||
{ no: 1, name: "value", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Encode `FloatValue` to JSON number.
|
||||
*/
|
||||
internalJsonWrite(message: FloatValue, options: JsonWriteOptions): JsonValue {
|
||||
return this.refJsonWriter.scalar(1, message.value, "value", false, true);
|
||||
}
|
||||
/**
|
||||
* Decode `FloatValue` from JSON number.
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: FloatValue): FloatValue {
|
||||
if (!target)
|
||||
target = this.create();
|
||||
target.value = this.refJsonReader.scalar(json, 1, undefined, "value") as number;
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<FloatValue>): FloatValue {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.value = 0;
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<FloatValue>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FloatValue): FloatValue {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* float value */ 1:
|
||||
message.value = reader.float();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: FloatValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* float value = 1; */
|
||||
if (message.value !== 0)
|
||||
writer.tag(1, WireType.Bit32).float(message.value);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.FloatValue
|
||||
*/
|
||||
export const FloatValue = new FloatValue$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Int64Value$Type extends MessageType<Int64Value> {
|
||||
constructor() {
|
||||
super("google.protobuf.Int64Value", [
|
||||
{ no: 1, name: "value", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Encode `Int64Value` to JSON string.
|
||||
*/
|
||||
internalJsonWrite(message: Int64Value, options: JsonWriteOptions): JsonValue {
|
||||
return this.refJsonWriter.scalar(ScalarType.INT64, message.value, "value", false, true);
|
||||
}
|
||||
/**
|
||||
* Decode `Int64Value` from JSON string.
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Int64Value): Int64Value {
|
||||
if (!target)
|
||||
target = this.create();
|
||||
target.value = this.refJsonReader.scalar(json, ScalarType.INT64, LongType.BIGINT, "value") as any;
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<Int64Value>): Int64Value {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.value = 0n;
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Int64Value>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Int64Value): Int64Value {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* int64 value */ 1:
|
||||
message.value = reader.int64().toBigInt();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Int64Value, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* int64 value = 1; */
|
||||
if (message.value !== 0n)
|
||||
writer.tag(1, WireType.Varint).int64(message.value);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Int64Value
|
||||
*/
|
||||
export const Int64Value = new Int64Value$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class UInt64Value$Type extends MessageType<UInt64Value> {
|
||||
constructor() {
|
||||
super("google.protobuf.UInt64Value", [
|
||||
{ no: 1, name: "value", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Encode `UInt64Value` to JSON string.
|
||||
*/
|
||||
internalJsonWrite(message: UInt64Value, options: JsonWriteOptions): JsonValue {
|
||||
return this.refJsonWriter.scalar(ScalarType.UINT64, message.value, "value", false, true);
|
||||
}
|
||||
/**
|
||||
* Decode `UInt64Value` from JSON string.
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: UInt64Value): UInt64Value {
|
||||
if (!target)
|
||||
target = this.create();
|
||||
target.value = this.refJsonReader.scalar(json, ScalarType.UINT64, LongType.BIGINT, "value") as any;
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<UInt64Value>): UInt64Value {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.value = 0n;
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<UInt64Value>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UInt64Value): UInt64Value {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* uint64 value */ 1:
|
||||
message.value = reader.uint64().toBigInt();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: UInt64Value, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* uint64 value = 1; */
|
||||
if (message.value !== 0n)
|
||||
writer.tag(1, WireType.Varint).uint64(message.value);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.UInt64Value
|
||||
*/
|
||||
export const UInt64Value = new UInt64Value$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Int32Value$Type extends MessageType<Int32Value> {
|
||||
constructor() {
|
||||
super("google.protobuf.Int32Value", [
|
||||
{ no: 1, name: "value", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Encode `Int32Value` to JSON string.
|
||||
*/
|
||||
internalJsonWrite(message: Int32Value, options: JsonWriteOptions): JsonValue {
|
||||
return this.refJsonWriter.scalar(5, message.value, "value", false, true);
|
||||
}
|
||||
/**
|
||||
* Decode `Int32Value` from JSON string.
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Int32Value): Int32Value {
|
||||
if (!target)
|
||||
target = this.create();
|
||||
target.value = this.refJsonReader.scalar(json, 5, undefined, "value") as number;
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<Int32Value>): Int32Value {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.value = 0;
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Int32Value>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Int32Value): Int32Value {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* int32 value */ 1:
|
||||
message.value = reader.int32();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Int32Value, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* int32 value = 1; */
|
||||
if (message.value !== 0)
|
||||
writer.tag(1, WireType.Varint).int32(message.value);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.Int32Value
|
||||
*/
|
||||
export const Int32Value = new Int32Value$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class UInt32Value$Type extends MessageType<UInt32Value> {
|
||||
constructor() {
|
||||
super("google.protobuf.UInt32Value", [
|
||||
{ no: 1, name: "value", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Encode `UInt32Value` to JSON string.
|
||||
*/
|
||||
internalJsonWrite(message: UInt32Value, options: JsonWriteOptions): JsonValue {
|
||||
return this.refJsonWriter.scalar(13, message.value, "value", false, true);
|
||||
}
|
||||
/**
|
||||
* Decode `UInt32Value` from JSON string.
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: UInt32Value): UInt32Value {
|
||||
if (!target)
|
||||
target = this.create();
|
||||
target.value = this.refJsonReader.scalar(json, 13, undefined, "value") as number;
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<UInt32Value>): UInt32Value {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.value = 0;
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<UInt32Value>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UInt32Value): UInt32Value {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* uint32 value */ 1:
|
||||
message.value = reader.uint32();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: UInt32Value, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* uint32 value = 1; */
|
||||
if (message.value !== 0)
|
||||
writer.tag(1, WireType.Varint).uint32(message.value);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.UInt32Value
|
||||
*/
|
||||
export const UInt32Value = new UInt32Value$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class BoolValue$Type extends MessageType<BoolValue> {
|
||||
constructor() {
|
||||
super("google.protobuf.BoolValue", [
|
||||
{ no: 1, name: "value", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Encode `BoolValue` to JSON bool.
|
||||
*/
|
||||
internalJsonWrite(message: BoolValue, options: JsonWriteOptions): JsonValue {
|
||||
return message.value;
|
||||
}
|
||||
/**
|
||||
* Decode `BoolValue` from JSON bool.
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: BoolValue): BoolValue {
|
||||
if (!target)
|
||||
target = this.create();
|
||||
target.value = this.refJsonReader.scalar(json, 8, undefined, "value") as boolean;
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<BoolValue>): BoolValue {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.value = false;
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<BoolValue>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: BoolValue): BoolValue {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* bool value */ 1:
|
||||
message.value = reader.bool();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: BoolValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* bool value = 1; */
|
||||
if (message.value !== false)
|
||||
writer.tag(1, WireType.Varint).bool(message.value);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.BoolValue
|
||||
*/
|
||||
export const BoolValue = new BoolValue$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class StringValue$Type extends MessageType<StringValue> {
|
||||
constructor() {
|
||||
super("google.protobuf.StringValue", [
|
||||
{ no: 1, name: "value", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Encode `StringValue` to JSON string.
|
||||
*/
|
||||
internalJsonWrite(message: StringValue, options: JsonWriteOptions): JsonValue {
|
||||
return message.value;
|
||||
}
|
||||
/**
|
||||
* Decode `StringValue` from JSON string.
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: StringValue): StringValue {
|
||||
if (!target)
|
||||
target = this.create();
|
||||
target.value = this.refJsonReader.scalar(json, 9, undefined, "value") as string;
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<StringValue>): StringValue {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.value = "";
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<StringValue>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StringValue): StringValue {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* string value */ 1:
|
||||
message.value = reader.string();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: StringValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* string value = 1; */
|
||||
if (message.value !== "")
|
||||
writer.tag(1, WireType.LengthDelimited).string(message.value);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.StringValue
|
||||
*/
|
||||
export const StringValue = new StringValue$Type();
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class BytesValue$Type extends MessageType<BytesValue> {
|
||||
constructor() {
|
||||
super("google.protobuf.BytesValue", [
|
||||
{ no: 1, name: "value", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
|
||||
]);
|
||||
}
|
||||
/**
|
||||
* Encode `BytesValue` to JSON string.
|
||||
*/
|
||||
internalJsonWrite(message: BytesValue, options: JsonWriteOptions): JsonValue {
|
||||
return this.refJsonWriter.scalar(12, message.value, "value", false, true);
|
||||
}
|
||||
/**
|
||||
* Decode `BytesValue` from JSON string.
|
||||
*/
|
||||
internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: BytesValue): BytesValue {
|
||||
if (!target)
|
||||
target = this.create();
|
||||
target.value = this.refJsonReader.scalar(json, 12, undefined, "value") as Uint8Array;
|
||||
return target;
|
||||
}
|
||||
create(value?: PartialMessage<BytesValue>): BytesValue {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.value = new Uint8Array(0);
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<BytesValue>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: BytesValue): BytesValue {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* bytes value */ 1:
|
||||
message.value = reader.bytes();
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: BytesValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* bytes value = 1; */
|
||||
if (message.value.length)
|
||||
writer.tag(1, WireType.LengthDelimited).bytes(message.value);
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.protobuf.BytesValue
|
||||
*/
|
||||
export const BytesValue = new BytesValue$Type();
|
||||
235
google/rpc/code.ts
Normal file
235
google/rpc/code.ts
Normal file
@@ -0,0 +1,235 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/rpc/code.proto" (package "google.rpc", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Copyright 2017 Google Inc.
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
/**
|
||||
* The canonical error codes for Google APIs.
|
||||
*
|
||||
*
|
||||
* Sometimes multiple error codes may apply. Services should return
|
||||
* the most specific error code that applies. For example, prefer
|
||||
* `OUT_OF_RANGE` over `FAILED_PRECONDITION` if both codes apply.
|
||||
* Similarly prefer `NOT_FOUND` or `ALREADY_EXISTS` over `FAILED_PRECONDITION`.
|
||||
*
|
||||
* @generated from protobuf enum google.rpc.Code
|
||||
*/
|
||||
export enum Code {
|
||||
/**
|
||||
* Not an error; returned on success
|
||||
*
|
||||
* HTTP Mapping: 200 OK
|
||||
*
|
||||
* @generated from protobuf enum value: OK = 0;
|
||||
*/
|
||||
OK = 0,
|
||||
/**
|
||||
* The operation was cancelled, typically by the caller.
|
||||
*
|
||||
* HTTP Mapping: 499 Client Closed Request
|
||||
*
|
||||
* @generated from protobuf enum value: CANCELLED = 1;
|
||||
*/
|
||||
CANCELLED = 1,
|
||||
/**
|
||||
* Unknown error. For example, this error may be returned when
|
||||
* a `Status` value received from another address space belongs to
|
||||
* an error space that is not known in this address space. Also
|
||||
* errors raised by APIs that do not return enough error information
|
||||
* may be converted to this error.
|
||||
*
|
||||
* HTTP Mapping: 500 Internal Server Error
|
||||
*
|
||||
* @generated from protobuf enum value: UNKNOWN = 2;
|
||||
*/
|
||||
UNKNOWN = 2,
|
||||
/**
|
||||
* The client specified an invalid argument. Note that this differs
|
||||
* from `FAILED_PRECONDITION`. `INVALID_ARGUMENT` indicates arguments
|
||||
* that are problematic regardless of the state of the system
|
||||
* (e.g., a malformed file name).
|
||||
*
|
||||
* HTTP Mapping: 400 Bad Request
|
||||
*
|
||||
* @generated from protobuf enum value: INVALID_ARGUMENT = 3;
|
||||
*/
|
||||
INVALID_ARGUMENT = 3,
|
||||
/**
|
||||
* The deadline expired before the operation could complete. For operations
|
||||
* that change the state of the system, this error may be returned
|
||||
* even if the operation has completed successfully. For example, a
|
||||
* successful response from a server could have been delayed long
|
||||
* enough for the deadline to expire.
|
||||
*
|
||||
* HTTP Mapping: 504 Gateway Timeout
|
||||
*
|
||||
* @generated from protobuf enum value: DEADLINE_EXCEEDED = 4;
|
||||
*/
|
||||
DEADLINE_EXCEEDED = 4,
|
||||
/**
|
||||
* Some requested entity (e.g., file or directory) was not found.
|
||||
*
|
||||
* Note to server developers: if a request is denied for an entire class
|
||||
* of users, such as gradual feature rollout or undocumented whitelist,
|
||||
* `NOT_FOUND` may be used. If a request is denied for some users within
|
||||
* a class of users, such as user-based access control, `PERMISSION_DENIED`
|
||||
* must be used.
|
||||
*
|
||||
* HTTP Mapping: 404 Not Found
|
||||
*
|
||||
* @generated from protobuf enum value: NOT_FOUND = 5;
|
||||
*/
|
||||
NOT_FOUND = 5,
|
||||
/**
|
||||
* The entity that a client attempted to create (e.g., file or directory)
|
||||
* already exists.
|
||||
*
|
||||
* HTTP Mapping: 409 Conflict
|
||||
*
|
||||
* @generated from protobuf enum value: ALREADY_EXISTS = 6;
|
||||
*/
|
||||
ALREADY_EXISTS = 6,
|
||||
/**
|
||||
* The caller does not have permission to execute the specified
|
||||
* operation. `PERMISSION_DENIED` must not be used for rejections
|
||||
* caused by exhausting some resource (use `RESOURCE_EXHAUSTED`
|
||||
* instead for those errors). `PERMISSION_DENIED` must not be
|
||||
* used if the caller can not be identified (use `UNAUTHENTICATED`
|
||||
* instead for those errors). This error code does not imply the
|
||||
* request is valid or the requested entity exists or satisfies
|
||||
* other pre-conditions.
|
||||
*
|
||||
* HTTP Mapping: 403 Forbidden
|
||||
*
|
||||
* @generated from protobuf enum value: PERMISSION_DENIED = 7;
|
||||
*/
|
||||
PERMISSION_DENIED = 7,
|
||||
/**
|
||||
* The request does not have valid authentication credentials for the
|
||||
* operation.
|
||||
*
|
||||
* HTTP Mapping: 401 Unauthorized
|
||||
*
|
||||
* @generated from protobuf enum value: UNAUTHENTICATED = 16;
|
||||
*/
|
||||
UNAUTHENTICATED = 16,
|
||||
/**
|
||||
* Some resource has been exhausted, perhaps a per-user quota, or
|
||||
* perhaps the entire file system is out of space.
|
||||
*
|
||||
* HTTP Mapping: 429 Too Many Requests
|
||||
*
|
||||
* @generated from protobuf enum value: RESOURCE_EXHAUSTED = 8;
|
||||
*/
|
||||
RESOURCE_EXHAUSTED = 8,
|
||||
/**
|
||||
* The operation was rejected because the system is not in a state
|
||||
* required for the operation's execution. For example, the directory
|
||||
* to be deleted is non-empty, an rmdir operation is applied to
|
||||
* a non-directory, etc.
|
||||
*
|
||||
* Service implementors can use the following guidelines to decide
|
||||
* between `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`:
|
||||
* (a) Use `UNAVAILABLE` if the client can retry just the failing call.
|
||||
* (b) Use `ABORTED` if the client should retry at a higher level
|
||||
* (e.g., when a client-specified test-and-set fails, indicating the
|
||||
* client should restart a read-modify-write sequence).
|
||||
* (c) Use `FAILED_PRECONDITION` if the client should not retry until
|
||||
* the system state has been explicitly fixed. E.g., if an "rmdir"
|
||||
* fails because the directory is non-empty, `FAILED_PRECONDITION`
|
||||
* should be returned since the client should not retry unless
|
||||
* the files are deleted from the directory.
|
||||
*
|
||||
* HTTP Mapping: 400 Bad Request
|
||||
*
|
||||
* @generated from protobuf enum value: FAILED_PRECONDITION = 9;
|
||||
*/
|
||||
FAILED_PRECONDITION = 9,
|
||||
/**
|
||||
* The operation was aborted, typically due to a concurrency issue such as
|
||||
* a sequencer check failure or transaction abort.
|
||||
*
|
||||
* See the guidelines above for deciding between `FAILED_PRECONDITION`,
|
||||
* `ABORTED`, and `UNAVAILABLE`.
|
||||
*
|
||||
* HTTP Mapping: 409 Conflict
|
||||
*
|
||||
* @generated from protobuf enum value: ABORTED = 10;
|
||||
*/
|
||||
ABORTED = 10,
|
||||
/**
|
||||
* The operation was attempted past the valid range. E.g., seeking or
|
||||
* reading past end-of-file.
|
||||
*
|
||||
* Unlike `INVALID_ARGUMENT`, this error indicates a problem that may
|
||||
* be fixed if the system state changes. For example, a 32-bit file
|
||||
* system will generate `INVALID_ARGUMENT` if asked to read at an
|
||||
* offset that is not in the range [0,2^32-1], but it will generate
|
||||
* `OUT_OF_RANGE` if asked to read from an offset past the current
|
||||
* file size.
|
||||
*
|
||||
* There is a fair bit of overlap between `FAILED_PRECONDITION` and
|
||||
* `OUT_OF_RANGE`. We recommend using `OUT_OF_RANGE` (the more specific
|
||||
* error) when it applies so that callers who are iterating through
|
||||
* a space can easily look for an `OUT_OF_RANGE` error to detect when
|
||||
* they are done.
|
||||
*
|
||||
* HTTP Mapping: 400 Bad Request
|
||||
*
|
||||
* @generated from protobuf enum value: OUT_OF_RANGE = 11;
|
||||
*/
|
||||
OUT_OF_RANGE = 11,
|
||||
/**
|
||||
* The operation is not implemented or is not supported/enabled in this
|
||||
* service.
|
||||
*
|
||||
* HTTP Mapping: 501 Not Implemented
|
||||
*
|
||||
* @generated from protobuf enum value: UNIMPLEMENTED = 12;
|
||||
*/
|
||||
UNIMPLEMENTED = 12,
|
||||
/**
|
||||
* Internal errors. This means that some invariants expected by the
|
||||
* underlying system have been broken. This error code is reserved
|
||||
* for serious errors.
|
||||
*
|
||||
* HTTP Mapping: 500 Internal Server Error
|
||||
*
|
||||
* @generated from protobuf enum value: INTERNAL = 13;
|
||||
*/
|
||||
INTERNAL = 13,
|
||||
/**
|
||||
* The service is currently unavailable. This is most likely a
|
||||
* transient condition, which can be corrected by retrying with
|
||||
* a backoff.
|
||||
*
|
||||
* See the guidelines above for deciding between `FAILED_PRECONDITION`,
|
||||
* `ABORTED`, and `UNAVAILABLE`.
|
||||
*
|
||||
* HTTP Mapping: 503 Service Unavailable
|
||||
*
|
||||
* @generated from protobuf enum value: UNAVAILABLE = 14;
|
||||
*/
|
||||
UNAVAILABLE = 14,
|
||||
/**
|
||||
* Unrecoverable data loss or corruption.
|
||||
*
|
||||
* HTTP Mapping: 500 Internal Server Error
|
||||
*
|
||||
* @generated from protobuf enum value: DATA_LOSS = 15;
|
||||
*/
|
||||
DATA_LOSS = 15
|
||||
}
|
||||
1024
google/rpc/error_details.ts
Normal file
1024
google/rpc/error_details.ts
Normal file
File diff suppressed because it is too large
Load Diff
170
google/rpc/status.ts
Normal file
170
google/rpc/status.ts
Normal file
@@ -0,0 +1,170 @@
|
||||
// @generated by protobuf-ts 2.9.5
|
||||
// @generated from protobuf file "google/rpc/status.proto" (package "google.rpc", syntax proto3)
|
||||
// tslint:disable
|
||||
//
|
||||
// Copyright 2017 Google Inc.
|
||||
//
|
||||
// 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 type { BinaryWriteOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryWriter } from "@protobuf-ts/runtime";
|
||||
import { WireType } from "@protobuf-ts/runtime";
|
||||
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
|
||||
import type { IBinaryReader } from "@protobuf-ts/runtime";
|
||||
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
|
||||
import type { PartialMessage } from "@protobuf-ts/runtime";
|
||||
import { reflectionMergePartial } from "@protobuf-ts/runtime";
|
||||
import { MessageType } from "@protobuf-ts/runtime";
|
||||
import { Any } from "../protobuf/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][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.
|
||||
*
|
||||
* @generated from protobuf message google.rpc.Status
|
||||
*/
|
||||
export interface Status {
|
||||
/**
|
||||
* The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].
|
||||
*
|
||||
* @generated from protobuf field: int32 code = 1;
|
||||
*/
|
||||
code: number;
|
||||
/**
|
||||
* 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][google.rpc.Status.details] field, or localized by the client.
|
||||
*
|
||||
* @generated from protobuf field: string message = 2;
|
||||
*/
|
||||
message: string;
|
||||
/**
|
||||
* A list of messages that carry the error details. There is a common set of
|
||||
* message types for APIs to use.
|
||||
*
|
||||
* @generated from protobuf field: repeated google.protobuf.Any details = 3;
|
||||
*/
|
||||
details: Any[];
|
||||
}
|
||||
// @generated message type with reflection information, may provide speed optimized methods
|
||||
class Status$Type extends MessageType<Status> {
|
||||
constructor() {
|
||||
super("google.rpc.Status", [
|
||||
{ no: 1, name: "code", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
|
||||
{ no: 2, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
|
||||
{ no: 3, name: "details", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Any }
|
||||
]);
|
||||
}
|
||||
create(value?: PartialMessage<Status>): Status {
|
||||
const message = globalThis.Object.create((this.messagePrototype!));
|
||||
message.code = 0;
|
||||
message.message = "";
|
||||
message.details = [];
|
||||
if (value !== undefined)
|
||||
reflectionMergePartial<Status>(this, message, value);
|
||||
return message;
|
||||
}
|
||||
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Status): Status {
|
||||
let message = target ?? this.create(), end = reader.pos + length;
|
||||
while (reader.pos < end) {
|
||||
let [fieldNo, wireType] = reader.tag();
|
||||
switch (fieldNo) {
|
||||
case /* int32 code */ 1:
|
||||
message.code = reader.int32();
|
||||
break;
|
||||
case /* string message */ 2:
|
||||
message.message = reader.string();
|
||||
break;
|
||||
case /* repeated google.protobuf.Any details */ 3:
|
||||
message.details.push(Any.internalBinaryRead(reader, reader.uint32(), options));
|
||||
break;
|
||||
default:
|
||||
let u = options.readUnknownField;
|
||||
if (u === "throw")
|
||||
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
|
||||
let d = reader.skip(wireType);
|
||||
if (u !== false)
|
||||
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
internalBinaryWrite(message: Status, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
||||
/* int32 code = 1; */
|
||||
if (message.code !== 0)
|
||||
writer.tag(1, WireType.Varint).int32(message.code);
|
||||
/* string message = 2; */
|
||||
if (message.message !== "")
|
||||
writer.tag(2, WireType.LengthDelimited).string(message.message);
|
||||
/* repeated google.protobuf.Any details = 3; */
|
||||
for (let i = 0; i < message.details.length; i++)
|
||||
Any.internalBinaryWrite(message.details[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
||||
let u = options.writeUnknownFields;
|
||||
if (u !== false)
|
||||
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
||||
return writer;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @generated MessageType for protobuf message google.rpc.Status
|
||||
*/
|
||||
export const Status = new Status$Type();
|
||||
Reference in New Issue
Block a user