From fec1f271d0288e50565e6cc6c662ce9e8eb8c680 Mon Sep 17 00:00:00 2001 From: Fedorov Vladimir Date: Tue, 14 Jul 2026 23:38:03 +0700 Subject: [PATCH] gen client --- src/api/generated/google/api/annotations.ts | 9 + src/api/generated/google/api/http.ts | 802 ++ src/api/generated/google/api/httpbody.ts | 220 + src/api/generated/google/protobuf/any.ts | 207 + .../generated/google/protobuf/descriptor.ts | 7529 +++++++++++++++++ src/api/generated/google/protobuf/struct.ts | 627 ++ .../generated/google/protobuf/timestamp.ts | 228 + src/api/generated/main.ts | 4041 +++++++++ .../options/annotations.ts | 9 + .../protoc-gen-openapiv2/options/openapiv2.ts | 6011 +++++++++++++ 10 files changed, 19683 insertions(+) create mode 100644 src/api/generated/google/api/annotations.ts create mode 100644 src/api/generated/google/api/http.ts create mode 100644 src/api/generated/google/api/httpbody.ts create mode 100644 src/api/generated/google/protobuf/any.ts create mode 100644 src/api/generated/google/protobuf/descriptor.ts create mode 100644 src/api/generated/google/protobuf/struct.ts create mode 100644 src/api/generated/google/protobuf/timestamp.ts create mode 100644 src/api/generated/main.ts create mode 100644 src/api/generated/protoc-gen-openapiv2/options/annotations.ts create mode 100644 src/api/generated/protoc-gen-openapiv2/options/openapiv2.ts diff --git a/src/api/generated/google/api/annotations.ts b/src/api/generated/google/api/annotations.ts new file mode 100644 index 0000000..c8b6b81 --- /dev/null +++ b/src/api/generated/google/api/annotations.ts @@ -0,0 +1,9 @@ +// Code generated by protoc-gen-ts_proto. DO NOT EDIT. +// versions: +// protoc-gen-ts_proto v2.12.0 +// protoc v7.35.1 +// source: google/api/annotations.proto + +/* eslint-disable */ + +export const protobufPackage = "google.api"; diff --git a/src/api/generated/google/api/http.ts b/src/api/generated/google/api/http.ts new file mode 100644 index 0000000..e587244 --- /dev/null +++ b/src/api/generated/google/api/http.ts @@ -0,0 +1,802 @@ +// Code generated by protoc-gen-ts_proto. DO NOT EDIT. +// versions: +// protoc-gen-ts_proto v2.12.0 +// protoc v7.35.1 +// source: google/api/http.proto + +/* eslint-disable */ +import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire"; + +export const protobufPackage = "google.api"; + +/** + * 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. + */ +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. + */ + rules?: + | HttpRule[] + | undefined; + /** + * 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. + */ + fullyDecodeReservedExpansion?: boolean | undefined; +} + +/** + * # 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. + */ +export interface HttpRule { + /** + * Selects a method to which this rule applies. + * + * Refer to [selector][google.api.DocumentationRule.selector] for syntax + * details. + */ + selector?: + | string + | undefined; + /** + * Maps to HTTP GET. Used for listing and getting information about + * resources. + */ + get?: + | string + | undefined; + /** Maps to HTTP PUT. Used for replacing a resource. */ + put?: + | string + | undefined; + /** Maps to HTTP POST. Used for creating a resource or performing an action. */ + post?: + | string + | undefined; + /** Maps to HTTP DELETE. Used for deleting a resource. */ + delete?: + | string + | undefined; + /** Maps to HTTP PATCH. Used for updating a resource. */ + patch?: + | string + | undefined; + /** + * 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. + */ + custom?: + | CustomHttpPattern + | 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. + */ + body?: + | string + | undefined; + /** + * 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. + */ + responseBody?: + | string + | undefined; + /** + * 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). + */ + additionalBindings?: HttpRule[] | undefined; +} + +/** A custom pattern is used for defining custom HTTP verb. */ +export interface CustomHttpPattern { + /** The name of this custom HTTP verb. */ + kind?: + | string + | undefined; + /** The path matched by this custom verb. */ + path?: string | undefined; +} + +function createBaseHttp(): Http { + return { rules: [], fullyDecodeReservedExpansion: false }; +} + +export const Http: MessageFns = { + encode(message: Http, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.rules !== undefined && message.rules.length !== 0) { + for (const v of message.rules) { + HttpRule.encode(v!, writer.uint32(10).fork()).join(); + } + } + if (message.fullyDecodeReservedExpansion !== undefined && message.fullyDecodeReservedExpansion !== false) { + writer.uint32(16).bool(message.fullyDecodeReservedExpansion); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Http { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseHttp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + const el = HttpRule.decode(reader, reader.uint32()); + if (el !== undefined) { + message.rules!.push(el); + } + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.fullyDecodeReservedExpansion = reader.bool(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Http { + return { + rules: globalThis.Array.isArray(object?.rules) ? object.rules.map((e: any) => HttpRule.fromJSON(e)) : [], + fullyDecodeReservedExpansion: isSet(object.fullyDecodeReservedExpansion) + ? globalThis.Boolean(object.fullyDecodeReservedExpansion) + : isSet(object.fully_decode_reserved_expansion) + ? globalThis.Boolean(object.fully_decode_reserved_expansion) + : false, + }; + }, + + toJSON(message: Http): unknown { + const obj: any = {}; + if (message.rules?.length) { + obj.rules = message.rules.map((e) => HttpRule.toJSON(e)); + } + if (message.fullyDecodeReservedExpansion !== undefined && message.fullyDecodeReservedExpansion !== false) { + obj.fullyDecodeReservedExpansion = message.fullyDecodeReservedExpansion; + } + return obj; + }, + + create(base?: DeepPartial): Http { + return Http.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Http { + const message = createBaseHttp(); + message.rules = object.rules?.map((e) => HttpRule.fromPartial(e)) || []; + message.fullyDecodeReservedExpansion = object.fullyDecodeReservedExpansion ?? false; + return message; + }, +}; + +function createBaseHttpRule(): HttpRule { + return { + selector: "", + get: undefined, + put: undefined, + post: undefined, + delete: undefined, + patch: undefined, + custom: undefined, + body: "", + responseBody: "", + additionalBindings: [], + }; +} + +export const HttpRule: MessageFns = { + encode(message: HttpRule, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.selector !== undefined && message.selector !== "") { + writer.uint32(10).string(message.selector); + } + if (message.get !== undefined) { + writer.uint32(18).string(message.get); + } + if (message.put !== undefined) { + writer.uint32(26).string(message.put); + } + if (message.post !== undefined) { + writer.uint32(34).string(message.post); + } + if (message.delete !== undefined) { + writer.uint32(42).string(message.delete); + } + if (message.patch !== undefined) { + writer.uint32(50).string(message.patch); + } + if (message.custom !== undefined) { + CustomHttpPattern.encode(message.custom, writer.uint32(66).fork()).join(); + } + if (message.body !== undefined && message.body !== "") { + writer.uint32(58).string(message.body); + } + if (message.responseBody !== undefined && message.responseBody !== "") { + writer.uint32(98).string(message.responseBody); + } + if (message.additionalBindings !== undefined && message.additionalBindings.length !== 0) { + for (const v of message.additionalBindings) { + HttpRule.encode(v!, writer.uint32(90).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): HttpRule { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseHttpRule(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.selector = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.get = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.put = reader.string(); + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + message.post = reader.string(); + continue; + } + case 5: { + if (tag !== 42) { + break; + } + + message.delete = reader.string(); + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + message.patch = reader.string(); + continue; + } + case 8: { + if (tag !== 66) { + break; + } + + message.custom = CustomHttpPattern.decode(reader, reader.uint32()); + continue; + } + case 7: { + if (tag !== 58) { + break; + } + + message.body = reader.string(); + continue; + } + case 12: { + if (tag !== 98) { + break; + } + + message.responseBody = reader.string(); + continue; + } + case 11: { + if (tag !== 90) { + break; + } + + const el = HttpRule.decode(reader, reader.uint32()); + if (el !== undefined) { + message.additionalBindings!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): HttpRule { + return { + selector: isSet(object.selector) ? globalThis.String(object.selector) : "", + get: isSet(object.get) ? globalThis.String(object.get) : undefined, + put: isSet(object.put) ? globalThis.String(object.put) : undefined, + post: isSet(object.post) ? globalThis.String(object.post) : undefined, + delete: isSet(object.delete) ? globalThis.String(object.delete) : undefined, + patch: isSet(object.patch) ? globalThis.String(object.patch) : undefined, + custom: isSet(object.custom) ? CustomHttpPattern.fromJSON(object.custom) : undefined, + body: isSet(object.body) ? globalThis.String(object.body) : "", + responseBody: isSet(object.responseBody) + ? globalThis.String(object.responseBody) + : isSet(object.response_body) + ? globalThis.String(object.response_body) + : "", + additionalBindings: globalThis.Array.isArray(object?.additionalBindings) + ? object.additionalBindings.map((e: any) => HttpRule.fromJSON(e)) + : globalThis.Array.isArray(object?.additional_bindings) + ? object.additional_bindings.map((e: any) => HttpRule.fromJSON(e)) + : [], + }; + }, + + toJSON(message: HttpRule): unknown { + const obj: any = {}; + if (message.selector !== undefined && message.selector !== "") { + obj.selector = message.selector; + } + if (message.get !== undefined) { + obj.get = message.get; + } + if (message.put !== undefined) { + obj.put = message.put; + } + if (message.post !== undefined) { + obj.post = message.post; + } + if (message.delete !== undefined) { + obj.delete = message.delete; + } + if (message.patch !== undefined) { + obj.patch = message.patch; + } + if (message.custom !== undefined) { + obj.custom = CustomHttpPattern.toJSON(message.custom); + } + if (message.body !== undefined && message.body !== "") { + obj.body = message.body; + } + if (message.responseBody !== undefined && message.responseBody !== "") { + obj.responseBody = message.responseBody; + } + if (message.additionalBindings?.length) { + obj.additionalBindings = message.additionalBindings.map((e) => HttpRule.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): HttpRule { + return HttpRule.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): HttpRule { + const message = createBaseHttpRule(); + message.selector = object.selector ?? ""; + message.get = object.get ?? undefined; + message.put = object.put ?? undefined; + message.post = object.post ?? undefined; + message.delete = object.delete ?? undefined; + message.patch = object.patch ?? undefined; + message.custom = (object.custom !== undefined && object.custom !== null) + ? CustomHttpPattern.fromPartial(object.custom) + : undefined; + message.body = object.body ?? ""; + message.responseBody = object.responseBody ?? ""; + message.additionalBindings = object.additionalBindings?.map((e) => HttpRule.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseCustomHttpPattern(): CustomHttpPattern { + return { kind: "", path: "" }; +} + +export const CustomHttpPattern: MessageFns = { + encode(message: CustomHttpPattern, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.kind !== undefined && message.kind !== "") { + writer.uint32(10).string(message.kind); + } + if (message.path !== undefined && message.path !== "") { + writer.uint32(18).string(message.path); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): CustomHttpPattern { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseCustomHttpPattern(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.kind = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.path = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): CustomHttpPattern { + return { + kind: isSet(object.kind) ? globalThis.String(object.kind) : "", + path: isSet(object.path) ? globalThis.String(object.path) : "", + }; + }, + + toJSON(message: CustomHttpPattern): unknown { + const obj: any = {}; + if (message.kind !== undefined && message.kind !== "") { + obj.kind = message.kind; + } + if (message.path !== undefined && message.path !== "") { + obj.path = message.path; + } + return obj; + }, + + create(base?: DeepPartial): CustomHttpPattern { + return CustomHttpPattern.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): CustomHttpPattern { + const message = createBaseCustomHttpPattern(); + message.kind = object.kind ?? ""; + message.path = object.path ?? ""; + return message; + }, +}; + +type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined; + +export type DeepPartial = T extends Builtin ? T + : T extends globalThis.Array ? globalThis.Array> + : T extends ReadonlyArray ? ReadonlyArray> + : T extends {} ? { [K in keyof T]?: DeepPartial } + : Partial; + +function isSet(value: any): boolean { + return value !== null && value !== undefined; +} + +export interface MessageFns { + encode(message: T, writer?: BinaryWriter): BinaryWriter; + decode(input: BinaryReader | Uint8Array, length?: number): T; + fromJSON(object: any): T; + toJSON(message: T): unknown; + create(base?: DeepPartial): T; + fromPartial(object: DeepPartial): T; +} diff --git a/src/api/generated/google/api/httpbody.ts b/src/api/generated/google/api/httpbody.ts new file mode 100644 index 0000000..b234ac5 --- /dev/null +++ b/src/api/generated/google/api/httpbody.ts @@ -0,0 +1,220 @@ +// Code generated by protoc-gen-ts_proto. DO NOT EDIT. +// versions: +// protoc-gen-ts_proto v2.12.0 +// protoc v7.35.1 +// source: google/api/httpbody.proto + +/* eslint-disable */ +import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire"; +import { Any } from "../protobuf/any"; + +export const protobufPackage = "google.api"; + +/** + * 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. + */ +export interface HttpBody { + /** The HTTP Content-Type header value specifying the content type of the body. */ + contentType?: + | string + | undefined; + /** The HTTP request/response body as raw binary. */ + data?: + | Uint8Array + | undefined; + /** + * Application specific response metadata. Must be set in the first response + * for streaming APIs. + */ + extensions?: Any[] | undefined; +} + +function createBaseHttpBody(): HttpBody { + return { contentType: "", data: new Uint8Array(0), extensions: [] }; +} + +export const HttpBody: MessageFns = { + encode(message: HttpBody, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.contentType !== undefined && message.contentType !== "") { + writer.uint32(10).string(message.contentType); + } + if (message.data !== undefined && message.data.length !== 0) { + writer.uint32(18).bytes(message.data); + } + if (message.extensions !== undefined && message.extensions.length !== 0) { + for (const v of message.extensions) { + Any.encode(v!, writer.uint32(26).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): HttpBody { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseHttpBody(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.contentType = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.data = reader.bytes(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + const el = Any.decode(reader, reader.uint32()); + if (el !== undefined) { + message.extensions!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): HttpBody { + return { + contentType: isSet(object.contentType) + ? globalThis.String(object.contentType) + : isSet(object.content_type) + ? globalThis.String(object.content_type) + : "", + data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(0), + extensions: globalThis.Array.isArray(object?.extensions) + ? object.extensions.map((e: any) => Any.fromJSON(e)) + : [], + }; + }, + + toJSON(message: HttpBody): unknown { + const obj: any = {}; + if (message.contentType !== undefined && message.contentType !== "") { + obj.contentType = message.contentType; + } + if (message.data !== undefined && message.data.length !== 0) { + obj.data = base64FromBytes(message.data); + } + if (message.extensions?.length) { + obj.extensions = message.extensions.map((e) => Any.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): HttpBody { + return HttpBody.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): HttpBody { + const message = createBaseHttpBody(); + message.contentType = object.contentType ?? ""; + message.data = object.data ?? new Uint8Array(0); + message.extensions = object.extensions?.map((e) => Any.fromPartial(e)) || []; + return message; + }, +}; + +function bytesFromBase64(b64: string): Uint8Array { + if ((globalThis as any).Buffer) { + return Uint8Array.from((globalThis as any).Buffer.from(b64, "base64")); + } else { + const bin = globalThis.atob(b64); + const arr = new Uint8Array(bin.length); + for (let i = 0; i < bin.length; ++i) { + arr[i] = bin.charCodeAt(i); + } + return arr; + } +} + +function base64FromBytes(arr: Uint8Array): string { + if ((globalThis as any).Buffer) { + return (globalThis as any).Buffer.from(arr).toString("base64"); + } else { + const bin: string[] = []; + arr.forEach((byte) => { + bin.push(globalThis.String.fromCharCode(byte)); + }); + return globalThis.btoa(bin.join("")); + } +} + +type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined; + +export type DeepPartial = T extends Builtin ? T + : T extends globalThis.Array ? globalThis.Array> + : T extends ReadonlyArray ? ReadonlyArray> + : T extends {} ? { [K in keyof T]?: DeepPartial } + : Partial; + +function isSet(value: any): boolean { + return value !== null && value !== undefined; +} + +export interface MessageFns { + encode(message: T, writer?: BinaryWriter): BinaryWriter; + decode(input: BinaryReader | Uint8Array, length?: number): T; + fromJSON(object: any): T; + toJSON(message: T): unknown; + create(base?: DeepPartial): T; + fromPartial(object: DeepPartial): T; +} diff --git a/src/api/generated/google/protobuf/any.ts b/src/api/generated/google/protobuf/any.ts new file mode 100644 index 0000000..7186524 --- /dev/null +++ b/src/api/generated/google/protobuf/any.ts @@ -0,0 +1,207 @@ +// Code generated by protoc-gen-ts_proto. DO NOT EDIT. +// versions: +// protoc-gen-ts_proto v2.12.0 +// protoc v7.35.1 +// source: google/protobuf/any.proto + +/* eslint-disable */ +import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire"; + +export const protobufPackage = "google.protobuf"; + +/** + * `Any` contains an arbitrary serialized protocol buffer message along with a + * URL that describes the type of the serialized message. + * + * In its binary encoding, an `Any` is an ordinary message; but in other wire + * forms like JSON, it has a special encoding. The format of the type URL is + * described on the `type_url` field. + * + * Protobuf APIs provide utilities to interact with `Any` values: + * + * - A 'pack' operation accepts a message and constructs a generic `Any` wrapper + * around it. + * - An 'unpack' operation reads the content of an `Any` message, either into an + * existing message or a new one. Unpack operations must check the type of the + * value they unpack against the declared `type_url`. + * - An 'is' operation decides whether an `Any` contains a message of the given + * type, i.e. whether it can 'unpack' that type. + * + * The JSON format representation of an `Any` follows one of these cases: + * + * - For types without special-cased JSON encodings, the JSON format + * representation of the `Any` is the same as that of the message, with an + * additional `@type` field which contains the type URL. + * - For types with special-cased JSON encodings (typically called 'well-known' + * types, listed in https://protobuf.dev/programming-guides/json/#any), the + * JSON format representation has a key `@type` which contains the type URL + * and a key `value` which contains the JSON-serialized value. + * + * The text format representation of an `Any` is like a message with one field + * whose name is the type URL in brackets. For example, an `Any` containing a + * `foo.Bar` message may be written `[type.googleapis.com/foo.Bar] { a: 2 }`. + */ +export interface Any { + /** + * Identifies the type of the serialized Protobuf message with a URI reference + * consisting of a prefix ending in a slash and the fully-qualified type name. + * + * Example: type.googleapis.com/google.protobuf.StringValue + * + * This string must contain at least one `/` character, and the content after + * the last `/` must be the fully-qualified name of the type in canonical + * form, without a leading dot. Do not write a scheme on these URI references + * so that clients do not attempt to contact them. + * + * The prefix is arbitrary and Protobuf implementations are expected to + * simply strip off everything up to and including the last `/` to identify + * the type. `type.googleapis.com/` is a common default prefix that some + * legacy implementations require. This prefix does not indicate the origin of + * the type, and URIs containing it are not expected to respond to any + * requests. + * + * All type URL strings must be legal URI references with the additional + * restriction (for the text format) that the content of the reference + * must consist only of alphanumeric characters, percent-encoded escapes, and + * characters in the following set (not including the outer backticks): + * `/-.~_!$&()*+,;=`. Despite our allowing percent encodings, implementations + * should not unescape them to prevent confusion with existing parsers. For + * example, `type.googleapis.com%2FFoo` should be rejected. + * + * In the original design of `Any`, the possibility of launching a type + * resolution service at these type URLs was considered but Protobuf never + * implemented one and considers contacting these URLs to be problematic and + * a potential security issue. Do not attempt to contact type URLs. + */ + typeUrl?: + | string + | undefined; + /** Holds a Protobuf serialization of the type described by type_url. */ + value?: Uint8Array | undefined; +} + +function createBaseAny(): Any { + return { typeUrl: "", value: new Uint8Array(0) }; +} + +export const Any: MessageFns = { + encode(message: Any, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.typeUrl !== undefined && message.typeUrl !== "") { + writer.uint32(10).string(message.typeUrl); + } + if (message.value !== undefined && message.value.length !== 0) { + writer.uint32(18).bytes(message.value); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Any { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseAny(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.typeUrl = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = reader.bytes(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Any { + return { + typeUrl: isSet(object.typeUrl) + ? globalThis.String(object.typeUrl) + : isSet(object.type_url) + ? globalThis.String(object.type_url) + : "", + value: isSet(object.value) ? bytesFromBase64(object.value) : new Uint8Array(0), + }; + }, + + toJSON(message: Any): unknown { + const obj: any = {}; + if (message.typeUrl !== undefined && message.typeUrl !== "") { + obj.typeUrl = message.typeUrl; + } + if (message.value !== undefined && message.value.length !== 0) { + obj.value = base64FromBytes(message.value); + } + return obj; + }, + + create(base?: DeepPartial): Any { + return Any.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Any { + const message = createBaseAny(); + message.typeUrl = object.typeUrl ?? ""; + message.value = object.value ?? new Uint8Array(0); + return message; + }, +}; + +function bytesFromBase64(b64: string): Uint8Array { + if ((globalThis as any).Buffer) { + return Uint8Array.from((globalThis as any).Buffer.from(b64, "base64")); + } else { + const bin = globalThis.atob(b64); + const arr = new Uint8Array(bin.length); + for (let i = 0; i < bin.length; ++i) { + arr[i] = bin.charCodeAt(i); + } + return arr; + } +} + +function base64FromBytes(arr: Uint8Array): string { + if ((globalThis as any).Buffer) { + return (globalThis as any).Buffer.from(arr).toString("base64"); + } else { + const bin: string[] = []; + arr.forEach((byte) => { + bin.push(globalThis.String.fromCharCode(byte)); + }); + return globalThis.btoa(bin.join("")); + } +} + +type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined; + +export type DeepPartial = T extends Builtin ? T + : T extends globalThis.Array ? globalThis.Array> + : T extends ReadonlyArray ? ReadonlyArray> + : T extends {} ? { [K in keyof T]?: DeepPartial } + : Partial; + +function isSet(value: any): boolean { + return value !== null && value !== undefined; +} + +export interface MessageFns { + encode(message: T, writer?: BinaryWriter): BinaryWriter; + decode(input: BinaryReader | Uint8Array, length?: number): T; + fromJSON(object: any): T; + toJSON(message: T): unknown; + create(base?: DeepPartial): T; + fromPartial(object: DeepPartial): T; +} diff --git a/src/api/generated/google/protobuf/descriptor.ts b/src/api/generated/google/protobuf/descriptor.ts new file mode 100644 index 0000000..de929cd --- /dev/null +++ b/src/api/generated/google/protobuf/descriptor.ts @@ -0,0 +1,7529 @@ +// Code generated by protoc-gen-ts_proto. DO NOT EDIT. +// versions: +// protoc-gen-ts_proto v2.12.0 +// protoc v7.35.1 +// source: google/protobuf/descriptor.proto + +/* eslint-disable */ +import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire"; + +export const protobufPackage = "google.protobuf"; + +/** The full set of known editions. */ +export enum Edition { + /** EDITION_UNKNOWN - A placeholder for an unknown edition value. */ + EDITION_UNKNOWN = 0, + /** + * EDITION_LEGACY - A placeholder edition for specifying default behaviors *before* a feature + * was first introduced. This is effectively an "infinite past". + */ + EDITION_LEGACY = 900, + /** + * EDITION_PROTO2 - Legacy syntax "editions". These pre-date editions, but behave much like + * distinct editions. These can't be used to specify the edition of proto + * files, but feature definitions must supply proto2/proto3 defaults for + * backwards compatibility. + */ + EDITION_PROTO2 = 998, + EDITION_PROTO3 = 999, + /** + * EDITION_2023 - Editions that have been released. The specific values are arbitrary and + * should not be depended on, but they will always be time-ordered for easy + * comparison. + */ + EDITION_2023 = 1000, + EDITION_2024 = 1001, + EDITION_2026 = 1002, + /** EDITION_UNSTABLE - A placeholder edition for developing and testing unscheduled features. */ + EDITION_UNSTABLE = 9999, + /** + * EDITION_1_TEST_ONLY - Placeholder editions for testing feature resolution. These should not be + * used or relied on outside of tests. + */ + EDITION_1_TEST_ONLY = 1, + EDITION_2_TEST_ONLY = 2, + EDITION_99997_TEST_ONLY = 99997, + EDITION_99998_TEST_ONLY = 99998, + EDITION_99999_TEST_ONLY = 99999, + /** + * EDITION_MAX - Placeholder for specifying unbounded edition support. This should only + * ever be used by plugins that can expect to never require any changes to + * support a new edition. + */ + EDITION_MAX = 2147483647, + UNRECOGNIZED = -1, +} + +export function editionFromJSON(object: any): Edition { + switch (object) { + case 0: + case "EDITION_UNKNOWN": + return Edition.EDITION_UNKNOWN; + case 900: + case "EDITION_LEGACY": + return Edition.EDITION_LEGACY; + case 998: + case "EDITION_PROTO2": + return Edition.EDITION_PROTO2; + case 999: + case "EDITION_PROTO3": + return Edition.EDITION_PROTO3; + case 1000: + case "EDITION_2023": + return Edition.EDITION_2023; + case 1001: + case "EDITION_2024": + return Edition.EDITION_2024; + case 1002: + case "EDITION_2026": + return Edition.EDITION_2026; + case 9999: + case "EDITION_UNSTABLE": + return Edition.EDITION_UNSTABLE; + case 1: + case "EDITION_1_TEST_ONLY": + return Edition.EDITION_1_TEST_ONLY; + case 2: + case "EDITION_2_TEST_ONLY": + return Edition.EDITION_2_TEST_ONLY; + case 99997: + case "EDITION_99997_TEST_ONLY": + return Edition.EDITION_99997_TEST_ONLY; + case 99998: + case "EDITION_99998_TEST_ONLY": + return Edition.EDITION_99998_TEST_ONLY; + case 99999: + case "EDITION_99999_TEST_ONLY": + return Edition.EDITION_99999_TEST_ONLY; + case 2147483647: + case "EDITION_MAX": + return Edition.EDITION_MAX; + case -1: + case "UNRECOGNIZED": + default: + return Edition.UNRECOGNIZED; + } +} + +export function editionToJSON(object: Edition): string { + switch (object) { + case Edition.EDITION_UNKNOWN: + return "EDITION_UNKNOWN"; + case Edition.EDITION_LEGACY: + return "EDITION_LEGACY"; + case Edition.EDITION_PROTO2: + return "EDITION_PROTO2"; + case Edition.EDITION_PROTO3: + return "EDITION_PROTO3"; + case Edition.EDITION_2023: + return "EDITION_2023"; + case Edition.EDITION_2024: + return "EDITION_2024"; + case Edition.EDITION_2026: + return "EDITION_2026"; + case Edition.EDITION_UNSTABLE: + return "EDITION_UNSTABLE"; + case Edition.EDITION_1_TEST_ONLY: + return "EDITION_1_TEST_ONLY"; + case Edition.EDITION_2_TEST_ONLY: + return "EDITION_2_TEST_ONLY"; + case Edition.EDITION_99997_TEST_ONLY: + return "EDITION_99997_TEST_ONLY"; + case Edition.EDITION_99998_TEST_ONLY: + return "EDITION_99998_TEST_ONLY"; + case Edition.EDITION_99999_TEST_ONLY: + return "EDITION_99999_TEST_ONLY"; + case Edition.EDITION_MAX: + return "EDITION_MAX"; + case Edition.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +/** + * Describes the 'visibility' of a symbol with respect to the proto import + * system. Symbols can only be imported when the visibility rules do not prevent + * it (ex: local symbols cannot be imported). Visibility modifiers can only set + * on `message` and `enum` as they are the only types available to be referenced + * from other files. + */ +export enum SymbolVisibility { + VISIBILITY_UNSET = 0, + VISIBILITY_LOCAL = 1, + VISIBILITY_EXPORT = 2, + UNRECOGNIZED = -1, +} + +export function symbolVisibilityFromJSON(object: any): SymbolVisibility { + switch (object) { + case 0: + case "VISIBILITY_UNSET": + return SymbolVisibility.VISIBILITY_UNSET; + case 1: + case "VISIBILITY_LOCAL": + return SymbolVisibility.VISIBILITY_LOCAL; + case 2: + case "VISIBILITY_EXPORT": + return SymbolVisibility.VISIBILITY_EXPORT; + case -1: + case "UNRECOGNIZED": + default: + return SymbolVisibility.UNRECOGNIZED; + } +} + +export function symbolVisibilityToJSON(object: SymbolVisibility): string { + switch (object) { + case SymbolVisibility.VISIBILITY_UNSET: + return "VISIBILITY_UNSET"; + case SymbolVisibility.VISIBILITY_LOCAL: + return "VISIBILITY_LOCAL"; + case SymbolVisibility.VISIBILITY_EXPORT: + return "VISIBILITY_EXPORT"; + case SymbolVisibility.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +/** + * The protocol compiler can output a FileDescriptorSet containing the .proto + * files it parses. + */ +export interface FileDescriptorSet { + file?: FileDescriptorProto[] | undefined; +} + +/** Describes a complete .proto file. */ +export interface FileDescriptorProto { + /** file name, relative to root of source tree */ + name?: + | string + | undefined; + /** e.g. "foo", "foo.bar", etc. */ + package?: + | string + | undefined; + /** Names of files imported by this file. */ + dependency?: + | string[] + | undefined; + /** Indexes of the public imported files in the dependency list above. */ + publicDependency?: + | number[] + | undefined; + /** + * Indexes of the weak imported files in the dependency list. + * For Google-internal migration only. Do not use. + */ + weakDependency?: + | number[] + | undefined; + /** + * Names of files imported by this file purely for the purpose of providing + * option extensions. These are excluded from the dependency list above. + */ + optionDependency?: + | string[] + | undefined; + /** All top-level definitions in this file. */ + messageType?: DescriptorProto[] | undefined; + enumType?: EnumDescriptorProto[] | undefined; + service?: ServiceDescriptorProto[] | undefined; + extension?: FieldDescriptorProto[] | undefined; + options?: + | FileOptions + | undefined; + /** + * This field contains optional information about the original source code. + * You may safely remove this entire field without harming runtime + * functionality of the descriptors -- the information is needed only by + * development tools. + */ + sourceCodeInfo?: + | SourceCodeInfo + | undefined; + /** + * The syntax of the proto file. + * The supported values are "proto2", "proto3", and "editions". + * + * If `edition` is present, this value must be "editions". + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + */ + syntax?: + | string + | undefined; + /** + * The edition of the proto file. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + */ + edition?: Edition | undefined; +} + +/** Describes a message type. */ +export interface DescriptorProto { + name?: string | undefined; + field?: FieldDescriptorProto[] | undefined; + extension?: FieldDescriptorProto[] | undefined; + nestedType?: DescriptorProto[] | undefined; + enumType?: EnumDescriptorProto[] | undefined; + extensionRange?: DescriptorProto_ExtensionRange[] | undefined; + oneofDecl?: OneofDescriptorProto[] | undefined; + options?: MessageOptions | undefined; + reservedRange?: + | DescriptorProto_ReservedRange[] + | undefined; + /** + * Reserved field names, which may not be used by fields in the same message. + * A given name may only be reserved once. + */ + reservedName?: + | string[] + | undefined; + /** Support for `export` and `local` keywords on enums. */ + visibility?: SymbolVisibility | undefined; +} + +export interface DescriptorProto_ExtensionRange { + /** Inclusive. */ + start?: + | number + | undefined; + /** Exclusive. */ + end?: number | undefined; + options?: ExtensionRangeOptions | undefined; +} + +/** + * Range of reserved tag numbers. Reserved tag numbers may not be used by + * fields or extension ranges in the same message. Reserved ranges may + * not overlap. + */ +export interface DescriptorProto_ReservedRange { + /** Inclusive. */ + start?: + | number + | undefined; + /** Exclusive. */ + end?: number | undefined; +} + +export interface ExtensionRangeOptions { + /** The parser stores options it doesn't recognize here. See above. */ + uninterpretedOption?: + | UninterpretedOption[] + | undefined; + /** + * For external users: DO NOT USE. We are in the process of open sourcing + * extension declaration and executing internal cleanups before it can be + * used externally. + */ + declaration?: + | ExtensionRangeOptions_Declaration[] + | undefined; + /** Any features defined in the specific edition. */ + features?: + | FeatureSet + | undefined; + /** + * The verification state of the range. + * TODO: flip the default to DECLARATION once all empty ranges + * are marked as UNVERIFIED. + */ + verification?: ExtensionRangeOptions_VerificationState | undefined; +} + +/** The verification state of the extension range. */ +export enum ExtensionRangeOptions_VerificationState { + /** DECLARATION - All the extensions of the range must be declared. */ + DECLARATION = 0, + UNVERIFIED = 1, + UNRECOGNIZED = -1, +} + +export function extensionRangeOptions_VerificationStateFromJSON(object: any): ExtensionRangeOptions_VerificationState { + switch (object) { + case 0: + case "DECLARATION": + return ExtensionRangeOptions_VerificationState.DECLARATION; + case 1: + case "UNVERIFIED": + return ExtensionRangeOptions_VerificationState.UNVERIFIED; + case -1: + case "UNRECOGNIZED": + default: + return ExtensionRangeOptions_VerificationState.UNRECOGNIZED; + } +} + +export function extensionRangeOptions_VerificationStateToJSON(object: ExtensionRangeOptions_VerificationState): string { + switch (object) { + case ExtensionRangeOptions_VerificationState.DECLARATION: + return "DECLARATION"; + case ExtensionRangeOptions_VerificationState.UNVERIFIED: + return "UNVERIFIED"; + case ExtensionRangeOptions_VerificationState.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export interface ExtensionRangeOptions_Declaration { + /** The extension number declared within the extension range. */ + number?: + | number + | undefined; + /** + * The fully-qualified name of the extension field. There must be a leading + * dot in front of the full name. + */ + fullName?: + | string + | undefined; + /** + * The fully-qualified type name of the extension field. Unlike + * Metadata.type, Declaration.type must have a leading dot for messages + * and enums. + */ + type?: + | string + | undefined; + /** + * If true, indicates that the number is reserved in the extension range, + * and any extension field with the number will fail to compile. Set this + * when a declared extension field is deleted. + */ + reserved?: + | boolean + | undefined; + /** + * If true, indicates that the extension must be defined as repeated. + * Otherwise the extension must be defined as optional. + */ + repeated?: boolean | undefined; +} + +/** Describes a field within a message. */ +export interface FieldDescriptorProto { + name?: string | undefined; + number?: number | undefined; + label?: + | FieldDescriptorProto_Label + | undefined; + /** + * If type_name is set, this need not be set. If both this and type_name + * are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + */ + type?: + | FieldDescriptorProto_Type + | undefined; + /** + * For message and enum types, this is the name of the type. If the name + * starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + * rules are used to find the type (i.e. first the nested types within this + * message are searched, then within the parent, on up to the root + * namespace). + */ + typeName?: + | string + | undefined; + /** + * For extensions, this is the name of the type being extended. It is + * resolved in the same manner as type_name. + */ + extendee?: + | string + | undefined; + /** + * For numeric types, contains the original text representation of the value. + * For booleans, "true" or "false". + * For strings, contains the default text contents (not escaped in any way). + * For bytes, contains the C escaped value. All bytes >= 128 are escaped. + */ + defaultValue?: + | string + | undefined; + /** + * If set, gives the index of a oneof in the containing type's oneof_decl + * list. This field is a member of that oneof. + */ + oneofIndex?: + | number + | undefined; + /** + * JSON name of this field. The value is set by protocol compiler. If the + * user has set a "json_name" option on this field, that option's value + * will be used. Otherwise, it's deduced from the field's name by converting + * it to camelCase. + */ + jsonName?: string | undefined; + options?: + | FieldOptions + | undefined; + /** + * If true, this is a proto3 "optional". When a proto3 field is optional, it + * tracks presence regardless of field type. + * + * When proto3_optional is true, this field must belong to a oneof to signal + * to old proto3 clients that presence is tracked for this field. This oneof + * is known as a "synthetic" oneof, and this field must be its sole member + * (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs + * exist in the descriptor only, and do not generate any API. Synthetic oneofs + * must be ordered after all "real" oneofs. + * + * For message fields, proto3_optional doesn't create any semantic change, + * since non-repeated message fields always track presence. However it still + * indicates the semantic detail of whether the user wrote "optional" or not. + * This can be useful for round-tripping the .proto file. For consistency we + * give message fields a synthetic oneof also, even though it is not required + * to track presence. This is especially important because the parser can't + * tell if a field is a message or an enum, so it must always create a + * synthetic oneof. + * + * Proto2 optional fields do not set this flag, because they already indicate + * optional with `LABEL_OPTIONAL`. + */ + proto3Optional?: boolean | undefined; +} + +export enum FieldDescriptorProto_Type { + /** + * TYPE_DOUBLE - 0 is reserved for errors. + * Order is weird for historical reasons. + */ + TYPE_DOUBLE = 1, + TYPE_FLOAT = 2, + /** + * TYPE_INT64 - Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + * negative values are likely. + */ + TYPE_INT64 = 3, + TYPE_UINT64 = 4, + /** + * TYPE_INT32 - Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + * negative values are likely. + */ + TYPE_INT32 = 5, + TYPE_FIXED64 = 6, + TYPE_FIXED32 = 7, + TYPE_BOOL = 8, + TYPE_STRING = 9, + /** + * TYPE_GROUP - Tag-delimited aggregate. + * Group type is deprecated and not supported after google.protobuf. However, Proto3 + * implementations should still be able to parse the group wire format and + * treat group fields as unknown fields. In Editions, the group wire format + * can be enabled via the `message_encoding` feature. + */ + TYPE_GROUP = 10, + /** TYPE_MESSAGE - Length-delimited aggregate. */ + TYPE_MESSAGE = 11, + /** TYPE_BYTES - New in version 2. */ + TYPE_BYTES = 12, + TYPE_UINT32 = 13, + TYPE_ENUM = 14, + TYPE_SFIXED32 = 15, + TYPE_SFIXED64 = 16, + /** TYPE_SINT32 - Uses ZigZag encoding. */ + TYPE_SINT32 = 17, + /** TYPE_SINT64 - Uses ZigZag encoding. */ + TYPE_SINT64 = 18, + UNRECOGNIZED = -1, +} + +export function fieldDescriptorProto_TypeFromJSON(object: any): FieldDescriptorProto_Type { + switch (object) { + case 1: + case "TYPE_DOUBLE": + return FieldDescriptorProto_Type.TYPE_DOUBLE; + case 2: + case "TYPE_FLOAT": + return FieldDescriptorProto_Type.TYPE_FLOAT; + case 3: + case "TYPE_INT64": + return FieldDescriptorProto_Type.TYPE_INT64; + case 4: + case "TYPE_UINT64": + return FieldDescriptorProto_Type.TYPE_UINT64; + case 5: + case "TYPE_INT32": + return FieldDescriptorProto_Type.TYPE_INT32; + case 6: + case "TYPE_FIXED64": + return FieldDescriptorProto_Type.TYPE_FIXED64; + case 7: + case "TYPE_FIXED32": + return FieldDescriptorProto_Type.TYPE_FIXED32; + case 8: + case "TYPE_BOOL": + return FieldDescriptorProto_Type.TYPE_BOOL; + case 9: + case "TYPE_STRING": + return FieldDescriptorProto_Type.TYPE_STRING; + case 10: + case "TYPE_GROUP": + return FieldDescriptorProto_Type.TYPE_GROUP; + case 11: + case "TYPE_MESSAGE": + return FieldDescriptorProto_Type.TYPE_MESSAGE; + case 12: + case "TYPE_BYTES": + return FieldDescriptorProto_Type.TYPE_BYTES; + case 13: + case "TYPE_UINT32": + return FieldDescriptorProto_Type.TYPE_UINT32; + case 14: + case "TYPE_ENUM": + return FieldDescriptorProto_Type.TYPE_ENUM; + case 15: + case "TYPE_SFIXED32": + return FieldDescriptorProto_Type.TYPE_SFIXED32; + case 16: + case "TYPE_SFIXED64": + return FieldDescriptorProto_Type.TYPE_SFIXED64; + case 17: + case "TYPE_SINT32": + return FieldDescriptorProto_Type.TYPE_SINT32; + case 18: + case "TYPE_SINT64": + return FieldDescriptorProto_Type.TYPE_SINT64; + case -1: + case "UNRECOGNIZED": + default: + return FieldDescriptorProto_Type.UNRECOGNIZED; + } +} + +export function fieldDescriptorProto_TypeToJSON(object: FieldDescriptorProto_Type): string { + switch (object) { + case FieldDescriptorProto_Type.TYPE_DOUBLE: + return "TYPE_DOUBLE"; + case FieldDescriptorProto_Type.TYPE_FLOAT: + return "TYPE_FLOAT"; + case FieldDescriptorProto_Type.TYPE_INT64: + return "TYPE_INT64"; + case FieldDescriptorProto_Type.TYPE_UINT64: + return "TYPE_UINT64"; + case FieldDescriptorProto_Type.TYPE_INT32: + return "TYPE_INT32"; + case FieldDescriptorProto_Type.TYPE_FIXED64: + return "TYPE_FIXED64"; + case FieldDescriptorProto_Type.TYPE_FIXED32: + return "TYPE_FIXED32"; + case FieldDescriptorProto_Type.TYPE_BOOL: + return "TYPE_BOOL"; + case FieldDescriptorProto_Type.TYPE_STRING: + return "TYPE_STRING"; + case FieldDescriptorProto_Type.TYPE_GROUP: + return "TYPE_GROUP"; + case FieldDescriptorProto_Type.TYPE_MESSAGE: + return "TYPE_MESSAGE"; + case FieldDescriptorProto_Type.TYPE_BYTES: + return "TYPE_BYTES"; + case FieldDescriptorProto_Type.TYPE_UINT32: + return "TYPE_UINT32"; + case FieldDescriptorProto_Type.TYPE_ENUM: + return "TYPE_ENUM"; + case FieldDescriptorProto_Type.TYPE_SFIXED32: + return "TYPE_SFIXED32"; + case FieldDescriptorProto_Type.TYPE_SFIXED64: + return "TYPE_SFIXED64"; + case FieldDescriptorProto_Type.TYPE_SINT32: + return "TYPE_SINT32"; + case FieldDescriptorProto_Type.TYPE_SINT64: + return "TYPE_SINT64"; + case FieldDescriptorProto_Type.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum FieldDescriptorProto_Label { + /** LABEL_OPTIONAL - 0 is reserved for errors */ + LABEL_OPTIONAL = 1, + LABEL_REPEATED = 3, + /** + * LABEL_REQUIRED - The required label is only allowed in google.protobuf. In proto3 and Editions + * it's explicitly prohibited. In Editions, the `field_presence` feature + * can be used to get this behavior. + */ + LABEL_REQUIRED = 2, + UNRECOGNIZED = -1, +} + +export function fieldDescriptorProto_LabelFromJSON(object: any): FieldDescriptorProto_Label { + switch (object) { + case 1: + case "LABEL_OPTIONAL": + return FieldDescriptorProto_Label.LABEL_OPTIONAL; + case 3: + case "LABEL_REPEATED": + return FieldDescriptorProto_Label.LABEL_REPEATED; + case 2: + case "LABEL_REQUIRED": + return FieldDescriptorProto_Label.LABEL_REQUIRED; + case -1: + case "UNRECOGNIZED": + default: + return FieldDescriptorProto_Label.UNRECOGNIZED; + } +} + +export function fieldDescriptorProto_LabelToJSON(object: FieldDescriptorProto_Label): string { + switch (object) { + case FieldDescriptorProto_Label.LABEL_OPTIONAL: + return "LABEL_OPTIONAL"; + case FieldDescriptorProto_Label.LABEL_REPEATED: + return "LABEL_REPEATED"; + case FieldDescriptorProto_Label.LABEL_REQUIRED: + return "LABEL_REQUIRED"; + case FieldDescriptorProto_Label.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +/** Describes a oneof. */ +export interface OneofDescriptorProto { + name?: string | undefined; + options?: OneofOptions | undefined; +} + +/** Describes an enum type. */ +export interface EnumDescriptorProto { + name?: string | undefined; + value?: EnumValueDescriptorProto[] | undefined; + options?: + | EnumOptions + | undefined; + /** + * Range of reserved numeric values. Reserved numeric values may not be used + * by enum values in the same enum declaration. Reserved ranges may not + * overlap. + */ + reservedRange?: + | EnumDescriptorProto_EnumReservedRange[] + | undefined; + /** + * Reserved enum value names, which may not be reused. A given name may only + * be reserved once. + */ + reservedName?: + | string[] + | undefined; + /** Support for `export` and `local` keywords on enums. */ + visibility?: SymbolVisibility | undefined; +} + +/** + * Range of reserved numeric values. Reserved values may not be used by + * entries in the same enum. Reserved ranges may not overlap. + * + * Note that this is distinct from DescriptorProto.ReservedRange in that it + * is inclusive such that it can appropriately represent the entire int32 + * domain. + */ +export interface EnumDescriptorProto_EnumReservedRange { + /** Inclusive. */ + start?: + | number + | undefined; + /** Inclusive. */ + end?: number | undefined; +} + +/** Describes a value within an enum. */ +export interface EnumValueDescriptorProto { + name?: string | undefined; + number?: number | undefined; + options?: EnumValueOptions | undefined; +} + +/** Describes a service. */ +export interface ServiceDescriptorProto { + name?: string | undefined; + method?: MethodDescriptorProto[] | undefined; + options?: ServiceOptions | undefined; +} + +/** Describes a method of a service. */ +export interface MethodDescriptorProto { + name?: + | string + | undefined; + /** + * Input and output type names. These are resolved in the same way as + * FieldDescriptorProto.type_name, but must refer to a message type. + */ + inputType?: string | undefined; + outputType?: string | undefined; + options?: + | MethodOptions + | undefined; + /** Identifies if client streams multiple client messages */ + clientStreaming?: + | boolean + | undefined; + /** Identifies if server streams multiple server messages */ + serverStreaming?: boolean | undefined; +} + +export interface FileOptions { + /** + * Sets the Java package where classes generated from this .proto will be + * placed. By default, the proto package is used, but this is often + * inappropriate because proto packages do not normally start with backwards + * domain names. + */ + javaPackage?: + | string + | undefined; + /** + * Controls the name of the wrapper Java class generated for the .proto file. + * That class will always contain the .proto file's getDescriptor() method as + * well as any top-level extensions defined in the .proto file. + * If java_multiple_files is disabled, then all the other classes from the + * .proto file will be nested inside the single wrapper outer class. + */ + javaOuterClassname?: + | string + | undefined; + /** + * If enabled, then the Java code generator will generate a separate .java + * file for each top-level message, enum, and service defined in the .proto + * file. Thus, these types will *not* be nested inside the wrapper class + * named by java_outer_classname. However, the wrapper class will still be + * generated to contain the file's getDescriptor() method as well as any + * top-level extensions defined in the file. + */ + javaMultipleFiles?: + | boolean + | undefined; + /** + * This option does nothing. + * + * @deprecated + */ + javaGenerateEqualsAndHash?: + | boolean + | undefined; + /** + * A proto2 file can set this to true to opt in to UTF-8 checking for Java, + * which will throw an exception if invalid UTF-8 is parsed from the wire or + * assigned to a string field. + * + * TODO: clarify exactly what kinds of field types this option + * applies to, and update these docs accordingly. + * + * Proto3 files already perform these checks. Setting the option explicitly to + * false has no effect: it cannot be used to opt proto3 files out of UTF-8 + * checks. + */ + javaStringCheckUtf8?: boolean | undefined; + optimizeFor?: + | FileOptions_OptimizeMode + | undefined; + /** + * Sets the Go package where structs generated from this .proto will be + * placed. If omitted, the Go package will be derived from the following: + * - The basename of the package import path, if provided. + * - Otherwise, the package statement in the .proto file, if present. + * - Otherwise, the basename of the .proto file, without extension. + */ + goPackage?: + | string + | undefined; + /** + * Should generic services be generated in each language? "Generic" services + * are not specific to any particular RPC system. They are generated by the + * main code generators in each language (without additional plugins). + * Generic services were the only kind of service generation supported by + * early versions of google.protobuf. + * + * Generic services are now considered deprecated in favor of using plugins + * that generate code specific to your particular RPC system. Therefore, + * these default to false. Old code which depends on generic services should + * explicitly set them to true. + */ + ccGenericServices?: boolean | undefined; + javaGenericServices?: boolean | undefined; + pyGenericServices?: + | boolean + | undefined; + /** + * Is this file deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for everything in the file, or it will be completely ignored; in the very + * least, this is a formalization for deprecating files. + */ + deprecated?: + | boolean + | undefined; + /** + * Enables the use of arenas for the proto messages in this file. This applies + * only to generated classes for C++. + */ + ccEnableArenas?: + | boolean + | undefined; + /** + * Sets the objective c class prefix which is prepended to all objective c + * generated classes from this .proto. There is no default. + */ + objcClassPrefix?: + | string + | undefined; + /** Namespace for generated classes; defaults to the package. */ + csharpNamespace?: + | string + | undefined; + /** + * By default Swift generators will take the proto package and CamelCase it + * replacing '.' with underscore and use that to prefix the types/symbols + * defined. When this options is provided, they will use this value instead + * to prefix the types/symbols defined. + */ + swiftPrefix?: + | string + | undefined; + /** + * Sets the php class prefix which is prepended to all php generated classes + * from this .proto. Default is empty. + */ + phpClassPrefix?: + | string + | undefined; + /** + * Use this option to change the namespace of php generated classes. Default + * is empty. When this option is empty, the package name will be used for + * determining the namespace. + */ + phpNamespace?: + | string + | undefined; + /** + * Use this option to change the namespace of php generated metadata classes. + * Default is empty. When this option is empty, the proto file name will be + * used for determining the namespace. + */ + phpMetadataNamespace?: + | string + | undefined; + /** + * Use this option to change the package of ruby generated classes. Default + * is empty. When this option is not set, the package name will be used for + * determining the ruby package. + */ + rubyPackage?: + | string + | undefined; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + */ + features?: + | FeatureSet + | undefined; + /** + * The parser stores options it doesn't recognize here. + * See the documentation for the "Options" section above. + */ + uninterpretedOption?: UninterpretedOption[] | undefined; +} + +/** Generated classes can be optimized for speed or code size. */ +export enum FileOptions_OptimizeMode { + /** SPEED - Generate complete code for parsing, serialization, */ + SPEED = 1, + /** CODE_SIZE - etc. */ + CODE_SIZE = 2, + /** LITE_RUNTIME - Generate code using MessageLite and the lite runtime. */ + LITE_RUNTIME = 3, + UNRECOGNIZED = -1, +} + +export function fileOptions_OptimizeModeFromJSON(object: any): FileOptions_OptimizeMode { + switch (object) { + case 1: + case "SPEED": + return FileOptions_OptimizeMode.SPEED; + case 2: + case "CODE_SIZE": + return FileOptions_OptimizeMode.CODE_SIZE; + case 3: + case "LITE_RUNTIME": + return FileOptions_OptimizeMode.LITE_RUNTIME; + case -1: + case "UNRECOGNIZED": + default: + return FileOptions_OptimizeMode.UNRECOGNIZED; + } +} + +export function fileOptions_OptimizeModeToJSON(object: FileOptions_OptimizeMode): string { + switch (object) { + case FileOptions_OptimizeMode.SPEED: + return "SPEED"; + case FileOptions_OptimizeMode.CODE_SIZE: + return "CODE_SIZE"; + case FileOptions_OptimizeMode.LITE_RUNTIME: + return "LITE_RUNTIME"; + case FileOptions_OptimizeMode.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export interface MessageOptions { + /** + * Set true to use the old proto1 MessageSet wire format for extensions. + * This is provided for backwards-compatibility with the MessageSet wire + * format. You should not use this for any other reason: It's less + * efficient, has fewer features, and is more complicated. + * + * The message must be defined exactly as follows: + * message Foo { + * option message_set_wire_format = true; + * extensions 4 to max; + * } + * Note that the message cannot have any defined fields; MessageSets only + * have extensions. + * + * All extensions of your type must be singular messages; e.g. they cannot + * be int32s, enums, or repeated messages. + * + * Because this is an option, the above two restrictions are not enforced by + * the protocol compiler. + */ + messageSetWireFormat?: + | boolean + | undefined; + /** + * Disables the generation of the standard "descriptor()" accessor, which can + * conflict with a field of the same name. This is meant to make migration + * from proto1 easier; new code should avoid fields named "descriptor". + */ + noStandardDescriptorAccessor?: + | boolean + | undefined; + /** + * Is this message deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the message, or it will be completely ignored; in the very least, + * this is a formalization for deprecating messages. + */ + deprecated?: + | boolean + | undefined; + /** + * Whether the message is an automatically generated map entry type for the + * maps field. + * + * For maps fields: + * map map_field = 1; + * The parsed descriptor looks like: + * message MapFieldEntry { + * option map_entry = true; + * optional KeyType key = 1; + * optional ValueType value = 2; + * } + * repeated MapFieldEntry map_field = 1; + * + * Implementations may choose not to generate the map_entry=true message, but + * use a native map in the target language to hold the keys and values. + * The reflection APIs in such implementations still need to work as + * if the field is a repeated message field. + * + * NOTE: Do not set the option in .proto files. Always use the maps syntax + * instead. The option should only be implicitly set by the proto compiler + * parser. + */ + mapEntry?: + | boolean + | undefined; + /** + * Enable the legacy handling of JSON field name conflicts. This lowercases + * and strips underscored from the fields before comparison in proto3 only. + * The new behavior takes `json_name` into account and applies to proto2 as + * well. + * + * This should only be used as a temporary measure against broken builds due + * to the change in behavior for JSON field name conflicts. + * + * TODO This is legacy behavior we plan to remove once downstream + * teams have had time to migrate. + * + * @deprecated + */ + deprecatedLegacyJsonFieldConflicts?: + | boolean + | undefined; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + */ + features?: + | FeatureSet + | undefined; + /** The parser stores options it doesn't recognize here. See above. */ + uninterpretedOption?: UninterpretedOption[] | undefined; +} + +export interface FieldOptions { + /** + * NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead. + * The ctype option instructs the C++ code generator to use a different + * representation of the field than it normally would. See the specific + * options below. This option is only implemented to support use of + * [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of + * type "bytes" in the open source release. + * TODO: make ctype actually deprecated. + */ + ctype?: + | FieldOptions_CType + | undefined; + /** + * The packed option can be enabled for repeated primitive fields to enable + * a more efficient representation on the wire. Rather than repeatedly + * writing the tag and type for each element, the entire array is encoded as + * a single length-delimited blob. In proto3, only explicit setting it to + * false will avoid using packed encoding. This option is prohibited in + * Editions, but the `repeated_field_encoding` feature can be used to control + * the behavior. + */ + packed?: + | boolean + | undefined; + /** + * The jstype option determines the JavaScript type used for values of the + * field. The option is permitted only for 64 bit integral and fixed types + * (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING + * is represented as JavaScript string, which avoids loss of precision that + * can happen when a large value is converted to a floating point JavaScript. + * Specifying JS_NUMBER for the jstype causes the generated JavaScript code to + * use the JavaScript "number" type. The behavior of the default option + * JS_NORMAL is implementation dependent. + * + * This option is an enum to permit additional types to be added, e.g. + * goog.math.Integer. + */ + jstype?: + | FieldOptions_JSType + | undefined; + /** + * Should this field be parsed lazily? Lazy applies only to message-type + * fields. It means that when the outer message is initially parsed, the + * inner message's contents will not be parsed but instead stored in encoded + * form. The inner message will actually be parsed when it is first accessed. + * + * This is only a hint. Implementations are free to choose whether to use + * eager or lazy parsing regardless of the value of this option. However, + * setting this option true suggests that the protocol author believes that + * using lazy parsing on this field is worth the additional bookkeeping + * overhead typically needed to implement it. + * + * This option does not affect the public interface of any generated code; + * all method signatures remain the same. Furthermore, thread-safety of the + * interface is not affected by this option; const methods remain safe to + * call from multiple threads concurrently, while non-const methods continue + * to require exclusive access. + * + * Note that lazy message fields are still eagerly verified to check + * ill-formed wireformat or missing required fields. Calling IsInitialized() + * on the outer message would fail if the inner message has missing required + * fields. Failed verification would result in parsing failure (except when + * uninitialized messages are acceptable). + */ + lazy?: + | boolean + | undefined; + /** + * unverified_lazy does no correctness checks on the byte stream. This should + * only be used where lazy with verification is prohibitive for performance + * reasons. + */ + unverifiedLazy?: + | boolean + | undefined; + /** + * Is this field deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for accessors, or it will be completely ignored; in the very least, this + * is a formalization for deprecating fields. + */ + deprecated?: + | boolean + | undefined; + /** + * DEPRECATED. DO NOT USE! + * For Google-internal migration only. Do not use. + * + * @deprecated + */ + weak?: + | boolean + | undefined; + /** + * Indicate that the field value should not be printed out when using debug + * formats, e.g. when the field contains sensitive credentials. + */ + debugRedact?: boolean | undefined; + retention?: FieldOptions_OptionRetention | undefined; + targets?: FieldOptions_OptionTargetType[] | undefined; + editionDefaults?: + | FieldOptions_EditionDefault[] + | undefined; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + */ + features?: FeatureSet | undefined; + featureSupport?: + | FieldOptions_FeatureSupport + | undefined; + /** The parser stores options it doesn't recognize here. See above. */ + uninterpretedOption?: UninterpretedOption[] | undefined; +} + +export enum FieldOptions_CType { + /** STRING - Default mode. */ + STRING = 0, + /** + * CORD - The option [ctype=CORD] may be applied to a non-repeated field of type + * "bytes". It indicates that in C++, the data should be stored in a Cord + * instead of a string. For very large strings, this may reduce memory + * fragmentation. It may also allow better performance when parsing from a + * Cord, or when parsing with aliasing enabled, as the parsed Cord may then + * alias the original buffer. + */ + CORD = 1, + STRING_PIECE = 2, + UNRECOGNIZED = -1, +} + +export function fieldOptions_CTypeFromJSON(object: any): FieldOptions_CType { + switch (object) { + case 0: + case "STRING": + return FieldOptions_CType.STRING; + case 1: + case "CORD": + return FieldOptions_CType.CORD; + case 2: + case "STRING_PIECE": + return FieldOptions_CType.STRING_PIECE; + case -1: + case "UNRECOGNIZED": + default: + return FieldOptions_CType.UNRECOGNIZED; + } +} + +export function fieldOptions_CTypeToJSON(object: FieldOptions_CType): string { + switch (object) { + case FieldOptions_CType.STRING: + return "STRING"; + case FieldOptions_CType.CORD: + return "CORD"; + case FieldOptions_CType.STRING_PIECE: + return "STRING_PIECE"; + case FieldOptions_CType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum FieldOptions_JSType { + /** JS_NORMAL - Use the default type. */ + JS_NORMAL = 0, + /** JS_STRING - Use JavaScript strings. */ + JS_STRING = 1, + /** JS_NUMBER - Use JavaScript numbers. */ + JS_NUMBER = 2, + UNRECOGNIZED = -1, +} + +export function fieldOptions_JSTypeFromJSON(object: any): FieldOptions_JSType { + switch (object) { + case 0: + case "JS_NORMAL": + return FieldOptions_JSType.JS_NORMAL; + case 1: + case "JS_STRING": + return FieldOptions_JSType.JS_STRING; + case 2: + case "JS_NUMBER": + return FieldOptions_JSType.JS_NUMBER; + case -1: + case "UNRECOGNIZED": + default: + return FieldOptions_JSType.UNRECOGNIZED; + } +} + +export function fieldOptions_JSTypeToJSON(object: FieldOptions_JSType): string { + switch (object) { + case FieldOptions_JSType.JS_NORMAL: + return "JS_NORMAL"; + case FieldOptions_JSType.JS_STRING: + return "JS_STRING"; + case FieldOptions_JSType.JS_NUMBER: + return "JS_NUMBER"; + case FieldOptions_JSType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +/** If set to RETENTION_SOURCE, the option will be omitted from the binary. */ +export enum FieldOptions_OptionRetention { + RETENTION_UNKNOWN = 0, + RETENTION_RUNTIME = 1, + RETENTION_SOURCE = 2, + UNRECOGNIZED = -1, +} + +export function fieldOptions_OptionRetentionFromJSON(object: any): FieldOptions_OptionRetention { + switch (object) { + case 0: + case "RETENTION_UNKNOWN": + return FieldOptions_OptionRetention.RETENTION_UNKNOWN; + case 1: + case "RETENTION_RUNTIME": + return FieldOptions_OptionRetention.RETENTION_RUNTIME; + case 2: + case "RETENTION_SOURCE": + return FieldOptions_OptionRetention.RETENTION_SOURCE; + case -1: + case "UNRECOGNIZED": + default: + return FieldOptions_OptionRetention.UNRECOGNIZED; + } +} + +export function fieldOptions_OptionRetentionToJSON(object: FieldOptions_OptionRetention): string { + switch (object) { + case FieldOptions_OptionRetention.RETENTION_UNKNOWN: + return "RETENTION_UNKNOWN"; + case FieldOptions_OptionRetention.RETENTION_RUNTIME: + return "RETENTION_RUNTIME"; + case FieldOptions_OptionRetention.RETENTION_SOURCE: + return "RETENTION_SOURCE"; + case FieldOptions_OptionRetention.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +/** + * This indicates the types of entities that the field may apply to when used + * as an option. If it is unset, then the field may be freely used as an + * option on any kind of entity. + */ +export enum FieldOptions_OptionTargetType { + TARGET_TYPE_UNKNOWN = 0, + TARGET_TYPE_FILE = 1, + TARGET_TYPE_EXTENSION_RANGE = 2, + TARGET_TYPE_MESSAGE = 3, + TARGET_TYPE_FIELD = 4, + TARGET_TYPE_ONEOF = 5, + TARGET_TYPE_ENUM = 6, + TARGET_TYPE_ENUM_ENTRY = 7, + TARGET_TYPE_SERVICE = 8, + TARGET_TYPE_METHOD = 9, + UNRECOGNIZED = -1, +} + +export function fieldOptions_OptionTargetTypeFromJSON(object: any): FieldOptions_OptionTargetType { + switch (object) { + case 0: + case "TARGET_TYPE_UNKNOWN": + return FieldOptions_OptionTargetType.TARGET_TYPE_UNKNOWN; + case 1: + case "TARGET_TYPE_FILE": + return FieldOptions_OptionTargetType.TARGET_TYPE_FILE; + case 2: + case "TARGET_TYPE_EXTENSION_RANGE": + return FieldOptions_OptionTargetType.TARGET_TYPE_EXTENSION_RANGE; + case 3: + case "TARGET_TYPE_MESSAGE": + return FieldOptions_OptionTargetType.TARGET_TYPE_MESSAGE; + case 4: + case "TARGET_TYPE_FIELD": + return FieldOptions_OptionTargetType.TARGET_TYPE_FIELD; + case 5: + case "TARGET_TYPE_ONEOF": + return FieldOptions_OptionTargetType.TARGET_TYPE_ONEOF; + case 6: + case "TARGET_TYPE_ENUM": + return FieldOptions_OptionTargetType.TARGET_TYPE_ENUM; + case 7: + case "TARGET_TYPE_ENUM_ENTRY": + return FieldOptions_OptionTargetType.TARGET_TYPE_ENUM_ENTRY; + case 8: + case "TARGET_TYPE_SERVICE": + return FieldOptions_OptionTargetType.TARGET_TYPE_SERVICE; + case 9: + case "TARGET_TYPE_METHOD": + return FieldOptions_OptionTargetType.TARGET_TYPE_METHOD; + case -1: + case "UNRECOGNIZED": + default: + return FieldOptions_OptionTargetType.UNRECOGNIZED; + } +} + +export function fieldOptions_OptionTargetTypeToJSON(object: FieldOptions_OptionTargetType): string { + switch (object) { + case FieldOptions_OptionTargetType.TARGET_TYPE_UNKNOWN: + return "TARGET_TYPE_UNKNOWN"; + case FieldOptions_OptionTargetType.TARGET_TYPE_FILE: + return "TARGET_TYPE_FILE"; + case FieldOptions_OptionTargetType.TARGET_TYPE_EXTENSION_RANGE: + return "TARGET_TYPE_EXTENSION_RANGE"; + case FieldOptions_OptionTargetType.TARGET_TYPE_MESSAGE: + return "TARGET_TYPE_MESSAGE"; + case FieldOptions_OptionTargetType.TARGET_TYPE_FIELD: + return "TARGET_TYPE_FIELD"; + case FieldOptions_OptionTargetType.TARGET_TYPE_ONEOF: + return "TARGET_TYPE_ONEOF"; + case FieldOptions_OptionTargetType.TARGET_TYPE_ENUM: + return "TARGET_TYPE_ENUM"; + case FieldOptions_OptionTargetType.TARGET_TYPE_ENUM_ENTRY: + return "TARGET_TYPE_ENUM_ENTRY"; + case FieldOptions_OptionTargetType.TARGET_TYPE_SERVICE: + return "TARGET_TYPE_SERVICE"; + case FieldOptions_OptionTargetType.TARGET_TYPE_METHOD: + return "TARGET_TYPE_METHOD"; + case FieldOptions_OptionTargetType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export interface FieldOptions_EditionDefault { + edition?: + | Edition + | undefined; + /** Textproto value. */ + value?: string | undefined; +} + +/** Information about the support window of a feature. */ +export interface FieldOptions_FeatureSupport { + /** + * The edition that this feature was first available in. In editions + * earlier than this one, the default assigned to EDITION_LEGACY will be + * used, and proto files will not be able to override it. + */ + editionIntroduced?: + | Edition + | undefined; + /** + * The edition this feature becomes deprecated in. Using this after this + * edition may trigger warnings. + */ + editionDeprecated?: + | Edition + | undefined; + /** + * The deprecation warning text if this feature is used after the edition it + * was marked deprecated in. + */ + deprecationWarning?: + | string + | undefined; + /** + * The edition this feature is no longer available in. In editions after + * this one, the last default assigned will be used, and proto files will + * not be able to override it. + */ + editionRemoved?: + | Edition + | undefined; + /** + * The removal error text if this feature is used after the edition it was + * removed in. + */ + removalError?: string | undefined; +} + +export interface OneofOptions { + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + */ + features?: + | FeatureSet + | undefined; + /** The parser stores options it doesn't recognize here. See above. */ + uninterpretedOption?: UninterpretedOption[] | undefined; +} + +export interface EnumOptions { + /** + * Set this option to true to allow mapping different tag names to the same + * value. + */ + allowAlias?: + | boolean + | undefined; + /** + * Is this enum deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the enum, or it will be completely ignored; in the very least, this + * is a formalization for deprecating enums. + */ + deprecated?: + | boolean + | undefined; + /** + * Enable the legacy handling of JSON field name conflicts. This lowercases + * and strips underscored from the fields before comparison in proto3 only. + * The new behavior takes `json_name` into account and applies to proto2 as + * well. + * TODO Remove this legacy behavior once downstream teams have + * had time to migrate. + * + * @deprecated + */ + deprecatedLegacyJsonFieldConflicts?: + | boolean + | undefined; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + */ + features?: + | FeatureSet + | undefined; + /** The parser stores options it doesn't recognize here. See above. */ + uninterpretedOption?: UninterpretedOption[] | undefined; +} + +export interface EnumValueOptions { + /** + * Is this enum value deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the enum value, or it will be completely ignored; in the very least, + * this is a formalization for deprecating enum values. + */ + deprecated?: + | boolean + | undefined; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + */ + features?: + | FeatureSet + | undefined; + /** + * Indicate that fields annotated with this enum value should not be printed + * out when using debug formats, e.g. when the field contains sensitive + * credentials. + */ + debugRedact?: + | boolean + | undefined; + /** Information about the support window of a feature value. */ + featureSupport?: + | FieldOptions_FeatureSupport + | undefined; + /** The parser stores options it doesn't recognize here. See above. */ + uninterpretedOption?: UninterpretedOption[] | undefined; +} + +export interface ServiceOptions { + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + */ + features?: + | FeatureSet + | undefined; + /** + * Is this service deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the service, or it will be completely ignored; in the very least, + * this is a formalization for deprecating services. + */ + deprecated?: + | boolean + | undefined; + /** The parser stores options it doesn't recognize here. See above. */ + uninterpretedOption?: UninterpretedOption[] | undefined; +} + +export interface MethodOptions { + /** + * Is this method deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the method, or it will be completely ignored; in the very least, + * this is a formalization for deprecating methods. + */ + deprecated?: boolean | undefined; + idempotencyLevel?: + | MethodOptions_IdempotencyLevel + | undefined; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + */ + features?: + | FeatureSet + | undefined; + /** The parser stores options it doesn't recognize here. See above. */ + uninterpretedOption?: UninterpretedOption[] | undefined; +} + +/** + * Is this method side-effect-free (or safe in HTTP parlance), or idempotent, + * or neither? HTTP based RPC implementation may choose GET verb for safe + * methods, and PUT verb for idempotent methods instead of the default POST. + */ +export enum MethodOptions_IdempotencyLevel { + IDEMPOTENCY_UNKNOWN = 0, + /** NO_SIDE_EFFECTS - implies idempotent */ + NO_SIDE_EFFECTS = 1, + /** IDEMPOTENT - idempotent, but may have side effects */ + IDEMPOTENT = 2, + UNRECOGNIZED = -1, +} + +export function methodOptions_IdempotencyLevelFromJSON(object: any): MethodOptions_IdempotencyLevel { + switch (object) { + case 0: + case "IDEMPOTENCY_UNKNOWN": + return MethodOptions_IdempotencyLevel.IDEMPOTENCY_UNKNOWN; + case 1: + case "NO_SIDE_EFFECTS": + return MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS; + case 2: + case "IDEMPOTENT": + return MethodOptions_IdempotencyLevel.IDEMPOTENT; + case -1: + case "UNRECOGNIZED": + default: + return MethodOptions_IdempotencyLevel.UNRECOGNIZED; + } +} + +export function methodOptions_IdempotencyLevelToJSON(object: MethodOptions_IdempotencyLevel): string { + switch (object) { + case MethodOptions_IdempotencyLevel.IDEMPOTENCY_UNKNOWN: + return "IDEMPOTENCY_UNKNOWN"; + case MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS: + return "NO_SIDE_EFFECTS"; + case MethodOptions_IdempotencyLevel.IDEMPOTENT: + return "IDEMPOTENT"; + case MethodOptions_IdempotencyLevel.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +/** + * A message representing a option the parser does not recognize. This only + * appears in options protos created by the compiler::Parser class. + * DescriptorPool resolves these when building Descriptor objects. Therefore, + * options protos in descriptor objects (e.g. returned by Descriptor::options(), + * or produced by Descriptor::CopyTo()) will never have UninterpretedOptions + * in them. + */ +export interface UninterpretedOption { + name?: + | UninterpretedOption_NamePart[] + | undefined; + /** + * The value of the uninterpreted option, in whatever type the tokenizer + * identified it as during parsing. Exactly one of these should be set. + */ + identifierValue?: string | undefined; + positiveIntValue?: number | undefined; + negativeIntValue?: number | undefined; + doubleValue?: number | undefined; + stringValue?: Uint8Array | undefined; + aggregateValue?: string | undefined; +} + +/** + * The name of the uninterpreted option. Each string represents a segment in + * a dot-separated name. is_extension is true iff a segment represents an + * extension (denoted with parentheses in options specs in .proto files). + * E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents + * "foo.(bar.baz).moo". + */ +export interface UninterpretedOption_NamePart { + namePart?: string | undefined; + isExtension?: boolean | undefined; +} + +/** + * TODO Enums in C++ gencode (and potentially other languages) are + * not well scoped. This means that each of the feature enums below can clash + * with each other. The short names we've chosen maximize call-site + * readability, but leave us very open to this scenario. A future feature will + * be designed and implemented to handle this, hopefully before we ever hit a + * conflict here. + */ +export interface FeatureSet { + fieldPresence?: FeatureSet_FieldPresence | undefined; + enumType?: FeatureSet_EnumType | undefined; + repeatedFieldEncoding?: FeatureSet_RepeatedFieldEncoding | undefined; + utf8Validation?: FeatureSet_Utf8Validation | undefined; + messageEncoding?: FeatureSet_MessageEncoding | undefined; + jsonFormat?: FeatureSet_JsonFormat | undefined; + enforceNamingStyle?: FeatureSet_EnforceNamingStyle | undefined; + defaultSymbolVisibility?: FeatureSet_VisibilityFeature_DefaultSymbolVisibility | undefined; +} + +export enum FeatureSet_FieldPresence { + FIELD_PRESENCE_UNKNOWN = 0, + EXPLICIT = 1, + IMPLICIT = 2, + LEGACY_REQUIRED = 3, + UNRECOGNIZED = -1, +} + +export function featureSet_FieldPresenceFromJSON(object: any): FeatureSet_FieldPresence { + switch (object) { + case 0: + case "FIELD_PRESENCE_UNKNOWN": + return FeatureSet_FieldPresence.FIELD_PRESENCE_UNKNOWN; + case 1: + case "EXPLICIT": + return FeatureSet_FieldPresence.EXPLICIT; + case 2: + case "IMPLICIT": + return FeatureSet_FieldPresence.IMPLICIT; + case 3: + case "LEGACY_REQUIRED": + return FeatureSet_FieldPresence.LEGACY_REQUIRED; + case -1: + case "UNRECOGNIZED": + default: + return FeatureSet_FieldPresence.UNRECOGNIZED; + } +} + +export function featureSet_FieldPresenceToJSON(object: FeatureSet_FieldPresence): string { + switch (object) { + case FeatureSet_FieldPresence.FIELD_PRESENCE_UNKNOWN: + return "FIELD_PRESENCE_UNKNOWN"; + case FeatureSet_FieldPresence.EXPLICIT: + return "EXPLICIT"; + case FeatureSet_FieldPresence.IMPLICIT: + return "IMPLICIT"; + case FeatureSet_FieldPresence.LEGACY_REQUIRED: + return "LEGACY_REQUIRED"; + case FeatureSet_FieldPresence.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum FeatureSet_EnumType { + ENUM_TYPE_UNKNOWN = 0, + OPEN = 1, + CLOSED = 2, + UNRECOGNIZED = -1, +} + +export function featureSet_EnumTypeFromJSON(object: any): FeatureSet_EnumType { + switch (object) { + case 0: + case "ENUM_TYPE_UNKNOWN": + return FeatureSet_EnumType.ENUM_TYPE_UNKNOWN; + case 1: + case "OPEN": + return FeatureSet_EnumType.OPEN; + case 2: + case "CLOSED": + return FeatureSet_EnumType.CLOSED; + case -1: + case "UNRECOGNIZED": + default: + return FeatureSet_EnumType.UNRECOGNIZED; + } +} + +export function featureSet_EnumTypeToJSON(object: FeatureSet_EnumType): string { + switch (object) { + case FeatureSet_EnumType.ENUM_TYPE_UNKNOWN: + return "ENUM_TYPE_UNKNOWN"; + case FeatureSet_EnumType.OPEN: + return "OPEN"; + case FeatureSet_EnumType.CLOSED: + return "CLOSED"; + case FeatureSet_EnumType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum FeatureSet_RepeatedFieldEncoding { + REPEATED_FIELD_ENCODING_UNKNOWN = 0, + PACKED = 1, + EXPANDED = 2, + UNRECOGNIZED = -1, +} + +export function featureSet_RepeatedFieldEncodingFromJSON(object: any): FeatureSet_RepeatedFieldEncoding { + switch (object) { + case 0: + case "REPEATED_FIELD_ENCODING_UNKNOWN": + return FeatureSet_RepeatedFieldEncoding.REPEATED_FIELD_ENCODING_UNKNOWN; + case 1: + case "PACKED": + return FeatureSet_RepeatedFieldEncoding.PACKED; + case 2: + case "EXPANDED": + return FeatureSet_RepeatedFieldEncoding.EXPANDED; + case -1: + case "UNRECOGNIZED": + default: + return FeatureSet_RepeatedFieldEncoding.UNRECOGNIZED; + } +} + +export function featureSet_RepeatedFieldEncodingToJSON(object: FeatureSet_RepeatedFieldEncoding): string { + switch (object) { + case FeatureSet_RepeatedFieldEncoding.REPEATED_FIELD_ENCODING_UNKNOWN: + return "REPEATED_FIELD_ENCODING_UNKNOWN"; + case FeatureSet_RepeatedFieldEncoding.PACKED: + return "PACKED"; + case FeatureSet_RepeatedFieldEncoding.EXPANDED: + return "EXPANDED"; + case FeatureSet_RepeatedFieldEncoding.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum FeatureSet_Utf8Validation { + UTF8_VALIDATION_UNKNOWN = 0, + VERIFY = 2, + NONE = 3, + UNRECOGNIZED = -1, +} + +export function featureSet_Utf8ValidationFromJSON(object: any): FeatureSet_Utf8Validation { + switch (object) { + case 0: + case "UTF8_VALIDATION_UNKNOWN": + return FeatureSet_Utf8Validation.UTF8_VALIDATION_UNKNOWN; + case 2: + case "VERIFY": + return FeatureSet_Utf8Validation.VERIFY; + case 3: + case "NONE": + return FeatureSet_Utf8Validation.NONE; + case -1: + case "UNRECOGNIZED": + default: + return FeatureSet_Utf8Validation.UNRECOGNIZED; + } +} + +export function featureSet_Utf8ValidationToJSON(object: FeatureSet_Utf8Validation): string { + switch (object) { + case FeatureSet_Utf8Validation.UTF8_VALIDATION_UNKNOWN: + return "UTF8_VALIDATION_UNKNOWN"; + case FeatureSet_Utf8Validation.VERIFY: + return "VERIFY"; + case FeatureSet_Utf8Validation.NONE: + return "NONE"; + case FeatureSet_Utf8Validation.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum FeatureSet_MessageEncoding { + MESSAGE_ENCODING_UNKNOWN = 0, + LENGTH_PREFIXED = 1, + DELIMITED = 2, + UNRECOGNIZED = -1, +} + +export function featureSet_MessageEncodingFromJSON(object: any): FeatureSet_MessageEncoding { + switch (object) { + case 0: + case "MESSAGE_ENCODING_UNKNOWN": + return FeatureSet_MessageEncoding.MESSAGE_ENCODING_UNKNOWN; + case 1: + case "LENGTH_PREFIXED": + return FeatureSet_MessageEncoding.LENGTH_PREFIXED; + case 2: + case "DELIMITED": + return FeatureSet_MessageEncoding.DELIMITED; + case -1: + case "UNRECOGNIZED": + default: + return FeatureSet_MessageEncoding.UNRECOGNIZED; + } +} + +export function featureSet_MessageEncodingToJSON(object: FeatureSet_MessageEncoding): string { + switch (object) { + case FeatureSet_MessageEncoding.MESSAGE_ENCODING_UNKNOWN: + return "MESSAGE_ENCODING_UNKNOWN"; + case FeatureSet_MessageEncoding.LENGTH_PREFIXED: + return "LENGTH_PREFIXED"; + case FeatureSet_MessageEncoding.DELIMITED: + return "DELIMITED"; + case FeatureSet_MessageEncoding.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum FeatureSet_JsonFormat { + JSON_FORMAT_UNKNOWN = 0, + ALLOW = 1, + LEGACY_BEST_EFFORT = 2, + UNRECOGNIZED = -1, +} + +export function featureSet_JsonFormatFromJSON(object: any): FeatureSet_JsonFormat { + switch (object) { + case 0: + case "JSON_FORMAT_UNKNOWN": + return FeatureSet_JsonFormat.JSON_FORMAT_UNKNOWN; + case 1: + case "ALLOW": + return FeatureSet_JsonFormat.ALLOW; + case 2: + case "LEGACY_BEST_EFFORT": + return FeatureSet_JsonFormat.LEGACY_BEST_EFFORT; + case -1: + case "UNRECOGNIZED": + default: + return FeatureSet_JsonFormat.UNRECOGNIZED; + } +} + +export function featureSet_JsonFormatToJSON(object: FeatureSet_JsonFormat): string { + switch (object) { + case FeatureSet_JsonFormat.JSON_FORMAT_UNKNOWN: + return "JSON_FORMAT_UNKNOWN"; + case FeatureSet_JsonFormat.ALLOW: + return "ALLOW"; + case FeatureSet_JsonFormat.LEGACY_BEST_EFFORT: + return "LEGACY_BEST_EFFORT"; + case FeatureSet_JsonFormat.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export enum FeatureSet_EnforceNamingStyle { + ENFORCE_NAMING_STYLE_UNKNOWN = 0, + STYLE2024 = 1, + STYLE_LEGACY = 2, + STYLE2026 = 3, + UNRECOGNIZED = -1, +} + +export function featureSet_EnforceNamingStyleFromJSON(object: any): FeatureSet_EnforceNamingStyle { + switch (object) { + case 0: + case "ENFORCE_NAMING_STYLE_UNKNOWN": + return FeatureSet_EnforceNamingStyle.ENFORCE_NAMING_STYLE_UNKNOWN; + case 1: + case "STYLE2024": + return FeatureSet_EnforceNamingStyle.STYLE2024; + case 2: + case "STYLE_LEGACY": + return FeatureSet_EnforceNamingStyle.STYLE_LEGACY; + case 3: + case "STYLE2026": + return FeatureSet_EnforceNamingStyle.STYLE2026; + case -1: + case "UNRECOGNIZED": + default: + return FeatureSet_EnforceNamingStyle.UNRECOGNIZED; + } +} + +export function featureSet_EnforceNamingStyleToJSON(object: FeatureSet_EnforceNamingStyle): string { + switch (object) { + case FeatureSet_EnforceNamingStyle.ENFORCE_NAMING_STYLE_UNKNOWN: + return "ENFORCE_NAMING_STYLE_UNKNOWN"; + case FeatureSet_EnforceNamingStyle.STYLE2024: + return "STYLE2024"; + case FeatureSet_EnforceNamingStyle.STYLE_LEGACY: + return "STYLE_LEGACY"; + case FeatureSet_EnforceNamingStyle.STYLE2026: + return "STYLE2026"; + case FeatureSet_EnforceNamingStyle.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export interface FeatureSet_VisibilityFeature { +} + +export enum FeatureSet_VisibilityFeature_DefaultSymbolVisibility { + DEFAULT_SYMBOL_VISIBILITY_UNKNOWN = 0, + /** EXPORT_ALL - Default pre-EDITION_2024, all UNSET visibility are export. */ + EXPORT_ALL = 1, + /** EXPORT_TOP_LEVEL - All top-level symbols default to export, nested default to local. */ + EXPORT_TOP_LEVEL = 2, + /** LOCAL_ALL - All symbols default to local. */ + LOCAL_ALL = 3, + /** + * STRICT - All symbols local by default. Nested types cannot be exported. + * With special case caveat for message { enum {} reserved 1 to max; } + * This is the recommended setting for new protos. + */ + STRICT = 4, + UNRECOGNIZED = -1, +} + +export function featureSet_VisibilityFeature_DefaultSymbolVisibilityFromJSON( + object: any, +): FeatureSet_VisibilityFeature_DefaultSymbolVisibility { + switch (object) { + case 0: + case "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN": + return FeatureSet_VisibilityFeature_DefaultSymbolVisibility.DEFAULT_SYMBOL_VISIBILITY_UNKNOWN; + case 1: + case "EXPORT_ALL": + return FeatureSet_VisibilityFeature_DefaultSymbolVisibility.EXPORT_ALL; + case 2: + case "EXPORT_TOP_LEVEL": + return FeatureSet_VisibilityFeature_DefaultSymbolVisibility.EXPORT_TOP_LEVEL; + case 3: + case "LOCAL_ALL": + return FeatureSet_VisibilityFeature_DefaultSymbolVisibility.LOCAL_ALL; + case 4: + case "STRICT": + return FeatureSet_VisibilityFeature_DefaultSymbolVisibility.STRICT; + case -1: + case "UNRECOGNIZED": + default: + return FeatureSet_VisibilityFeature_DefaultSymbolVisibility.UNRECOGNIZED; + } +} + +export function featureSet_VisibilityFeature_DefaultSymbolVisibilityToJSON( + object: FeatureSet_VisibilityFeature_DefaultSymbolVisibility, +): string { + switch (object) { + case FeatureSet_VisibilityFeature_DefaultSymbolVisibility.DEFAULT_SYMBOL_VISIBILITY_UNKNOWN: + return "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN"; + case FeatureSet_VisibilityFeature_DefaultSymbolVisibility.EXPORT_ALL: + return "EXPORT_ALL"; + case FeatureSet_VisibilityFeature_DefaultSymbolVisibility.EXPORT_TOP_LEVEL: + return "EXPORT_TOP_LEVEL"; + case FeatureSet_VisibilityFeature_DefaultSymbolVisibility.LOCAL_ALL: + return "LOCAL_ALL"; + case FeatureSet_VisibilityFeature_DefaultSymbolVisibility.STRICT: + return "STRICT"; + case FeatureSet_VisibilityFeature_DefaultSymbolVisibility.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +/** + * A compiled specification for the defaults of a set of features. These + * messages are generated from FeatureSet extensions and can be used to seed + * feature resolution. The resolution with this object becomes a simple search + * for the closest matching edition, followed by proto merges. + */ +export interface FeatureSetDefaults { + defaults?: + | FeatureSetDefaults_FeatureSetEditionDefault[] + | undefined; + /** + * The minimum supported edition (inclusive) when this was constructed. + * Editions before this will not have defaults. + */ + minimumEdition?: + | Edition + | undefined; + /** + * The maximum known edition (inclusive) when this was constructed. Editions + * after this will not have reliable defaults. + */ + maximumEdition?: Edition | undefined; +} + +/** + * A map from every known edition with a unique set of defaults to its + * defaults. Not all editions may be contained here. For a given edition, + * the defaults at the closest matching edition ordered at or before it should + * be used. This field must be in strict ascending order by edition. + */ +export interface FeatureSetDefaults_FeatureSetEditionDefault { + edition?: + | Edition + | undefined; + /** Defaults of features that can be overridden in this edition. */ + overridableFeatures?: + | FeatureSet + | undefined; + /** Defaults of features that can't be overridden in this edition. */ + fixedFeatures?: FeatureSet | undefined; +} + +/** + * Encapsulates information about the original source file from which a + * FileDescriptorProto was generated. + */ +export interface SourceCodeInfo { + /** + * A Location identifies a piece of source code in a .proto file which + * corresponds to a particular definition. This information is intended + * to be useful to IDEs, code indexers, documentation generators, and similar + * tools. + * + * For example, say we have a file like: + * message Foo { + * optional string foo = 1; + * } + * Let's look at just the field definition: + * optional string foo = 1; + * ^ ^^ ^^ ^ ^^^ + * a bc de f ghi + * We have the following locations: + * span path represents + * [a,i) [ 4, 0, 2, 0 ] The whole field definition. + * [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + * [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + * [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + * [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + * + * Notes: + * - A location may refer to a repeated field itself (i.e. not to any + * particular index within it). This is used whenever a set of elements are + * logically enclosed in a single code segment. For example, an entire + * extend block (possibly containing multiple extension definitions) will + * have an outer location whose path refers to the "extensions" repeated + * field without an index. + * - Multiple locations may have the same path. This happens when a single + * logical declaration is spread out across multiple places. The most + * obvious example is the "extend" block again -- there may be multiple + * extend blocks in the same scope, each of which will have the same path. + * - A location's span is not always a subset of its parent's span. For + * example, the "extendee" of an extension declaration appears at the + * beginning of the "extend" block and is shared by all extensions within + * the block. + * - Just because a location's span is a subset of some other location's span + * does not mean that it is a descendant. For example, a "group" defines + * both a type and a field in a single declaration. Thus, the locations + * corresponding to the type and field and their components will overlap. + * - Code which tries to interpret locations should probably be designed to + * ignore those that it doesn't understand, as more types of locations could + * be recorded in the future. + */ + location?: SourceCodeInfo_Location[] | undefined; +} + +export interface SourceCodeInfo_Location { + /** + * Identifies which part of the FileDescriptorProto was defined at this + * location. + * + * Each element is a field number or an index. They form a path from + * the root FileDescriptorProto to the place where the definition appears. + * For example, this path: + * [ 4, 3, 2, 7, 1 ] + * refers to: + * file.message_type(3) // 4, 3 + * .field(7) // 2, 7 + * .name() // 1 + * This is because FileDescriptorProto.message_type has field number 4: + * repeated DescriptorProto message_type = 4; + * and DescriptorProto.field has field number 2: + * repeated FieldDescriptorProto field = 2; + * and FieldDescriptorProto.name has field number 1: + * optional string name = 1; + * + * Thus, the above path gives the location of a field name. If we removed + * the last element: + * [ 4, 3, 2, 7 ] + * this path refers to the whole field declaration (from the beginning + * of the label to the terminating semicolon). + */ + path?: + | number[] + | undefined; + /** + * Always has exactly three or four elements: start line, start column, + * end line (optional, otherwise assumed same as start line), end column. + * These are packed into a single field for efficiency. Note that line + * and column numbers are zero-based -- typically you will want to add + * 1 to each before displaying to a user. + */ + span?: + | number[] + | undefined; + /** + * If this SourceCodeInfo represents a complete declaration, these are any + * comments appearing before and after the declaration which appear to be + * attached to the declaration. + * + * A series of line comments appearing on consecutive lines, with no other + * tokens appearing on those lines, will be treated as a single comment. + * + * leading_detached_comments will keep paragraphs of comments that appear + * before (but not connected to) the current element. Each paragraph, + * separated by empty lines, will be one comment element in the repeated + * field. + * + * Only the comment content is provided; comment markers (e.g. //) are + * stripped out. For block comments, leading whitespace and an asterisk + * will be stripped from the beginning of each line other than the first. + * Newlines are included in the output. + * + * Examples: + * + * optional int32 foo = 1; // Comment attached to foo. + * // Comment attached to bar. + * optional int32 bar = 2; + * + * optional string baz = 3; + * // Comment attached to baz. + * // Another line attached to baz. + * + * // Comment attached to moo. + * // + * // Another line attached to moo. + * optional double moo = 4; + * + * // Detached comment for corge. This is not leading or trailing comments + * // to moo or corge because there are blank lines separating it from + * // both. + * + * // Detached comment for corge paragraph 2. + * + * optional string corge = 5; + * /* Block comment attached + * * to corge. Leading asterisks + * * will be removed. * / + * /* Block comment attached to + * * grault. * / + * optional int32 grault = 6; + * + * // ignored detached comments. + */ + leadingComments?: string | undefined; + trailingComments?: string | undefined; + leadingDetachedComments?: string[] | undefined; +} + +/** + * Describes the relationship between generated code and its original source + * file. A GeneratedCodeInfo message is associated with only one generated + * source file, but may contain references to different source .proto files. + */ +export interface GeneratedCodeInfo { + /** + * An Annotation connects some span of text in generated code to an element + * of its generating .proto file. + */ + annotation?: GeneratedCodeInfo_Annotation[] | undefined; +} + +export interface GeneratedCodeInfo_Annotation { + /** + * Identifies the element in the original source .proto file. This field + * is formatted the same as SourceCodeInfo.Location.path. + */ + path?: + | number[] + | undefined; + /** Identifies the filesystem path to the original source .proto. */ + sourceFile?: + | string + | undefined; + /** + * Identifies the starting offset in bytes in the generated code + * that relates to the identified object. + */ + begin?: + | number + | undefined; + /** + * Identifies the ending offset in bytes in the generated code that + * relates to the identified object. The end offset should be one past + * the last relevant byte (so the length of the text = end - begin). + */ + end?: number | undefined; + semantic?: GeneratedCodeInfo_Annotation_Semantic | undefined; +} + +/** + * Represents the identified object's effect on the element in the original + * .proto file. + */ +export enum GeneratedCodeInfo_Annotation_Semantic { + /** NONE - There is no effect or the effect is indescribable. */ + NONE = 0, + /** SET - The element is set or otherwise mutated. */ + SET = 1, + /** ALIAS - An alias to the element is returned. */ + ALIAS = 2, + UNRECOGNIZED = -1, +} + +export function generatedCodeInfo_Annotation_SemanticFromJSON(object: any): GeneratedCodeInfo_Annotation_Semantic { + switch (object) { + case 0: + case "NONE": + return GeneratedCodeInfo_Annotation_Semantic.NONE; + case 1: + case "SET": + return GeneratedCodeInfo_Annotation_Semantic.SET; + case 2: + case "ALIAS": + return GeneratedCodeInfo_Annotation_Semantic.ALIAS; + case -1: + case "UNRECOGNIZED": + default: + return GeneratedCodeInfo_Annotation_Semantic.UNRECOGNIZED; + } +} + +export function generatedCodeInfo_Annotation_SemanticToJSON(object: GeneratedCodeInfo_Annotation_Semantic): string { + switch (object) { + case GeneratedCodeInfo_Annotation_Semantic.NONE: + return "NONE"; + case GeneratedCodeInfo_Annotation_Semantic.SET: + return "SET"; + case GeneratedCodeInfo_Annotation_Semantic.ALIAS: + return "ALIAS"; + case GeneratedCodeInfo_Annotation_Semantic.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +function createBaseFileDescriptorSet(): FileDescriptorSet { + return { file: [] }; +} + +export const FileDescriptorSet: MessageFns = { + encode(message: FileDescriptorSet, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.file !== undefined && message.file.length !== 0) { + for (const v of message.file) { + FileDescriptorProto.encode(v!, writer.uint32(10).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): FileDescriptorSet { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFileDescriptorSet(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + const el = FileDescriptorProto.decode(reader, reader.uint32()); + if (el !== undefined) { + message.file!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): FileDescriptorSet { + return { + file: globalThis.Array.isArray(object?.file) ? object.file.map((e: any) => FileDescriptorProto.fromJSON(e)) : [], + }; + }, + + toJSON(message: FileDescriptorSet): unknown { + const obj: any = {}; + if (message.file?.length) { + obj.file = message.file.map((e) => FileDescriptorProto.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): FileDescriptorSet { + return FileDescriptorSet.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): FileDescriptorSet { + const message = createBaseFileDescriptorSet(); + message.file = object.file?.map((e) => FileDescriptorProto.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseFileDescriptorProto(): FileDescriptorProto { + return { + name: "", + package: "", + dependency: [], + publicDependency: [], + weakDependency: [], + optionDependency: [], + messageType: [], + enumType: [], + service: [], + extension: [], + options: undefined, + sourceCodeInfo: undefined, + syntax: "", + edition: 0, + }; +} + +export const FileDescriptorProto: MessageFns = { + encode(message: FileDescriptorProto, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.package !== undefined && message.package !== "") { + writer.uint32(18).string(message.package); + } + if (message.dependency !== undefined && message.dependency.length !== 0) { + for (const v of message.dependency) { + writer.uint32(26).string(v!); + } + } + if (message.publicDependency !== undefined && message.publicDependency.length !== 0) { + for (const v of message.publicDependency) { + writer.uint32(80).int32(v!); + } + } + if (message.weakDependency !== undefined && message.weakDependency.length !== 0) { + for (const v of message.weakDependency) { + writer.uint32(88).int32(v!); + } + } + if (message.optionDependency !== undefined && message.optionDependency.length !== 0) { + for (const v of message.optionDependency) { + writer.uint32(122).string(v!); + } + } + if (message.messageType !== undefined && message.messageType.length !== 0) { + for (const v of message.messageType) { + DescriptorProto.encode(v!, writer.uint32(34).fork()).join(); + } + } + if (message.enumType !== undefined && message.enumType.length !== 0) { + for (const v of message.enumType) { + EnumDescriptorProto.encode(v!, writer.uint32(42).fork()).join(); + } + } + if (message.service !== undefined && message.service.length !== 0) { + for (const v of message.service) { + ServiceDescriptorProto.encode(v!, writer.uint32(50).fork()).join(); + } + } + if (message.extension !== undefined && message.extension.length !== 0) { + for (const v of message.extension) { + FieldDescriptorProto.encode(v!, writer.uint32(58).fork()).join(); + } + } + if (message.options !== undefined) { + FileOptions.encode(message.options, writer.uint32(66).fork()).join(); + } + if (message.sourceCodeInfo !== undefined) { + SourceCodeInfo.encode(message.sourceCodeInfo, writer.uint32(74).fork()).join(); + } + if (message.syntax !== undefined && message.syntax !== "") { + writer.uint32(98).string(message.syntax); + } + if (message.edition !== undefined && message.edition !== 0) { + writer.uint32(112).int32(message.edition); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): FileDescriptorProto { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFileDescriptorProto(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.package = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.dependency!.push(el); + } + continue; + } + case 10: { + if (tag === 80) { + message.publicDependency!.push(reader.int32()); + + continue; + } + + if (tag === 82) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.publicDependency!.push(reader.int32()); + } + + continue; + } + + break; + } + case 11: { + if (tag === 88) { + message.weakDependency!.push(reader.int32()); + + continue; + } + + if (tag === 90) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.weakDependency!.push(reader.int32()); + } + + continue; + } + + break; + } + case 15: { + if (tag !== 122) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.optionDependency!.push(el); + } + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + const el = DescriptorProto.decode(reader, reader.uint32()); + if (el !== undefined) { + message.messageType!.push(el); + } + continue; + } + case 5: { + if (tag !== 42) { + break; + } + + const el = EnumDescriptorProto.decode(reader, reader.uint32()); + if (el !== undefined) { + message.enumType!.push(el); + } + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + const el = ServiceDescriptorProto.decode(reader, reader.uint32()); + if (el !== undefined) { + message.service!.push(el); + } + continue; + } + case 7: { + if (tag !== 58) { + break; + } + + const el = FieldDescriptorProto.decode(reader, reader.uint32()); + if (el !== undefined) { + message.extension!.push(el); + } + continue; + } + case 8: { + if (tag !== 66) { + break; + } + + message.options = FileOptions.decode(reader, reader.uint32()); + continue; + } + case 9: { + if (tag !== 74) { + break; + } + + message.sourceCodeInfo = SourceCodeInfo.decode(reader, reader.uint32()); + continue; + } + case 12: { + if (tag !== 98) { + break; + } + + message.syntax = reader.string(); + continue; + } + case 14: { + if (tag !== 112) { + break; + } + + message.edition = reader.int32() as any; + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): FileDescriptorProto { + return { + name: isSet(object.name) ? globalThis.String(object.name) : "", + package: isSet(object.package) ? globalThis.String(object.package) : "", + dependency: globalThis.Array.isArray(object?.dependency) + ? object.dependency.map((e: any) => globalThis.String(e)) + : [], + publicDependency: globalThis.Array.isArray(object?.publicDependency) + ? object.publicDependency.map((e: any) => globalThis.Number(e)) + : globalThis.Array.isArray(object?.public_dependency) + ? object.public_dependency.map((e: any) => globalThis.Number(e)) + : [], + weakDependency: globalThis.Array.isArray(object?.weakDependency) + ? object.weakDependency.map((e: any) => globalThis.Number(e)) + : globalThis.Array.isArray(object?.weak_dependency) + ? object.weak_dependency.map((e: any) => globalThis.Number(e)) + : [], + optionDependency: globalThis.Array.isArray(object?.optionDependency) + ? object.optionDependency.map((e: any) => globalThis.String(e)) + : globalThis.Array.isArray(object?.option_dependency) + ? object.option_dependency.map((e: any) => globalThis.String(e)) + : [], + messageType: globalThis.Array.isArray(object?.messageType) + ? object.messageType.map((e: any) => DescriptorProto.fromJSON(e)) + : globalThis.Array.isArray(object?.message_type) + ? object.message_type.map((e: any) => DescriptorProto.fromJSON(e)) + : [], + enumType: globalThis.Array.isArray(object?.enumType) + ? object.enumType.map((e: any) => EnumDescriptorProto.fromJSON(e)) + : globalThis.Array.isArray(object?.enum_type) + ? object.enum_type.map((e: any) => EnumDescriptorProto.fromJSON(e)) + : [], + service: globalThis.Array.isArray(object?.service) + ? object.service.map((e: any) => ServiceDescriptorProto.fromJSON(e)) + : [], + extension: globalThis.Array.isArray(object?.extension) + ? object.extension.map((e: any) => FieldDescriptorProto.fromJSON(e)) + : [], + options: isSet(object.options) ? FileOptions.fromJSON(object.options) : undefined, + sourceCodeInfo: isSet(object.sourceCodeInfo) + ? SourceCodeInfo.fromJSON(object.sourceCodeInfo) + : isSet(object.source_code_info) + ? SourceCodeInfo.fromJSON(object.source_code_info) + : undefined, + syntax: isSet(object.syntax) ? globalThis.String(object.syntax) : "", + edition: isSet(object.edition) ? editionFromJSON(object.edition) : 0, + }; + }, + + toJSON(message: FileDescriptorProto): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.package !== undefined && message.package !== "") { + obj.package = message.package; + } + if (message.dependency?.length) { + obj.dependency = message.dependency; + } + if (message.publicDependency?.length) { + obj.publicDependency = message.publicDependency.map((e) => Math.round(e)); + } + if (message.weakDependency?.length) { + obj.weakDependency = message.weakDependency.map((e) => Math.round(e)); + } + if (message.optionDependency?.length) { + obj.optionDependency = message.optionDependency; + } + if (message.messageType?.length) { + obj.messageType = message.messageType.map((e) => DescriptorProto.toJSON(e)); + } + if (message.enumType?.length) { + obj.enumType = message.enumType.map((e) => EnumDescriptorProto.toJSON(e)); + } + if (message.service?.length) { + obj.service = message.service.map((e) => ServiceDescriptorProto.toJSON(e)); + } + if (message.extension?.length) { + obj.extension = message.extension.map((e) => FieldDescriptorProto.toJSON(e)); + } + if (message.options !== undefined) { + obj.options = FileOptions.toJSON(message.options); + } + if (message.sourceCodeInfo !== undefined) { + obj.sourceCodeInfo = SourceCodeInfo.toJSON(message.sourceCodeInfo); + } + if (message.syntax !== undefined && message.syntax !== "") { + obj.syntax = message.syntax; + } + if (message.edition !== undefined && message.edition !== 0) { + obj.edition = editionToJSON(message.edition); + } + return obj; + }, + + create(base?: DeepPartial): FileDescriptorProto { + return FileDescriptorProto.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): FileDescriptorProto { + const message = createBaseFileDescriptorProto(); + message.name = object.name ?? ""; + message.package = object.package ?? ""; + message.dependency = object.dependency?.map((e) => e) || []; + message.publicDependency = object.publicDependency?.map((e) => e) || []; + message.weakDependency = object.weakDependency?.map((e) => e) || []; + message.optionDependency = object.optionDependency?.map((e) => e) || []; + message.messageType = object.messageType?.map((e) => DescriptorProto.fromPartial(e)) || []; + message.enumType = object.enumType?.map((e) => EnumDescriptorProto.fromPartial(e)) || []; + message.service = object.service?.map((e) => ServiceDescriptorProto.fromPartial(e)) || []; + message.extension = object.extension?.map((e) => FieldDescriptorProto.fromPartial(e)) || []; + message.options = (object.options !== undefined && object.options !== null) + ? FileOptions.fromPartial(object.options) + : undefined; + message.sourceCodeInfo = (object.sourceCodeInfo !== undefined && object.sourceCodeInfo !== null) + ? SourceCodeInfo.fromPartial(object.sourceCodeInfo) + : undefined; + message.syntax = object.syntax ?? ""; + message.edition = object.edition ?? 0; + return message; + }, +}; + +function createBaseDescriptorProto(): DescriptorProto { + return { + name: "", + field: [], + extension: [], + nestedType: [], + enumType: [], + extensionRange: [], + oneofDecl: [], + options: undefined, + reservedRange: [], + reservedName: [], + visibility: 0, + }; +} + +export const DescriptorProto: MessageFns = { + encode(message: DescriptorProto, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.field !== undefined && message.field.length !== 0) { + for (const v of message.field) { + FieldDescriptorProto.encode(v!, writer.uint32(18).fork()).join(); + } + } + if (message.extension !== undefined && message.extension.length !== 0) { + for (const v of message.extension) { + FieldDescriptorProto.encode(v!, writer.uint32(50).fork()).join(); + } + } + if (message.nestedType !== undefined && message.nestedType.length !== 0) { + for (const v of message.nestedType) { + DescriptorProto.encode(v!, writer.uint32(26).fork()).join(); + } + } + if (message.enumType !== undefined && message.enumType.length !== 0) { + for (const v of message.enumType) { + EnumDescriptorProto.encode(v!, writer.uint32(34).fork()).join(); + } + } + if (message.extensionRange !== undefined && message.extensionRange.length !== 0) { + for (const v of message.extensionRange) { + DescriptorProto_ExtensionRange.encode(v!, writer.uint32(42).fork()).join(); + } + } + if (message.oneofDecl !== undefined && message.oneofDecl.length !== 0) { + for (const v of message.oneofDecl) { + OneofDescriptorProto.encode(v!, writer.uint32(66).fork()).join(); + } + } + if (message.options !== undefined) { + MessageOptions.encode(message.options, writer.uint32(58).fork()).join(); + } + if (message.reservedRange !== undefined && message.reservedRange.length !== 0) { + for (const v of message.reservedRange) { + DescriptorProto_ReservedRange.encode(v!, writer.uint32(74).fork()).join(); + } + } + if (message.reservedName !== undefined && message.reservedName.length !== 0) { + for (const v of message.reservedName) { + writer.uint32(82).string(v!); + } + } + if (message.visibility !== undefined && message.visibility !== 0) { + writer.uint32(88).int32(message.visibility); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): DescriptorProto { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseDescriptorProto(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + const el = FieldDescriptorProto.decode(reader, reader.uint32()); + if (el !== undefined) { + message.field!.push(el); + } + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + const el = FieldDescriptorProto.decode(reader, reader.uint32()); + if (el !== undefined) { + message.extension!.push(el); + } + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + const el = DescriptorProto.decode(reader, reader.uint32()); + if (el !== undefined) { + message.nestedType!.push(el); + } + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + const el = EnumDescriptorProto.decode(reader, reader.uint32()); + if (el !== undefined) { + message.enumType!.push(el); + } + continue; + } + case 5: { + if (tag !== 42) { + break; + } + + const el = DescriptorProto_ExtensionRange.decode(reader, reader.uint32()); + if (el !== undefined) { + message.extensionRange!.push(el); + } + continue; + } + case 8: { + if (tag !== 66) { + break; + } + + const el = OneofDescriptorProto.decode(reader, reader.uint32()); + if (el !== undefined) { + message.oneofDecl!.push(el); + } + continue; + } + case 7: { + if (tag !== 58) { + break; + } + + message.options = MessageOptions.decode(reader, reader.uint32()); + continue; + } + case 9: { + if (tag !== 74) { + break; + } + + const el = DescriptorProto_ReservedRange.decode(reader, reader.uint32()); + if (el !== undefined) { + message.reservedRange!.push(el); + } + continue; + } + case 10: { + if (tag !== 82) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.reservedName!.push(el); + } + continue; + } + case 11: { + if (tag !== 88) { + break; + } + + message.visibility = reader.int32() as any; + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): DescriptorProto { + return { + name: isSet(object.name) ? globalThis.String(object.name) : "", + field: globalThis.Array.isArray(object?.field) + ? object.field.map((e: any) => FieldDescriptorProto.fromJSON(e)) + : [], + extension: globalThis.Array.isArray(object?.extension) + ? object.extension.map((e: any) => FieldDescriptorProto.fromJSON(e)) + : [], + nestedType: globalThis.Array.isArray(object?.nestedType) + ? object.nestedType.map((e: any) => DescriptorProto.fromJSON(e)) + : globalThis.Array.isArray(object?.nested_type) + ? object.nested_type.map((e: any) => DescriptorProto.fromJSON(e)) + : [], + enumType: globalThis.Array.isArray(object?.enumType) + ? object.enumType.map((e: any) => EnumDescriptorProto.fromJSON(e)) + : globalThis.Array.isArray(object?.enum_type) + ? object.enum_type.map((e: any) => EnumDescriptorProto.fromJSON(e)) + : [], + extensionRange: globalThis.Array.isArray(object?.extensionRange) + ? object.extensionRange.map((e: any) => DescriptorProto_ExtensionRange.fromJSON(e)) + : globalThis.Array.isArray(object?.extension_range) + ? object.extension_range.map((e: any) => DescriptorProto_ExtensionRange.fromJSON(e)) + : [], + oneofDecl: globalThis.Array.isArray(object?.oneofDecl) + ? object.oneofDecl.map((e: any) => OneofDescriptorProto.fromJSON(e)) + : globalThis.Array.isArray(object?.oneof_decl) + ? object.oneof_decl.map((e: any) => OneofDescriptorProto.fromJSON(e)) + : [], + options: isSet(object.options) ? MessageOptions.fromJSON(object.options) : undefined, + reservedRange: globalThis.Array.isArray(object?.reservedRange) + ? object.reservedRange.map((e: any) => DescriptorProto_ReservedRange.fromJSON(e)) + : globalThis.Array.isArray(object?.reserved_range) + ? object.reserved_range.map((e: any) => DescriptorProto_ReservedRange.fromJSON(e)) + : [], + reservedName: globalThis.Array.isArray(object?.reservedName) + ? object.reservedName.map((e: any) => globalThis.String(e)) + : globalThis.Array.isArray(object?.reserved_name) + ? object.reserved_name.map((e: any) => globalThis.String(e)) + : [], + visibility: isSet(object.visibility) ? symbolVisibilityFromJSON(object.visibility) : 0, + }; + }, + + toJSON(message: DescriptorProto): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.field?.length) { + obj.field = message.field.map((e) => FieldDescriptorProto.toJSON(e)); + } + if (message.extension?.length) { + obj.extension = message.extension.map((e) => FieldDescriptorProto.toJSON(e)); + } + if (message.nestedType?.length) { + obj.nestedType = message.nestedType.map((e) => DescriptorProto.toJSON(e)); + } + if (message.enumType?.length) { + obj.enumType = message.enumType.map((e) => EnumDescriptorProto.toJSON(e)); + } + if (message.extensionRange?.length) { + obj.extensionRange = message.extensionRange.map((e) => DescriptorProto_ExtensionRange.toJSON(e)); + } + if (message.oneofDecl?.length) { + obj.oneofDecl = message.oneofDecl.map((e) => OneofDescriptorProto.toJSON(e)); + } + if (message.options !== undefined) { + obj.options = MessageOptions.toJSON(message.options); + } + if (message.reservedRange?.length) { + obj.reservedRange = message.reservedRange.map((e) => DescriptorProto_ReservedRange.toJSON(e)); + } + if (message.reservedName?.length) { + obj.reservedName = message.reservedName; + } + if (message.visibility !== undefined && message.visibility !== 0) { + obj.visibility = symbolVisibilityToJSON(message.visibility); + } + return obj; + }, + + create(base?: DeepPartial): DescriptorProto { + return DescriptorProto.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): DescriptorProto { + const message = createBaseDescriptorProto(); + message.name = object.name ?? ""; + message.field = object.field?.map((e) => FieldDescriptorProto.fromPartial(e)) || []; + message.extension = object.extension?.map((e) => FieldDescriptorProto.fromPartial(e)) || []; + message.nestedType = object.nestedType?.map((e) => DescriptorProto.fromPartial(e)) || []; + message.enumType = object.enumType?.map((e) => EnumDescriptorProto.fromPartial(e)) || []; + message.extensionRange = object.extensionRange?.map((e) => DescriptorProto_ExtensionRange.fromPartial(e)) || []; + message.oneofDecl = object.oneofDecl?.map((e) => OneofDescriptorProto.fromPartial(e)) || []; + message.options = (object.options !== undefined && object.options !== null) + ? MessageOptions.fromPartial(object.options) + : undefined; + message.reservedRange = object.reservedRange?.map((e) => DescriptorProto_ReservedRange.fromPartial(e)) || []; + message.reservedName = object.reservedName?.map((e) => e) || []; + message.visibility = object.visibility ?? 0; + return message; + }, +}; + +function createBaseDescriptorProto_ExtensionRange(): DescriptorProto_ExtensionRange { + return { start: 0, end: 0, options: undefined }; +} + +export const DescriptorProto_ExtensionRange: MessageFns = { + encode(message: DescriptorProto_ExtensionRange, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.start !== undefined && message.start !== 0) { + writer.uint32(8).int32(message.start); + } + if (message.end !== undefined && message.end !== 0) { + writer.uint32(16).int32(message.end); + } + if (message.options !== undefined) { + ExtensionRangeOptions.encode(message.options, writer.uint32(26).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): DescriptorProto_ExtensionRange { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseDescriptorProto_ExtensionRange(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.start = reader.int32(); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.end = reader.int32(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.options = ExtensionRangeOptions.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): DescriptorProto_ExtensionRange { + return { + start: isSet(object.start) ? globalThis.Number(object.start) : 0, + end: isSet(object.end) ? globalThis.Number(object.end) : 0, + options: isSet(object.options) ? ExtensionRangeOptions.fromJSON(object.options) : undefined, + }; + }, + + toJSON(message: DescriptorProto_ExtensionRange): unknown { + const obj: any = {}; + if (message.start !== undefined && message.start !== 0) { + obj.start = Math.round(message.start); + } + if (message.end !== undefined && message.end !== 0) { + obj.end = Math.round(message.end); + } + if (message.options !== undefined) { + obj.options = ExtensionRangeOptions.toJSON(message.options); + } + return obj; + }, + + create(base?: DeepPartial): DescriptorProto_ExtensionRange { + return DescriptorProto_ExtensionRange.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): DescriptorProto_ExtensionRange { + const message = createBaseDescriptorProto_ExtensionRange(); + message.start = object.start ?? 0; + message.end = object.end ?? 0; + message.options = (object.options !== undefined && object.options !== null) + ? ExtensionRangeOptions.fromPartial(object.options) + : undefined; + return message; + }, +}; + +function createBaseDescriptorProto_ReservedRange(): DescriptorProto_ReservedRange { + return { start: 0, end: 0 }; +} + +export const DescriptorProto_ReservedRange: MessageFns = { + encode(message: DescriptorProto_ReservedRange, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.start !== undefined && message.start !== 0) { + writer.uint32(8).int32(message.start); + } + if (message.end !== undefined && message.end !== 0) { + writer.uint32(16).int32(message.end); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): DescriptorProto_ReservedRange { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseDescriptorProto_ReservedRange(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.start = reader.int32(); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.end = reader.int32(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): DescriptorProto_ReservedRange { + return { + start: isSet(object.start) ? globalThis.Number(object.start) : 0, + end: isSet(object.end) ? globalThis.Number(object.end) : 0, + }; + }, + + toJSON(message: DescriptorProto_ReservedRange): unknown { + const obj: any = {}; + if (message.start !== undefined && message.start !== 0) { + obj.start = Math.round(message.start); + } + if (message.end !== undefined && message.end !== 0) { + obj.end = Math.round(message.end); + } + return obj; + }, + + create(base?: DeepPartial): DescriptorProto_ReservedRange { + return DescriptorProto_ReservedRange.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): DescriptorProto_ReservedRange { + const message = createBaseDescriptorProto_ReservedRange(); + message.start = object.start ?? 0; + message.end = object.end ?? 0; + return message; + }, +}; + +function createBaseExtensionRangeOptions(): ExtensionRangeOptions { + return { uninterpretedOption: [], declaration: [], features: undefined, verification: 1 }; +} + +export const ExtensionRangeOptions: MessageFns = { + encode(message: ExtensionRangeOptions, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.uninterpretedOption !== undefined && message.uninterpretedOption.length !== 0) { + for (const v of message.uninterpretedOption) { + UninterpretedOption.encode(v!, writer.uint32(7994).fork()).join(); + } + } + if (message.declaration !== undefined && message.declaration.length !== 0) { + for (const v of message.declaration) { + ExtensionRangeOptions_Declaration.encode(v!, writer.uint32(18).fork()).join(); + } + } + if (message.features !== undefined) { + FeatureSet.encode(message.features, writer.uint32(402).fork()).join(); + } + if (message.verification !== undefined && message.verification !== 1) { + writer.uint32(24).int32(message.verification); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): ExtensionRangeOptions { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseExtensionRangeOptions(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 999: { + if (tag !== 7994) { + break; + } + + const el = UninterpretedOption.decode(reader, reader.uint32()); + if (el !== undefined) { + message.uninterpretedOption!.push(el); + } + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + const el = ExtensionRangeOptions_Declaration.decode(reader, reader.uint32()); + if (el !== undefined) { + message.declaration!.push(el); + } + continue; + } + case 50: { + if (tag !== 402) { + break; + } + + message.features = FeatureSet.decode(reader, reader.uint32()); + continue; + } + case 3: { + if (tag !== 24) { + break; + } + + message.verification = reader.int32() as any; + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): ExtensionRangeOptions { + return { + uninterpretedOption: globalThis.Array.isArray(object?.uninterpretedOption) + ? object.uninterpretedOption.map((e: any) => UninterpretedOption.fromJSON(e)) + : globalThis.Array.isArray(object?.uninterpreted_option) + ? object.uninterpreted_option.map((e: any) => UninterpretedOption.fromJSON(e)) + : [], + declaration: globalThis.Array.isArray(object?.declaration) + ? object.declaration.map((e: any) => ExtensionRangeOptions_Declaration.fromJSON(e)) + : [], + features: isSet(object.features) ? FeatureSet.fromJSON(object.features) : undefined, + verification: isSet(object.verification) + ? extensionRangeOptions_VerificationStateFromJSON(object.verification) + : 1, + }; + }, + + toJSON(message: ExtensionRangeOptions): unknown { + const obj: any = {}; + if (message.uninterpretedOption?.length) { + obj.uninterpretedOption = message.uninterpretedOption.map((e) => UninterpretedOption.toJSON(e)); + } + if (message.declaration?.length) { + obj.declaration = message.declaration.map((e) => ExtensionRangeOptions_Declaration.toJSON(e)); + } + if (message.features !== undefined) { + obj.features = FeatureSet.toJSON(message.features); + } + if (message.verification !== undefined && message.verification !== 1) { + obj.verification = extensionRangeOptions_VerificationStateToJSON(message.verification); + } + return obj; + }, + + create(base?: DeepPartial): ExtensionRangeOptions { + return ExtensionRangeOptions.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): ExtensionRangeOptions { + const message = createBaseExtensionRangeOptions(); + message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || []; + message.declaration = object.declaration?.map((e) => ExtensionRangeOptions_Declaration.fromPartial(e)) || []; + message.features = (object.features !== undefined && object.features !== null) + ? FeatureSet.fromPartial(object.features) + : undefined; + message.verification = object.verification ?? 1; + return message; + }, +}; + +function createBaseExtensionRangeOptions_Declaration(): ExtensionRangeOptions_Declaration { + return { number: 0, fullName: "", type: "", reserved: false, repeated: false }; +} + +export const ExtensionRangeOptions_Declaration: MessageFns = { + encode(message: ExtensionRangeOptions_Declaration, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.number !== undefined && message.number !== 0) { + writer.uint32(8).int32(message.number); + } + if (message.fullName !== undefined && message.fullName !== "") { + writer.uint32(18).string(message.fullName); + } + if (message.type !== undefined && message.type !== "") { + writer.uint32(26).string(message.type); + } + if (message.reserved !== undefined && message.reserved !== false) { + writer.uint32(40).bool(message.reserved); + } + if (message.repeated !== undefined && message.repeated !== false) { + writer.uint32(48).bool(message.repeated); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): ExtensionRangeOptions_Declaration { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseExtensionRangeOptions_Declaration(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.number = reader.int32(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.fullName = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.type = reader.string(); + continue; + } + case 5: { + if (tag !== 40) { + break; + } + + message.reserved = reader.bool(); + continue; + } + case 6: { + if (tag !== 48) { + break; + } + + message.repeated = reader.bool(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): ExtensionRangeOptions_Declaration { + return { + number: isSet(object.number) ? globalThis.Number(object.number) : 0, + fullName: isSet(object.fullName) + ? globalThis.String(object.fullName) + : isSet(object.full_name) + ? globalThis.String(object.full_name) + : "", + type: isSet(object.type) ? globalThis.String(object.type) : "", + reserved: isSet(object.reserved) ? globalThis.Boolean(object.reserved) : false, + repeated: isSet(object.repeated) ? globalThis.Boolean(object.repeated) : false, + }; + }, + + toJSON(message: ExtensionRangeOptions_Declaration): unknown { + const obj: any = {}; + if (message.number !== undefined && message.number !== 0) { + obj.number = Math.round(message.number); + } + if (message.fullName !== undefined && message.fullName !== "") { + obj.fullName = message.fullName; + } + if (message.type !== undefined && message.type !== "") { + obj.type = message.type; + } + if (message.reserved !== undefined && message.reserved !== false) { + obj.reserved = message.reserved; + } + if (message.repeated !== undefined && message.repeated !== false) { + obj.repeated = message.repeated; + } + return obj; + }, + + create(base?: DeepPartial): ExtensionRangeOptions_Declaration { + return ExtensionRangeOptions_Declaration.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): ExtensionRangeOptions_Declaration { + const message = createBaseExtensionRangeOptions_Declaration(); + message.number = object.number ?? 0; + message.fullName = object.fullName ?? ""; + message.type = object.type ?? ""; + message.reserved = object.reserved ?? false; + message.repeated = object.repeated ?? false; + return message; + }, +}; + +function createBaseFieldDescriptorProto(): FieldDescriptorProto { + return { + name: "", + number: 0, + label: 1, + type: 1, + typeName: "", + extendee: "", + defaultValue: "", + oneofIndex: 0, + jsonName: "", + options: undefined, + proto3Optional: false, + }; +} + +export const FieldDescriptorProto: MessageFns = { + encode(message: FieldDescriptorProto, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.number !== undefined && message.number !== 0) { + writer.uint32(24).int32(message.number); + } + if (message.label !== undefined && message.label !== 1) { + writer.uint32(32).int32(message.label); + } + if (message.type !== undefined && message.type !== 1) { + writer.uint32(40).int32(message.type); + } + if (message.typeName !== undefined && message.typeName !== "") { + writer.uint32(50).string(message.typeName); + } + if (message.extendee !== undefined && message.extendee !== "") { + writer.uint32(18).string(message.extendee); + } + if (message.defaultValue !== undefined && message.defaultValue !== "") { + writer.uint32(58).string(message.defaultValue); + } + if (message.oneofIndex !== undefined && message.oneofIndex !== 0) { + writer.uint32(72).int32(message.oneofIndex); + } + if (message.jsonName !== undefined && message.jsonName !== "") { + writer.uint32(82).string(message.jsonName); + } + if (message.options !== undefined) { + FieldOptions.encode(message.options, writer.uint32(66).fork()).join(); + } + if (message.proto3Optional !== undefined && message.proto3Optional !== false) { + writer.uint32(136).bool(message.proto3Optional); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): FieldDescriptorProto { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFieldDescriptorProto(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + case 3: { + if (tag !== 24) { + break; + } + + message.number = reader.int32(); + continue; + } + case 4: { + if (tag !== 32) { + break; + } + + message.label = reader.int32() as any; + continue; + } + case 5: { + if (tag !== 40) { + break; + } + + message.type = reader.int32() as any; + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + message.typeName = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.extendee = reader.string(); + continue; + } + case 7: { + if (tag !== 58) { + break; + } + + message.defaultValue = reader.string(); + continue; + } + case 9: { + if (tag !== 72) { + break; + } + + message.oneofIndex = reader.int32(); + continue; + } + case 10: { + if (tag !== 82) { + break; + } + + message.jsonName = reader.string(); + continue; + } + case 8: { + if (tag !== 66) { + break; + } + + message.options = FieldOptions.decode(reader, reader.uint32()); + continue; + } + case 17: { + if (tag !== 136) { + break; + } + + message.proto3Optional = reader.bool(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): FieldDescriptorProto { + return { + name: isSet(object.name) ? globalThis.String(object.name) : "", + number: isSet(object.number) ? globalThis.Number(object.number) : 0, + label: isSet(object.label) ? fieldDescriptorProto_LabelFromJSON(object.label) : 1, + type: isSet(object.type) ? fieldDescriptorProto_TypeFromJSON(object.type) : 1, + typeName: isSet(object.typeName) + ? globalThis.String(object.typeName) + : isSet(object.type_name) + ? globalThis.String(object.type_name) + : "", + extendee: isSet(object.extendee) ? globalThis.String(object.extendee) : "", + defaultValue: isSet(object.defaultValue) + ? globalThis.String(object.defaultValue) + : isSet(object.default_value) + ? globalThis.String(object.default_value) + : "", + oneofIndex: isSet(object.oneofIndex) + ? globalThis.Number(object.oneofIndex) + : isSet(object.oneof_index) + ? globalThis.Number(object.oneof_index) + : 0, + jsonName: isSet(object.jsonName) + ? globalThis.String(object.jsonName) + : isSet(object.json_name) + ? globalThis.String(object.json_name) + : "", + options: isSet(object.options) ? FieldOptions.fromJSON(object.options) : undefined, + proto3Optional: isSet(object.proto3Optional) + ? globalThis.Boolean(object.proto3Optional) + : isSet(object.proto3_optional) + ? globalThis.Boolean(object.proto3_optional) + : false, + }; + }, + + toJSON(message: FieldDescriptorProto): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.number !== undefined && message.number !== 0) { + obj.number = Math.round(message.number); + } + if (message.label !== undefined && message.label !== 1) { + obj.label = fieldDescriptorProto_LabelToJSON(message.label); + } + if (message.type !== undefined && message.type !== 1) { + obj.type = fieldDescriptorProto_TypeToJSON(message.type); + } + if (message.typeName !== undefined && message.typeName !== "") { + obj.typeName = message.typeName; + } + if (message.extendee !== undefined && message.extendee !== "") { + obj.extendee = message.extendee; + } + if (message.defaultValue !== undefined && message.defaultValue !== "") { + obj.defaultValue = message.defaultValue; + } + if (message.oneofIndex !== undefined && message.oneofIndex !== 0) { + obj.oneofIndex = Math.round(message.oneofIndex); + } + if (message.jsonName !== undefined && message.jsonName !== "") { + obj.jsonName = message.jsonName; + } + if (message.options !== undefined) { + obj.options = FieldOptions.toJSON(message.options); + } + if (message.proto3Optional !== undefined && message.proto3Optional !== false) { + obj.proto3Optional = message.proto3Optional; + } + return obj; + }, + + create(base?: DeepPartial): FieldDescriptorProto { + return FieldDescriptorProto.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): FieldDescriptorProto { + const message = createBaseFieldDescriptorProto(); + message.name = object.name ?? ""; + message.number = object.number ?? 0; + message.label = object.label ?? 1; + message.type = object.type ?? 1; + message.typeName = object.typeName ?? ""; + message.extendee = object.extendee ?? ""; + message.defaultValue = object.defaultValue ?? ""; + message.oneofIndex = object.oneofIndex ?? 0; + message.jsonName = object.jsonName ?? ""; + message.options = (object.options !== undefined && object.options !== null) + ? FieldOptions.fromPartial(object.options) + : undefined; + message.proto3Optional = object.proto3Optional ?? false; + return message; + }, +}; + +function createBaseOneofDescriptorProto(): OneofDescriptorProto { + return { name: "", options: undefined }; +} + +export const OneofDescriptorProto: MessageFns = { + encode(message: OneofDescriptorProto, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.options !== undefined) { + OneofOptions.encode(message.options, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): OneofDescriptorProto { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseOneofDescriptorProto(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.options = OneofOptions.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): OneofDescriptorProto { + return { + name: isSet(object.name) ? globalThis.String(object.name) : "", + options: isSet(object.options) ? OneofOptions.fromJSON(object.options) : undefined, + }; + }, + + toJSON(message: OneofDescriptorProto): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.options !== undefined) { + obj.options = OneofOptions.toJSON(message.options); + } + return obj; + }, + + create(base?: DeepPartial): OneofDescriptorProto { + return OneofDescriptorProto.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): OneofDescriptorProto { + const message = createBaseOneofDescriptorProto(); + message.name = object.name ?? ""; + message.options = (object.options !== undefined && object.options !== null) + ? OneofOptions.fromPartial(object.options) + : undefined; + return message; + }, +}; + +function createBaseEnumDescriptorProto(): EnumDescriptorProto { + return { name: "", value: [], options: undefined, reservedRange: [], reservedName: [], visibility: 0 }; +} + +export const EnumDescriptorProto: MessageFns = { + encode(message: EnumDescriptorProto, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.value !== undefined && message.value.length !== 0) { + for (const v of message.value) { + EnumValueDescriptorProto.encode(v!, writer.uint32(18).fork()).join(); + } + } + if (message.options !== undefined) { + EnumOptions.encode(message.options, writer.uint32(26).fork()).join(); + } + if (message.reservedRange !== undefined && message.reservedRange.length !== 0) { + for (const v of message.reservedRange) { + EnumDescriptorProto_EnumReservedRange.encode(v!, writer.uint32(34).fork()).join(); + } + } + if (message.reservedName !== undefined && message.reservedName.length !== 0) { + for (const v of message.reservedName) { + writer.uint32(42).string(v!); + } + } + if (message.visibility !== undefined && message.visibility !== 0) { + writer.uint32(48).int32(message.visibility); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): EnumDescriptorProto { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEnumDescriptorProto(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + const el = EnumValueDescriptorProto.decode(reader, reader.uint32()); + if (el !== undefined) { + message.value!.push(el); + } + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.options = EnumOptions.decode(reader, reader.uint32()); + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + const el = EnumDescriptorProto_EnumReservedRange.decode(reader, reader.uint32()); + if (el !== undefined) { + message.reservedRange!.push(el); + } + continue; + } + case 5: { + if (tag !== 42) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.reservedName!.push(el); + } + continue; + } + case 6: { + if (tag !== 48) { + break; + } + + message.visibility = reader.int32() as any; + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): EnumDescriptorProto { + return { + name: isSet(object.name) ? globalThis.String(object.name) : "", + value: globalThis.Array.isArray(object?.value) + ? object.value.map((e: any) => EnumValueDescriptorProto.fromJSON(e)) + : [], + options: isSet(object.options) ? EnumOptions.fromJSON(object.options) : undefined, + reservedRange: globalThis.Array.isArray(object?.reservedRange) + ? object.reservedRange.map((e: any) => EnumDescriptorProto_EnumReservedRange.fromJSON(e)) + : globalThis.Array.isArray(object?.reserved_range) + ? object.reserved_range.map((e: any) => EnumDescriptorProto_EnumReservedRange.fromJSON(e)) + : [], + reservedName: globalThis.Array.isArray(object?.reservedName) + ? object.reservedName.map((e: any) => globalThis.String(e)) + : globalThis.Array.isArray(object?.reserved_name) + ? object.reserved_name.map((e: any) => globalThis.String(e)) + : [], + visibility: isSet(object.visibility) ? symbolVisibilityFromJSON(object.visibility) : 0, + }; + }, + + toJSON(message: EnumDescriptorProto): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.value?.length) { + obj.value = message.value.map((e) => EnumValueDescriptorProto.toJSON(e)); + } + if (message.options !== undefined) { + obj.options = EnumOptions.toJSON(message.options); + } + if (message.reservedRange?.length) { + obj.reservedRange = message.reservedRange.map((e) => EnumDescriptorProto_EnumReservedRange.toJSON(e)); + } + if (message.reservedName?.length) { + obj.reservedName = message.reservedName; + } + if (message.visibility !== undefined && message.visibility !== 0) { + obj.visibility = symbolVisibilityToJSON(message.visibility); + } + return obj; + }, + + create(base?: DeepPartial): EnumDescriptorProto { + return EnumDescriptorProto.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): EnumDescriptorProto { + const message = createBaseEnumDescriptorProto(); + message.name = object.name ?? ""; + message.value = object.value?.map((e) => EnumValueDescriptorProto.fromPartial(e)) || []; + message.options = (object.options !== undefined && object.options !== null) + ? EnumOptions.fromPartial(object.options) + : undefined; + message.reservedRange = object.reservedRange?.map((e) => EnumDescriptorProto_EnumReservedRange.fromPartial(e)) || + []; + message.reservedName = object.reservedName?.map((e) => e) || []; + message.visibility = object.visibility ?? 0; + return message; + }, +}; + +function createBaseEnumDescriptorProto_EnumReservedRange(): EnumDescriptorProto_EnumReservedRange { + return { start: 0, end: 0 }; +} + +export const EnumDescriptorProto_EnumReservedRange: MessageFns = { + encode(message: EnumDescriptorProto_EnumReservedRange, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.start !== undefined && message.start !== 0) { + writer.uint32(8).int32(message.start); + } + if (message.end !== undefined && message.end !== 0) { + writer.uint32(16).int32(message.end); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): EnumDescriptorProto_EnumReservedRange { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEnumDescriptorProto_EnumReservedRange(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.start = reader.int32(); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.end = reader.int32(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): EnumDescriptorProto_EnumReservedRange { + return { + start: isSet(object.start) ? globalThis.Number(object.start) : 0, + end: isSet(object.end) ? globalThis.Number(object.end) : 0, + }; + }, + + toJSON(message: EnumDescriptorProto_EnumReservedRange): unknown { + const obj: any = {}; + if (message.start !== undefined && message.start !== 0) { + obj.start = Math.round(message.start); + } + if (message.end !== undefined && message.end !== 0) { + obj.end = Math.round(message.end); + } + return obj; + }, + + create(base?: DeepPartial): EnumDescriptorProto_EnumReservedRange { + return EnumDescriptorProto_EnumReservedRange.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): EnumDescriptorProto_EnumReservedRange { + const message = createBaseEnumDescriptorProto_EnumReservedRange(); + message.start = object.start ?? 0; + message.end = object.end ?? 0; + return message; + }, +}; + +function createBaseEnumValueDescriptorProto(): EnumValueDescriptorProto { + return { name: "", number: 0, options: undefined }; +} + +export const EnumValueDescriptorProto: MessageFns = { + encode(message: EnumValueDescriptorProto, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.number !== undefined && message.number !== 0) { + writer.uint32(16).int32(message.number); + } + if (message.options !== undefined) { + EnumValueOptions.encode(message.options, writer.uint32(26).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): EnumValueDescriptorProto { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEnumValueDescriptorProto(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.number = reader.int32(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.options = EnumValueOptions.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): EnumValueDescriptorProto { + return { + name: isSet(object.name) ? globalThis.String(object.name) : "", + number: isSet(object.number) ? globalThis.Number(object.number) : 0, + options: isSet(object.options) ? EnumValueOptions.fromJSON(object.options) : undefined, + }; + }, + + toJSON(message: EnumValueDescriptorProto): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.number !== undefined && message.number !== 0) { + obj.number = Math.round(message.number); + } + if (message.options !== undefined) { + obj.options = EnumValueOptions.toJSON(message.options); + } + return obj; + }, + + create(base?: DeepPartial): EnumValueDescriptorProto { + return EnumValueDescriptorProto.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): EnumValueDescriptorProto { + const message = createBaseEnumValueDescriptorProto(); + message.name = object.name ?? ""; + message.number = object.number ?? 0; + message.options = (object.options !== undefined && object.options !== null) + ? EnumValueOptions.fromPartial(object.options) + : undefined; + return message; + }, +}; + +function createBaseServiceDescriptorProto(): ServiceDescriptorProto { + return { name: "", method: [], options: undefined }; +} + +export const ServiceDescriptorProto: MessageFns = { + encode(message: ServiceDescriptorProto, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.method !== undefined && message.method.length !== 0) { + for (const v of message.method) { + MethodDescriptorProto.encode(v!, writer.uint32(18).fork()).join(); + } + } + if (message.options !== undefined) { + ServiceOptions.encode(message.options, writer.uint32(26).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): ServiceDescriptorProto { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseServiceDescriptorProto(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + const el = MethodDescriptorProto.decode(reader, reader.uint32()); + if (el !== undefined) { + message.method!.push(el); + } + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.options = ServiceOptions.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): ServiceDescriptorProto { + return { + name: isSet(object.name) ? globalThis.String(object.name) : "", + method: globalThis.Array.isArray(object?.method) + ? object.method.map((e: any) => MethodDescriptorProto.fromJSON(e)) + : [], + options: isSet(object.options) ? ServiceOptions.fromJSON(object.options) : undefined, + }; + }, + + toJSON(message: ServiceDescriptorProto): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.method?.length) { + obj.method = message.method.map((e) => MethodDescriptorProto.toJSON(e)); + } + if (message.options !== undefined) { + obj.options = ServiceOptions.toJSON(message.options); + } + return obj; + }, + + create(base?: DeepPartial): ServiceDescriptorProto { + return ServiceDescriptorProto.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): ServiceDescriptorProto { + const message = createBaseServiceDescriptorProto(); + message.name = object.name ?? ""; + message.method = object.method?.map((e) => MethodDescriptorProto.fromPartial(e)) || []; + message.options = (object.options !== undefined && object.options !== null) + ? ServiceOptions.fromPartial(object.options) + : undefined; + return message; + }, +}; + +function createBaseMethodDescriptorProto(): MethodDescriptorProto { + return { + name: "", + inputType: "", + outputType: "", + options: undefined, + clientStreaming: false, + serverStreaming: false, + }; +} + +export const MethodDescriptorProto: MessageFns = { + encode(message: MethodDescriptorProto, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.inputType !== undefined && message.inputType !== "") { + writer.uint32(18).string(message.inputType); + } + if (message.outputType !== undefined && message.outputType !== "") { + writer.uint32(26).string(message.outputType); + } + if (message.options !== undefined) { + MethodOptions.encode(message.options, writer.uint32(34).fork()).join(); + } + if (message.clientStreaming !== undefined && message.clientStreaming !== false) { + writer.uint32(40).bool(message.clientStreaming); + } + if (message.serverStreaming !== undefined && message.serverStreaming !== false) { + writer.uint32(48).bool(message.serverStreaming); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): MethodDescriptorProto { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseMethodDescriptorProto(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.inputType = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.outputType = reader.string(); + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + message.options = MethodOptions.decode(reader, reader.uint32()); + continue; + } + case 5: { + if (tag !== 40) { + break; + } + + message.clientStreaming = reader.bool(); + continue; + } + case 6: { + if (tag !== 48) { + break; + } + + message.serverStreaming = reader.bool(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): MethodDescriptorProto { + return { + name: isSet(object.name) ? globalThis.String(object.name) : "", + inputType: isSet(object.inputType) + ? globalThis.String(object.inputType) + : isSet(object.input_type) + ? globalThis.String(object.input_type) + : "", + outputType: isSet(object.outputType) + ? globalThis.String(object.outputType) + : isSet(object.output_type) + ? globalThis.String(object.output_type) + : "", + options: isSet(object.options) ? MethodOptions.fromJSON(object.options) : undefined, + clientStreaming: isSet(object.clientStreaming) + ? globalThis.Boolean(object.clientStreaming) + : isSet(object.client_streaming) + ? globalThis.Boolean(object.client_streaming) + : false, + serverStreaming: isSet(object.serverStreaming) + ? globalThis.Boolean(object.serverStreaming) + : isSet(object.server_streaming) + ? globalThis.Boolean(object.server_streaming) + : false, + }; + }, + + toJSON(message: MethodDescriptorProto): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.inputType !== undefined && message.inputType !== "") { + obj.inputType = message.inputType; + } + if (message.outputType !== undefined && message.outputType !== "") { + obj.outputType = message.outputType; + } + if (message.options !== undefined) { + obj.options = MethodOptions.toJSON(message.options); + } + if (message.clientStreaming !== undefined && message.clientStreaming !== false) { + obj.clientStreaming = message.clientStreaming; + } + if (message.serverStreaming !== undefined && message.serverStreaming !== false) { + obj.serverStreaming = message.serverStreaming; + } + return obj; + }, + + create(base?: DeepPartial): MethodDescriptorProto { + return MethodDescriptorProto.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): MethodDescriptorProto { + const message = createBaseMethodDescriptorProto(); + message.name = object.name ?? ""; + message.inputType = object.inputType ?? ""; + message.outputType = object.outputType ?? ""; + message.options = (object.options !== undefined && object.options !== null) + ? MethodOptions.fromPartial(object.options) + : undefined; + message.clientStreaming = object.clientStreaming ?? false; + message.serverStreaming = object.serverStreaming ?? false; + return message; + }, +}; + +function createBaseFileOptions(): FileOptions { + return { + javaPackage: "", + javaOuterClassname: "", + javaMultipleFiles: false, + javaGenerateEqualsAndHash: false, + javaStringCheckUtf8: false, + optimizeFor: 1, + goPackage: "", + ccGenericServices: false, + javaGenericServices: false, + pyGenericServices: false, + deprecated: false, + ccEnableArenas: true, + objcClassPrefix: "", + csharpNamespace: "", + swiftPrefix: "", + phpClassPrefix: "", + phpNamespace: "", + phpMetadataNamespace: "", + rubyPackage: "", + features: undefined, + uninterpretedOption: [], + }; +} + +export const FileOptions: MessageFns = { + encode(message: FileOptions, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.javaPackage !== undefined && message.javaPackage !== "") { + writer.uint32(10).string(message.javaPackage); + } + if (message.javaOuterClassname !== undefined && message.javaOuterClassname !== "") { + writer.uint32(66).string(message.javaOuterClassname); + } + if (message.javaMultipleFiles !== undefined && message.javaMultipleFiles !== false) { + writer.uint32(80).bool(message.javaMultipleFiles); + } + if (message.javaGenerateEqualsAndHash !== undefined && message.javaGenerateEqualsAndHash !== false) { + writer.uint32(160).bool(message.javaGenerateEqualsAndHash); + } + if (message.javaStringCheckUtf8 !== undefined && message.javaStringCheckUtf8 !== false) { + writer.uint32(216).bool(message.javaStringCheckUtf8); + } + if (message.optimizeFor !== undefined && message.optimizeFor !== 1) { + writer.uint32(72).int32(message.optimizeFor); + } + if (message.goPackage !== undefined && message.goPackage !== "") { + writer.uint32(90).string(message.goPackage); + } + if (message.ccGenericServices !== undefined && message.ccGenericServices !== false) { + writer.uint32(128).bool(message.ccGenericServices); + } + if (message.javaGenericServices !== undefined && message.javaGenericServices !== false) { + writer.uint32(136).bool(message.javaGenericServices); + } + if (message.pyGenericServices !== undefined && message.pyGenericServices !== false) { + writer.uint32(144).bool(message.pyGenericServices); + } + if (message.deprecated !== undefined && message.deprecated !== false) { + writer.uint32(184).bool(message.deprecated); + } + if (message.ccEnableArenas !== undefined && message.ccEnableArenas !== true) { + writer.uint32(248).bool(message.ccEnableArenas); + } + if (message.objcClassPrefix !== undefined && message.objcClassPrefix !== "") { + writer.uint32(290).string(message.objcClassPrefix); + } + if (message.csharpNamespace !== undefined && message.csharpNamespace !== "") { + writer.uint32(298).string(message.csharpNamespace); + } + if (message.swiftPrefix !== undefined && message.swiftPrefix !== "") { + writer.uint32(314).string(message.swiftPrefix); + } + if (message.phpClassPrefix !== undefined && message.phpClassPrefix !== "") { + writer.uint32(322).string(message.phpClassPrefix); + } + if (message.phpNamespace !== undefined && message.phpNamespace !== "") { + writer.uint32(330).string(message.phpNamespace); + } + if (message.phpMetadataNamespace !== undefined && message.phpMetadataNamespace !== "") { + writer.uint32(354).string(message.phpMetadataNamespace); + } + if (message.rubyPackage !== undefined && message.rubyPackage !== "") { + writer.uint32(362).string(message.rubyPackage); + } + if (message.features !== undefined) { + FeatureSet.encode(message.features, writer.uint32(402).fork()).join(); + } + if (message.uninterpretedOption !== undefined && message.uninterpretedOption.length !== 0) { + for (const v of message.uninterpretedOption) { + UninterpretedOption.encode(v!, writer.uint32(7994).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): FileOptions { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFileOptions(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.javaPackage = reader.string(); + continue; + } + case 8: { + if (tag !== 66) { + break; + } + + message.javaOuterClassname = reader.string(); + continue; + } + case 10: { + if (tag !== 80) { + break; + } + + message.javaMultipleFiles = reader.bool(); + continue; + } + case 20: { + if (tag !== 160) { + break; + } + + message.javaGenerateEqualsAndHash = reader.bool(); + continue; + } + case 27: { + if (tag !== 216) { + break; + } + + message.javaStringCheckUtf8 = reader.bool(); + continue; + } + case 9: { + if (tag !== 72) { + break; + } + + message.optimizeFor = reader.int32() as any; + continue; + } + case 11: { + if (tag !== 90) { + break; + } + + message.goPackage = reader.string(); + continue; + } + case 16: { + if (tag !== 128) { + break; + } + + message.ccGenericServices = reader.bool(); + continue; + } + case 17: { + if (tag !== 136) { + break; + } + + message.javaGenericServices = reader.bool(); + continue; + } + case 18: { + if (tag !== 144) { + break; + } + + message.pyGenericServices = reader.bool(); + continue; + } + case 23: { + if (tag !== 184) { + break; + } + + message.deprecated = reader.bool(); + continue; + } + case 31: { + if (tag !== 248) { + break; + } + + message.ccEnableArenas = reader.bool(); + continue; + } + case 36: { + if (tag !== 290) { + break; + } + + message.objcClassPrefix = reader.string(); + continue; + } + case 37: { + if (tag !== 298) { + break; + } + + message.csharpNamespace = reader.string(); + continue; + } + case 39: { + if (tag !== 314) { + break; + } + + message.swiftPrefix = reader.string(); + continue; + } + case 40: { + if (tag !== 322) { + break; + } + + message.phpClassPrefix = reader.string(); + continue; + } + case 41: { + if (tag !== 330) { + break; + } + + message.phpNamespace = reader.string(); + continue; + } + case 44: { + if (tag !== 354) { + break; + } + + message.phpMetadataNamespace = reader.string(); + continue; + } + case 45: { + if (tag !== 362) { + break; + } + + message.rubyPackage = reader.string(); + continue; + } + case 50: { + if (tag !== 402) { + break; + } + + message.features = FeatureSet.decode(reader, reader.uint32()); + continue; + } + case 999: { + if (tag !== 7994) { + break; + } + + const el = UninterpretedOption.decode(reader, reader.uint32()); + if (el !== undefined) { + message.uninterpretedOption!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): FileOptions { + return { + javaPackage: isSet(object.javaPackage) + ? globalThis.String(object.javaPackage) + : isSet(object.java_package) + ? globalThis.String(object.java_package) + : "", + javaOuterClassname: isSet(object.javaOuterClassname) + ? globalThis.String(object.javaOuterClassname) + : isSet(object.java_outer_classname) + ? globalThis.String(object.java_outer_classname) + : "", + javaMultipleFiles: isSet(object.javaMultipleFiles) + ? globalThis.Boolean(object.javaMultipleFiles) + : isSet(object.java_multiple_files) + ? globalThis.Boolean(object.java_multiple_files) + : false, + javaGenerateEqualsAndHash: isSet(object.javaGenerateEqualsAndHash) + ? globalThis.Boolean(object.javaGenerateEqualsAndHash) + : isSet(object.java_generate_equals_and_hash) + ? globalThis.Boolean(object.java_generate_equals_and_hash) + : false, + javaStringCheckUtf8: isSet(object.javaStringCheckUtf8) + ? globalThis.Boolean(object.javaStringCheckUtf8) + : isSet(object.java_string_check_utf8) + ? globalThis.Boolean(object.java_string_check_utf8) + : false, + optimizeFor: isSet(object.optimizeFor) + ? fileOptions_OptimizeModeFromJSON(object.optimizeFor) + : isSet(object.optimize_for) + ? fileOptions_OptimizeModeFromJSON(object.optimize_for) + : 1, + goPackage: isSet(object.goPackage) + ? globalThis.String(object.goPackage) + : isSet(object.go_package) + ? globalThis.String(object.go_package) + : "", + ccGenericServices: isSet(object.ccGenericServices) + ? globalThis.Boolean(object.ccGenericServices) + : isSet(object.cc_generic_services) + ? globalThis.Boolean(object.cc_generic_services) + : false, + javaGenericServices: isSet(object.javaGenericServices) + ? globalThis.Boolean(object.javaGenericServices) + : isSet(object.java_generic_services) + ? globalThis.Boolean(object.java_generic_services) + : false, + pyGenericServices: isSet(object.pyGenericServices) + ? globalThis.Boolean(object.pyGenericServices) + : isSet(object.py_generic_services) + ? globalThis.Boolean(object.py_generic_services) + : false, + deprecated: isSet(object.deprecated) ? globalThis.Boolean(object.deprecated) : false, + ccEnableArenas: isSet(object.ccEnableArenas) + ? globalThis.Boolean(object.ccEnableArenas) + : isSet(object.cc_enable_arenas) + ? globalThis.Boolean(object.cc_enable_arenas) + : true, + objcClassPrefix: isSet(object.objcClassPrefix) + ? globalThis.String(object.objcClassPrefix) + : isSet(object.objc_class_prefix) + ? globalThis.String(object.objc_class_prefix) + : "", + csharpNamespace: isSet(object.csharpNamespace) + ? globalThis.String(object.csharpNamespace) + : isSet(object.csharp_namespace) + ? globalThis.String(object.csharp_namespace) + : "", + swiftPrefix: isSet(object.swiftPrefix) + ? globalThis.String(object.swiftPrefix) + : isSet(object.swift_prefix) + ? globalThis.String(object.swift_prefix) + : "", + phpClassPrefix: isSet(object.phpClassPrefix) + ? globalThis.String(object.phpClassPrefix) + : isSet(object.php_class_prefix) + ? globalThis.String(object.php_class_prefix) + : "", + phpNamespace: isSet(object.phpNamespace) + ? globalThis.String(object.phpNamespace) + : isSet(object.php_namespace) + ? globalThis.String(object.php_namespace) + : "", + phpMetadataNamespace: isSet(object.phpMetadataNamespace) + ? globalThis.String(object.phpMetadataNamespace) + : isSet(object.php_metadata_namespace) + ? globalThis.String(object.php_metadata_namespace) + : "", + rubyPackage: isSet(object.rubyPackage) + ? globalThis.String(object.rubyPackage) + : isSet(object.ruby_package) + ? globalThis.String(object.ruby_package) + : "", + features: isSet(object.features) ? FeatureSet.fromJSON(object.features) : undefined, + uninterpretedOption: globalThis.Array.isArray(object?.uninterpretedOption) + ? object.uninterpretedOption.map((e: any) => UninterpretedOption.fromJSON(e)) + : globalThis.Array.isArray(object?.uninterpreted_option) + ? object.uninterpreted_option.map((e: any) => UninterpretedOption.fromJSON(e)) + : [], + }; + }, + + toJSON(message: FileOptions): unknown { + const obj: any = {}; + if (message.javaPackage !== undefined && message.javaPackage !== "") { + obj.javaPackage = message.javaPackage; + } + if (message.javaOuterClassname !== undefined && message.javaOuterClassname !== "") { + obj.javaOuterClassname = message.javaOuterClassname; + } + if (message.javaMultipleFiles !== undefined && message.javaMultipleFiles !== false) { + obj.javaMultipleFiles = message.javaMultipleFiles; + } + if (message.javaGenerateEqualsAndHash !== undefined && message.javaGenerateEqualsAndHash !== false) { + obj.javaGenerateEqualsAndHash = message.javaGenerateEqualsAndHash; + } + if (message.javaStringCheckUtf8 !== undefined && message.javaStringCheckUtf8 !== false) { + obj.javaStringCheckUtf8 = message.javaStringCheckUtf8; + } + if (message.optimizeFor !== undefined && message.optimizeFor !== 1) { + obj.optimizeFor = fileOptions_OptimizeModeToJSON(message.optimizeFor); + } + if (message.goPackage !== undefined && message.goPackage !== "") { + obj.goPackage = message.goPackage; + } + if (message.ccGenericServices !== undefined && message.ccGenericServices !== false) { + obj.ccGenericServices = message.ccGenericServices; + } + if (message.javaGenericServices !== undefined && message.javaGenericServices !== false) { + obj.javaGenericServices = message.javaGenericServices; + } + if (message.pyGenericServices !== undefined && message.pyGenericServices !== false) { + obj.pyGenericServices = message.pyGenericServices; + } + if (message.deprecated !== undefined && message.deprecated !== false) { + obj.deprecated = message.deprecated; + } + if (message.ccEnableArenas !== undefined && message.ccEnableArenas !== true) { + obj.ccEnableArenas = message.ccEnableArenas; + } + if (message.objcClassPrefix !== undefined && message.objcClassPrefix !== "") { + obj.objcClassPrefix = message.objcClassPrefix; + } + if (message.csharpNamespace !== undefined && message.csharpNamespace !== "") { + obj.csharpNamespace = message.csharpNamespace; + } + if (message.swiftPrefix !== undefined && message.swiftPrefix !== "") { + obj.swiftPrefix = message.swiftPrefix; + } + if (message.phpClassPrefix !== undefined && message.phpClassPrefix !== "") { + obj.phpClassPrefix = message.phpClassPrefix; + } + if (message.phpNamespace !== undefined && message.phpNamespace !== "") { + obj.phpNamespace = message.phpNamespace; + } + if (message.phpMetadataNamespace !== undefined && message.phpMetadataNamespace !== "") { + obj.phpMetadataNamespace = message.phpMetadataNamespace; + } + if (message.rubyPackage !== undefined && message.rubyPackage !== "") { + obj.rubyPackage = message.rubyPackage; + } + if (message.features !== undefined) { + obj.features = FeatureSet.toJSON(message.features); + } + if (message.uninterpretedOption?.length) { + obj.uninterpretedOption = message.uninterpretedOption.map((e) => UninterpretedOption.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): FileOptions { + return FileOptions.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): FileOptions { + const message = createBaseFileOptions(); + message.javaPackage = object.javaPackage ?? ""; + message.javaOuterClassname = object.javaOuterClassname ?? ""; + message.javaMultipleFiles = object.javaMultipleFiles ?? false; + message.javaGenerateEqualsAndHash = object.javaGenerateEqualsAndHash ?? false; + message.javaStringCheckUtf8 = object.javaStringCheckUtf8 ?? false; + message.optimizeFor = object.optimizeFor ?? 1; + message.goPackage = object.goPackage ?? ""; + message.ccGenericServices = object.ccGenericServices ?? false; + message.javaGenericServices = object.javaGenericServices ?? false; + message.pyGenericServices = object.pyGenericServices ?? false; + message.deprecated = object.deprecated ?? false; + message.ccEnableArenas = object.ccEnableArenas ?? true; + message.objcClassPrefix = object.objcClassPrefix ?? ""; + message.csharpNamespace = object.csharpNamespace ?? ""; + message.swiftPrefix = object.swiftPrefix ?? ""; + message.phpClassPrefix = object.phpClassPrefix ?? ""; + message.phpNamespace = object.phpNamespace ?? ""; + message.phpMetadataNamespace = object.phpMetadataNamespace ?? ""; + message.rubyPackage = object.rubyPackage ?? ""; + message.features = (object.features !== undefined && object.features !== null) + ? FeatureSet.fromPartial(object.features) + : undefined; + message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseMessageOptions(): MessageOptions { + return { + messageSetWireFormat: false, + noStandardDescriptorAccessor: false, + deprecated: false, + mapEntry: false, + deprecatedLegacyJsonFieldConflicts: false, + features: undefined, + uninterpretedOption: [], + }; +} + +export const MessageOptions: MessageFns = { + encode(message: MessageOptions, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.messageSetWireFormat !== undefined && message.messageSetWireFormat !== false) { + writer.uint32(8).bool(message.messageSetWireFormat); + } + if (message.noStandardDescriptorAccessor !== undefined && message.noStandardDescriptorAccessor !== false) { + writer.uint32(16).bool(message.noStandardDescriptorAccessor); + } + if (message.deprecated !== undefined && message.deprecated !== false) { + writer.uint32(24).bool(message.deprecated); + } + if (message.mapEntry !== undefined && message.mapEntry !== false) { + writer.uint32(56).bool(message.mapEntry); + } + if ( + message.deprecatedLegacyJsonFieldConflicts !== undefined && message.deprecatedLegacyJsonFieldConflicts !== false + ) { + writer.uint32(88).bool(message.deprecatedLegacyJsonFieldConflicts); + } + if (message.features !== undefined) { + FeatureSet.encode(message.features, writer.uint32(98).fork()).join(); + } + if (message.uninterpretedOption !== undefined && message.uninterpretedOption.length !== 0) { + for (const v of message.uninterpretedOption) { + UninterpretedOption.encode(v!, writer.uint32(7994).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): MessageOptions { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseMessageOptions(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.messageSetWireFormat = reader.bool(); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.noStandardDescriptorAccessor = reader.bool(); + continue; + } + case 3: { + if (tag !== 24) { + break; + } + + message.deprecated = reader.bool(); + continue; + } + case 7: { + if (tag !== 56) { + break; + } + + message.mapEntry = reader.bool(); + continue; + } + case 11: { + if (tag !== 88) { + break; + } + + message.deprecatedLegacyJsonFieldConflicts = reader.bool(); + continue; + } + case 12: { + if (tag !== 98) { + break; + } + + message.features = FeatureSet.decode(reader, reader.uint32()); + continue; + } + case 999: { + if (tag !== 7994) { + break; + } + + const el = UninterpretedOption.decode(reader, reader.uint32()); + if (el !== undefined) { + message.uninterpretedOption!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): MessageOptions { + return { + messageSetWireFormat: isSet(object.messageSetWireFormat) + ? globalThis.Boolean(object.messageSetWireFormat) + : isSet(object.message_set_wire_format) + ? globalThis.Boolean(object.message_set_wire_format) + : false, + noStandardDescriptorAccessor: isSet(object.noStandardDescriptorAccessor) + ? globalThis.Boolean(object.noStandardDescriptorAccessor) + : isSet(object.no_standard_descriptor_accessor) + ? globalThis.Boolean(object.no_standard_descriptor_accessor) + : false, + deprecated: isSet(object.deprecated) ? globalThis.Boolean(object.deprecated) : false, + mapEntry: isSet(object.mapEntry) + ? globalThis.Boolean(object.mapEntry) + : isSet(object.map_entry) + ? globalThis.Boolean(object.map_entry) + : false, + deprecatedLegacyJsonFieldConflicts: isSet(object.deprecatedLegacyJsonFieldConflicts) + ? globalThis.Boolean(object.deprecatedLegacyJsonFieldConflicts) + : isSet(object.deprecated_legacy_json_field_conflicts) + ? globalThis.Boolean(object.deprecated_legacy_json_field_conflicts) + : false, + features: isSet(object.features) ? FeatureSet.fromJSON(object.features) : undefined, + uninterpretedOption: globalThis.Array.isArray(object?.uninterpretedOption) + ? object.uninterpretedOption.map((e: any) => UninterpretedOption.fromJSON(e)) + : globalThis.Array.isArray(object?.uninterpreted_option) + ? object.uninterpreted_option.map((e: any) => UninterpretedOption.fromJSON(e)) + : [], + }; + }, + + toJSON(message: MessageOptions): unknown { + const obj: any = {}; + if (message.messageSetWireFormat !== undefined && message.messageSetWireFormat !== false) { + obj.messageSetWireFormat = message.messageSetWireFormat; + } + if (message.noStandardDescriptorAccessor !== undefined && message.noStandardDescriptorAccessor !== false) { + obj.noStandardDescriptorAccessor = message.noStandardDescriptorAccessor; + } + if (message.deprecated !== undefined && message.deprecated !== false) { + obj.deprecated = message.deprecated; + } + if (message.mapEntry !== undefined && message.mapEntry !== false) { + obj.mapEntry = message.mapEntry; + } + if ( + message.deprecatedLegacyJsonFieldConflicts !== undefined && message.deprecatedLegacyJsonFieldConflicts !== false + ) { + obj.deprecatedLegacyJsonFieldConflicts = message.deprecatedLegacyJsonFieldConflicts; + } + if (message.features !== undefined) { + obj.features = FeatureSet.toJSON(message.features); + } + if (message.uninterpretedOption?.length) { + obj.uninterpretedOption = message.uninterpretedOption.map((e) => UninterpretedOption.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): MessageOptions { + return MessageOptions.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): MessageOptions { + const message = createBaseMessageOptions(); + message.messageSetWireFormat = object.messageSetWireFormat ?? false; + message.noStandardDescriptorAccessor = object.noStandardDescriptorAccessor ?? false; + message.deprecated = object.deprecated ?? false; + message.mapEntry = object.mapEntry ?? false; + message.deprecatedLegacyJsonFieldConflicts = object.deprecatedLegacyJsonFieldConflicts ?? false; + message.features = (object.features !== undefined && object.features !== null) + ? FeatureSet.fromPartial(object.features) + : undefined; + message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseFieldOptions(): FieldOptions { + return { + ctype: 0, + packed: false, + jstype: 0, + lazy: false, + unverifiedLazy: false, + deprecated: false, + weak: false, + debugRedact: false, + retention: 0, + targets: [], + editionDefaults: [], + features: undefined, + featureSupport: undefined, + uninterpretedOption: [], + }; +} + +export const FieldOptions: MessageFns = { + encode(message: FieldOptions, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.ctype !== undefined && message.ctype !== 0) { + writer.uint32(8).int32(message.ctype); + } + if (message.packed !== undefined && message.packed !== false) { + writer.uint32(16).bool(message.packed); + } + if (message.jstype !== undefined && message.jstype !== 0) { + writer.uint32(48).int32(message.jstype); + } + if (message.lazy !== undefined && message.lazy !== false) { + writer.uint32(40).bool(message.lazy); + } + if (message.unverifiedLazy !== undefined && message.unverifiedLazy !== false) { + writer.uint32(120).bool(message.unverifiedLazy); + } + if (message.deprecated !== undefined && message.deprecated !== false) { + writer.uint32(24).bool(message.deprecated); + } + if (message.weak !== undefined && message.weak !== false) { + writer.uint32(80).bool(message.weak); + } + if (message.debugRedact !== undefined && message.debugRedact !== false) { + writer.uint32(128).bool(message.debugRedact); + } + if (message.retention !== undefined && message.retention !== 0) { + writer.uint32(136).int32(message.retention); + } + if (message.targets !== undefined && message.targets.length !== 0) { + for (const v of message.targets) { + writer.uint32(152).int32(v!); + } + } + if (message.editionDefaults !== undefined && message.editionDefaults.length !== 0) { + for (const v of message.editionDefaults) { + FieldOptions_EditionDefault.encode(v!, writer.uint32(162).fork()).join(); + } + } + if (message.features !== undefined) { + FeatureSet.encode(message.features, writer.uint32(170).fork()).join(); + } + if (message.featureSupport !== undefined) { + FieldOptions_FeatureSupport.encode(message.featureSupport, writer.uint32(178).fork()).join(); + } + if (message.uninterpretedOption !== undefined && message.uninterpretedOption.length !== 0) { + for (const v of message.uninterpretedOption) { + UninterpretedOption.encode(v!, writer.uint32(7994).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): FieldOptions { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFieldOptions(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.ctype = reader.int32() as any; + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.packed = reader.bool(); + continue; + } + case 6: { + if (tag !== 48) { + break; + } + + message.jstype = reader.int32() as any; + continue; + } + case 5: { + if (tag !== 40) { + break; + } + + message.lazy = reader.bool(); + continue; + } + case 15: { + if (tag !== 120) { + break; + } + + message.unverifiedLazy = reader.bool(); + continue; + } + case 3: { + if (tag !== 24) { + break; + } + + message.deprecated = reader.bool(); + continue; + } + case 10: { + if (tag !== 80) { + break; + } + + message.weak = reader.bool(); + continue; + } + case 16: { + if (tag !== 128) { + break; + } + + message.debugRedact = reader.bool(); + continue; + } + case 17: { + if (tag !== 136) { + break; + } + + message.retention = reader.int32() as any; + continue; + } + case 19: { + if (tag === 152) { + message.targets!.push(reader.int32() as any); + + continue; + } + + if (tag === 154) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.targets!.push(reader.int32() as any); + } + + continue; + } + + break; + } + case 20: { + if (tag !== 162) { + break; + } + + const el = FieldOptions_EditionDefault.decode(reader, reader.uint32()); + if (el !== undefined) { + message.editionDefaults!.push(el); + } + continue; + } + case 21: { + if (tag !== 170) { + break; + } + + message.features = FeatureSet.decode(reader, reader.uint32()); + continue; + } + case 22: { + if (tag !== 178) { + break; + } + + message.featureSupport = FieldOptions_FeatureSupport.decode(reader, reader.uint32()); + continue; + } + case 999: { + if (tag !== 7994) { + break; + } + + const el = UninterpretedOption.decode(reader, reader.uint32()); + if (el !== undefined) { + message.uninterpretedOption!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): FieldOptions { + return { + ctype: isSet(object.ctype) ? fieldOptions_CTypeFromJSON(object.ctype) : 0, + packed: isSet(object.packed) ? globalThis.Boolean(object.packed) : false, + jstype: isSet(object.jstype) ? fieldOptions_JSTypeFromJSON(object.jstype) : 0, + lazy: isSet(object.lazy) ? globalThis.Boolean(object.lazy) : false, + unverifiedLazy: isSet(object.unverifiedLazy) + ? globalThis.Boolean(object.unverifiedLazy) + : isSet(object.unverified_lazy) + ? globalThis.Boolean(object.unverified_lazy) + : false, + deprecated: isSet(object.deprecated) ? globalThis.Boolean(object.deprecated) : false, + weak: isSet(object.weak) ? globalThis.Boolean(object.weak) : false, + debugRedact: isSet(object.debugRedact) + ? globalThis.Boolean(object.debugRedact) + : isSet(object.debug_redact) + ? globalThis.Boolean(object.debug_redact) + : false, + retention: isSet(object.retention) ? fieldOptions_OptionRetentionFromJSON(object.retention) : 0, + targets: globalThis.Array.isArray(object?.targets) + ? object.targets.map((e: any) => fieldOptions_OptionTargetTypeFromJSON(e)) + : [], + editionDefaults: globalThis.Array.isArray(object?.editionDefaults) + ? object.editionDefaults.map((e: any) => FieldOptions_EditionDefault.fromJSON(e)) + : globalThis.Array.isArray(object?.edition_defaults) + ? object.edition_defaults.map((e: any) => FieldOptions_EditionDefault.fromJSON(e)) + : [], + features: isSet(object.features) ? FeatureSet.fromJSON(object.features) : undefined, + featureSupport: isSet(object.featureSupport) + ? FieldOptions_FeatureSupport.fromJSON(object.featureSupport) + : isSet(object.feature_support) + ? FieldOptions_FeatureSupport.fromJSON(object.feature_support) + : undefined, + uninterpretedOption: globalThis.Array.isArray(object?.uninterpretedOption) + ? object.uninterpretedOption.map((e: any) => UninterpretedOption.fromJSON(e)) + : globalThis.Array.isArray(object?.uninterpreted_option) + ? object.uninterpreted_option.map((e: any) => UninterpretedOption.fromJSON(e)) + : [], + }; + }, + + toJSON(message: FieldOptions): unknown { + const obj: any = {}; + if (message.ctype !== undefined && message.ctype !== 0) { + obj.ctype = fieldOptions_CTypeToJSON(message.ctype); + } + if (message.packed !== undefined && message.packed !== false) { + obj.packed = message.packed; + } + if (message.jstype !== undefined && message.jstype !== 0) { + obj.jstype = fieldOptions_JSTypeToJSON(message.jstype); + } + if (message.lazy !== undefined && message.lazy !== false) { + obj.lazy = message.lazy; + } + if (message.unverifiedLazy !== undefined && message.unverifiedLazy !== false) { + obj.unverifiedLazy = message.unverifiedLazy; + } + if (message.deprecated !== undefined && message.deprecated !== false) { + obj.deprecated = message.deprecated; + } + if (message.weak !== undefined && message.weak !== false) { + obj.weak = message.weak; + } + if (message.debugRedact !== undefined && message.debugRedact !== false) { + obj.debugRedact = message.debugRedact; + } + if (message.retention !== undefined && message.retention !== 0) { + obj.retention = fieldOptions_OptionRetentionToJSON(message.retention); + } + if (message.targets?.length) { + obj.targets = message.targets.map((e) => fieldOptions_OptionTargetTypeToJSON(e)); + } + if (message.editionDefaults?.length) { + obj.editionDefaults = message.editionDefaults.map((e) => FieldOptions_EditionDefault.toJSON(e)); + } + if (message.features !== undefined) { + obj.features = FeatureSet.toJSON(message.features); + } + if (message.featureSupport !== undefined) { + obj.featureSupport = FieldOptions_FeatureSupport.toJSON(message.featureSupport); + } + if (message.uninterpretedOption?.length) { + obj.uninterpretedOption = message.uninterpretedOption.map((e) => UninterpretedOption.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): FieldOptions { + return FieldOptions.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): FieldOptions { + const message = createBaseFieldOptions(); + message.ctype = object.ctype ?? 0; + message.packed = object.packed ?? false; + message.jstype = object.jstype ?? 0; + message.lazy = object.lazy ?? false; + message.unverifiedLazy = object.unverifiedLazy ?? false; + message.deprecated = object.deprecated ?? false; + message.weak = object.weak ?? false; + message.debugRedact = object.debugRedact ?? false; + message.retention = object.retention ?? 0; + message.targets = object.targets?.map((e) => e) || []; + message.editionDefaults = object.editionDefaults?.map((e) => FieldOptions_EditionDefault.fromPartial(e)) || []; + message.features = (object.features !== undefined && object.features !== null) + ? FeatureSet.fromPartial(object.features) + : undefined; + message.featureSupport = (object.featureSupport !== undefined && object.featureSupport !== null) + ? FieldOptions_FeatureSupport.fromPartial(object.featureSupport) + : undefined; + message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseFieldOptions_EditionDefault(): FieldOptions_EditionDefault { + return { edition: 0, value: "" }; +} + +export const FieldOptions_EditionDefault: MessageFns = { + encode(message: FieldOptions_EditionDefault, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.edition !== undefined && message.edition !== 0) { + writer.uint32(24).int32(message.edition); + } + if (message.value !== undefined && message.value !== "") { + writer.uint32(18).string(message.value); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): FieldOptions_EditionDefault { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFieldOptions_EditionDefault(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 3: { + if (tag !== 24) { + break; + } + + message.edition = reader.int32() as any; + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): FieldOptions_EditionDefault { + return { + edition: isSet(object.edition) ? editionFromJSON(object.edition) : 0, + value: isSet(object.value) ? globalThis.String(object.value) : "", + }; + }, + + toJSON(message: FieldOptions_EditionDefault): unknown { + const obj: any = {}; + if (message.edition !== undefined && message.edition !== 0) { + obj.edition = editionToJSON(message.edition); + } + if (message.value !== undefined && message.value !== "") { + obj.value = message.value; + } + return obj; + }, + + create(base?: DeepPartial): FieldOptions_EditionDefault { + return FieldOptions_EditionDefault.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): FieldOptions_EditionDefault { + const message = createBaseFieldOptions_EditionDefault(); + message.edition = object.edition ?? 0; + message.value = object.value ?? ""; + return message; + }, +}; + +function createBaseFieldOptions_FeatureSupport(): FieldOptions_FeatureSupport { + return { editionIntroduced: 0, editionDeprecated: 0, deprecationWarning: "", editionRemoved: 0, removalError: "" }; +} + +export const FieldOptions_FeatureSupport: MessageFns = { + encode(message: FieldOptions_FeatureSupport, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.editionIntroduced !== undefined && message.editionIntroduced !== 0) { + writer.uint32(8).int32(message.editionIntroduced); + } + if (message.editionDeprecated !== undefined && message.editionDeprecated !== 0) { + writer.uint32(16).int32(message.editionDeprecated); + } + if (message.deprecationWarning !== undefined && message.deprecationWarning !== "") { + writer.uint32(26).string(message.deprecationWarning); + } + if (message.editionRemoved !== undefined && message.editionRemoved !== 0) { + writer.uint32(32).int32(message.editionRemoved); + } + if (message.removalError !== undefined && message.removalError !== "") { + writer.uint32(42).string(message.removalError); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): FieldOptions_FeatureSupport { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFieldOptions_FeatureSupport(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.editionIntroduced = reader.int32() as any; + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.editionDeprecated = reader.int32() as any; + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.deprecationWarning = reader.string(); + continue; + } + case 4: { + if (tag !== 32) { + break; + } + + message.editionRemoved = reader.int32() as any; + continue; + } + case 5: { + if (tag !== 42) { + break; + } + + message.removalError = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): FieldOptions_FeatureSupport { + return { + editionIntroduced: isSet(object.editionIntroduced) + ? editionFromJSON(object.editionIntroduced) + : isSet(object.edition_introduced) + ? editionFromJSON(object.edition_introduced) + : 0, + editionDeprecated: isSet(object.editionDeprecated) + ? editionFromJSON(object.editionDeprecated) + : isSet(object.edition_deprecated) + ? editionFromJSON(object.edition_deprecated) + : 0, + deprecationWarning: isSet(object.deprecationWarning) + ? globalThis.String(object.deprecationWarning) + : isSet(object.deprecation_warning) + ? globalThis.String(object.deprecation_warning) + : "", + editionRemoved: isSet(object.editionRemoved) + ? editionFromJSON(object.editionRemoved) + : isSet(object.edition_removed) + ? editionFromJSON(object.edition_removed) + : 0, + removalError: isSet(object.removalError) + ? globalThis.String(object.removalError) + : isSet(object.removal_error) + ? globalThis.String(object.removal_error) + : "", + }; + }, + + toJSON(message: FieldOptions_FeatureSupport): unknown { + const obj: any = {}; + if (message.editionIntroduced !== undefined && message.editionIntroduced !== 0) { + obj.editionIntroduced = editionToJSON(message.editionIntroduced); + } + if (message.editionDeprecated !== undefined && message.editionDeprecated !== 0) { + obj.editionDeprecated = editionToJSON(message.editionDeprecated); + } + if (message.deprecationWarning !== undefined && message.deprecationWarning !== "") { + obj.deprecationWarning = message.deprecationWarning; + } + if (message.editionRemoved !== undefined && message.editionRemoved !== 0) { + obj.editionRemoved = editionToJSON(message.editionRemoved); + } + if (message.removalError !== undefined && message.removalError !== "") { + obj.removalError = message.removalError; + } + return obj; + }, + + create(base?: DeepPartial): FieldOptions_FeatureSupport { + return FieldOptions_FeatureSupport.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): FieldOptions_FeatureSupport { + const message = createBaseFieldOptions_FeatureSupport(); + message.editionIntroduced = object.editionIntroduced ?? 0; + message.editionDeprecated = object.editionDeprecated ?? 0; + message.deprecationWarning = object.deprecationWarning ?? ""; + message.editionRemoved = object.editionRemoved ?? 0; + message.removalError = object.removalError ?? ""; + return message; + }, +}; + +function createBaseOneofOptions(): OneofOptions { + return { features: undefined, uninterpretedOption: [] }; +} + +export const OneofOptions: MessageFns = { + encode(message: OneofOptions, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.features !== undefined) { + FeatureSet.encode(message.features, writer.uint32(10).fork()).join(); + } + if (message.uninterpretedOption !== undefined && message.uninterpretedOption.length !== 0) { + for (const v of message.uninterpretedOption) { + UninterpretedOption.encode(v!, writer.uint32(7994).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): OneofOptions { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseOneofOptions(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.features = FeatureSet.decode(reader, reader.uint32()); + continue; + } + case 999: { + if (tag !== 7994) { + break; + } + + const el = UninterpretedOption.decode(reader, reader.uint32()); + if (el !== undefined) { + message.uninterpretedOption!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): OneofOptions { + return { + features: isSet(object.features) ? FeatureSet.fromJSON(object.features) : undefined, + uninterpretedOption: globalThis.Array.isArray(object?.uninterpretedOption) + ? object.uninterpretedOption.map((e: any) => UninterpretedOption.fromJSON(e)) + : globalThis.Array.isArray(object?.uninterpreted_option) + ? object.uninterpreted_option.map((e: any) => UninterpretedOption.fromJSON(e)) + : [], + }; + }, + + toJSON(message: OneofOptions): unknown { + const obj: any = {}; + if (message.features !== undefined) { + obj.features = FeatureSet.toJSON(message.features); + } + if (message.uninterpretedOption?.length) { + obj.uninterpretedOption = message.uninterpretedOption.map((e) => UninterpretedOption.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): OneofOptions { + return OneofOptions.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): OneofOptions { + const message = createBaseOneofOptions(); + message.features = (object.features !== undefined && object.features !== null) + ? FeatureSet.fromPartial(object.features) + : undefined; + message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseEnumOptions(): EnumOptions { + return { + allowAlias: false, + deprecated: false, + deprecatedLegacyJsonFieldConflicts: false, + features: undefined, + uninterpretedOption: [], + }; +} + +export const EnumOptions: MessageFns = { + encode(message: EnumOptions, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.allowAlias !== undefined && message.allowAlias !== false) { + writer.uint32(16).bool(message.allowAlias); + } + if (message.deprecated !== undefined && message.deprecated !== false) { + writer.uint32(24).bool(message.deprecated); + } + if ( + message.deprecatedLegacyJsonFieldConflicts !== undefined && message.deprecatedLegacyJsonFieldConflicts !== false + ) { + writer.uint32(48).bool(message.deprecatedLegacyJsonFieldConflicts); + } + if (message.features !== undefined) { + FeatureSet.encode(message.features, writer.uint32(58).fork()).join(); + } + if (message.uninterpretedOption !== undefined && message.uninterpretedOption.length !== 0) { + for (const v of message.uninterpretedOption) { + UninterpretedOption.encode(v!, writer.uint32(7994).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): EnumOptions { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEnumOptions(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 2: { + if (tag !== 16) { + break; + } + + message.allowAlias = reader.bool(); + continue; + } + case 3: { + if (tag !== 24) { + break; + } + + message.deprecated = reader.bool(); + continue; + } + case 6: { + if (tag !== 48) { + break; + } + + message.deprecatedLegacyJsonFieldConflicts = reader.bool(); + continue; + } + case 7: { + if (tag !== 58) { + break; + } + + message.features = FeatureSet.decode(reader, reader.uint32()); + continue; + } + case 999: { + if (tag !== 7994) { + break; + } + + const el = UninterpretedOption.decode(reader, reader.uint32()); + if (el !== undefined) { + message.uninterpretedOption!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): EnumOptions { + return { + allowAlias: isSet(object.allowAlias) + ? globalThis.Boolean(object.allowAlias) + : isSet(object.allow_alias) + ? globalThis.Boolean(object.allow_alias) + : false, + deprecated: isSet(object.deprecated) ? globalThis.Boolean(object.deprecated) : false, + deprecatedLegacyJsonFieldConflicts: isSet(object.deprecatedLegacyJsonFieldConflicts) + ? globalThis.Boolean(object.deprecatedLegacyJsonFieldConflicts) + : isSet(object.deprecated_legacy_json_field_conflicts) + ? globalThis.Boolean(object.deprecated_legacy_json_field_conflicts) + : false, + features: isSet(object.features) ? FeatureSet.fromJSON(object.features) : undefined, + uninterpretedOption: globalThis.Array.isArray(object?.uninterpretedOption) + ? object.uninterpretedOption.map((e: any) => UninterpretedOption.fromJSON(e)) + : globalThis.Array.isArray(object?.uninterpreted_option) + ? object.uninterpreted_option.map((e: any) => UninterpretedOption.fromJSON(e)) + : [], + }; + }, + + toJSON(message: EnumOptions): unknown { + const obj: any = {}; + if (message.allowAlias !== undefined && message.allowAlias !== false) { + obj.allowAlias = message.allowAlias; + } + if (message.deprecated !== undefined && message.deprecated !== false) { + obj.deprecated = message.deprecated; + } + if ( + message.deprecatedLegacyJsonFieldConflicts !== undefined && message.deprecatedLegacyJsonFieldConflicts !== false + ) { + obj.deprecatedLegacyJsonFieldConflicts = message.deprecatedLegacyJsonFieldConflicts; + } + if (message.features !== undefined) { + obj.features = FeatureSet.toJSON(message.features); + } + if (message.uninterpretedOption?.length) { + obj.uninterpretedOption = message.uninterpretedOption.map((e) => UninterpretedOption.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): EnumOptions { + return EnumOptions.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): EnumOptions { + const message = createBaseEnumOptions(); + message.allowAlias = object.allowAlias ?? false; + message.deprecated = object.deprecated ?? false; + message.deprecatedLegacyJsonFieldConflicts = object.deprecatedLegacyJsonFieldConflicts ?? false; + message.features = (object.features !== undefined && object.features !== null) + ? FeatureSet.fromPartial(object.features) + : undefined; + message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseEnumValueOptions(): EnumValueOptions { + return { + deprecated: false, + features: undefined, + debugRedact: false, + featureSupport: undefined, + uninterpretedOption: [], + }; +} + +export const EnumValueOptions: MessageFns = { + encode(message: EnumValueOptions, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.deprecated !== undefined && message.deprecated !== false) { + writer.uint32(8).bool(message.deprecated); + } + if (message.features !== undefined) { + FeatureSet.encode(message.features, writer.uint32(18).fork()).join(); + } + if (message.debugRedact !== undefined && message.debugRedact !== false) { + writer.uint32(24).bool(message.debugRedact); + } + if (message.featureSupport !== undefined) { + FieldOptions_FeatureSupport.encode(message.featureSupport, writer.uint32(34).fork()).join(); + } + if (message.uninterpretedOption !== undefined && message.uninterpretedOption.length !== 0) { + for (const v of message.uninterpretedOption) { + UninterpretedOption.encode(v!, writer.uint32(7994).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): EnumValueOptions { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEnumValueOptions(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.deprecated = reader.bool(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.features = FeatureSet.decode(reader, reader.uint32()); + continue; + } + case 3: { + if (tag !== 24) { + break; + } + + message.debugRedact = reader.bool(); + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + message.featureSupport = FieldOptions_FeatureSupport.decode(reader, reader.uint32()); + continue; + } + case 999: { + if (tag !== 7994) { + break; + } + + const el = UninterpretedOption.decode(reader, reader.uint32()); + if (el !== undefined) { + message.uninterpretedOption!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): EnumValueOptions { + return { + deprecated: isSet(object.deprecated) ? globalThis.Boolean(object.deprecated) : false, + features: isSet(object.features) ? FeatureSet.fromJSON(object.features) : undefined, + debugRedact: isSet(object.debugRedact) + ? globalThis.Boolean(object.debugRedact) + : isSet(object.debug_redact) + ? globalThis.Boolean(object.debug_redact) + : false, + featureSupport: isSet(object.featureSupport) + ? FieldOptions_FeatureSupport.fromJSON(object.featureSupport) + : isSet(object.feature_support) + ? FieldOptions_FeatureSupport.fromJSON(object.feature_support) + : undefined, + uninterpretedOption: globalThis.Array.isArray(object?.uninterpretedOption) + ? object.uninterpretedOption.map((e: any) => UninterpretedOption.fromJSON(e)) + : globalThis.Array.isArray(object?.uninterpreted_option) + ? object.uninterpreted_option.map((e: any) => UninterpretedOption.fromJSON(e)) + : [], + }; + }, + + toJSON(message: EnumValueOptions): unknown { + const obj: any = {}; + if (message.deprecated !== undefined && message.deprecated !== false) { + obj.deprecated = message.deprecated; + } + if (message.features !== undefined) { + obj.features = FeatureSet.toJSON(message.features); + } + if (message.debugRedact !== undefined && message.debugRedact !== false) { + obj.debugRedact = message.debugRedact; + } + if (message.featureSupport !== undefined) { + obj.featureSupport = FieldOptions_FeatureSupport.toJSON(message.featureSupport); + } + if (message.uninterpretedOption?.length) { + obj.uninterpretedOption = message.uninterpretedOption.map((e) => UninterpretedOption.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): EnumValueOptions { + return EnumValueOptions.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): EnumValueOptions { + const message = createBaseEnumValueOptions(); + message.deprecated = object.deprecated ?? false; + message.features = (object.features !== undefined && object.features !== null) + ? FeatureSet.fromPartial(object.features) + : undefined; + message.debugRedact = object.debugRedact ?? false; + message.featureSupport = (object.featureSupport !== undefined && object.featureSupport !== null) + ? FieldOptions_FeatureSupport.fromPartial(object.featureSupport) + : undefined; + message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseServiceOptions(): ServiceOptions { + return { features: undefined, deprecated: false, uninterpretedOption: [] }; +} + +export const ServiceOptions: MessageFns = { + encode(message: ServiceOptions, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.features !== undefined) { + FeatureSet.encode(message.features, writer.uint32(274).fork()).join(); + } + if (message.deprecated !== undefined && message.deprecated !== false) { + writer.uint32(264).bool(message.deprecated); + } + if (message.uninterpretedOption !== undefined && message.uninterpretedOption.length !== 0) { + for (const v of message.uninterpretedOption) { + UninterpretedOption.encode(v!, writer.uint32(7994).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): ServiceOptions { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseServiceOptions(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 34: { + if (tag !== 274) { + break; + } + + message.features = FeatureSet.decode(reader, reader.uint32()); + continue; + } + case 33: { + if (tag !== 264) { + break; + } + + message.deprecated = reader.bool(); + continue; + } + case 999: { + if (tag !== 7994) { + break; + } + + const el = UninterpretedOption.decode(reader, reader.uint32()); + if (el !== undefined) { + message.uninterpretedOption!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): ServiceOptions { + return { + features: isSet(object.features) ? FeatureSet.fromJSON(object.features) : undefined, + deprecated: isSet(object.deprecated) ? globalThis.Boolean(object.deprecated) : false, + uninterpretedOption: globalThis.Array.isArray(object?.uninterpretedOption) + ? object.uninterpretedOption.map((e: any) => UninterpretedOption.fromJSON(e)) + : globalThis.Array.isArray(object?.uninterpreted_option) + ? object.uninterpreted_option.map((e: any) => UninterpretedOption.fromJSON(e)) + : [], + }; + }, + + toJSON(message: ServiceOptions): unknown { + const obj: any = {}; + if (message.features !== undefined) { + obj.features = FeatureSet.toJSON(message.features); + } + if (message.deprecated !== undefined && message.deprecated !== false) { + obj.deprecated = message.deprecated; + } + if (message.uninterpretedOption?.length) { + obj.uninterpretedOption = message.uninterpretedOption.map((e) => UninterpretedOption.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): ServiceOptions { + return ServiceOptions.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): ServiceOptions { + const message = createBaseServiceOptions(); + message.features = (object.features !== undefined && object.features !== null) + ? FeatureSet.fromPartial(object.features) + : undefined; + message.deprecated = object.deprecated ?? false; + message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseMethodOptions(): MethodOptions { + return { deprecated: false, idempotencyLevel: 0, features: undefined, uninterpretedOption: [] }; +} + +export const MethodOptions: MessageFns = { + encode(message: MethodOptions, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.deprecated !== undefined && message.deprecated !== false) { + writer.uint32(264).bool(message.deprecated); + } + if (message.idempotencyLevel !== undefined && message.idempotencyLevel !== 0) { + writer.uint32(272).int32(message.idempotencyLevel); + } + if (message.features !== undefined) { + FeatureSet.encode(message.features, writer.uint32(282).fork()).join(); + } + if (message.uninterpretedOption !== undefined && message.uninterpretedOption.length !== 0) { + for (const v of message.uninterpretedOption) { + UninterpretedOption.encode(v!, writer.uint32(7994).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): MethodOptions { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseMethodOptions(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 33: { + if (tag !== 264) { + break; + } + + message.deprecated = reader.bool(); + continue; + } + case 34: { + if (tag !== 272) { + break; + } + + message.idempotencyLevel = reader.int32() as any; + continue; + } + case 35: { + if (tag !== 282) { + break; + } + + message.features = FeatureSet.decode(reader, reader.uint32()); + continue; + } + case 999: { + if (tag !== 7994) { + break; + } + + const el = UninterpretedOption.decode(reader, reader.uint32()); + if (el !== undefined) { + message.uninterpretedOption!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): MethodOptions { + return { + deprecated: isSet(object.deprecated) ? globalThis.Boolean(object.deprecated) : false, + idempotencyLevel: isSet(object.idempotencyLevel) + ? methodOptions_IdempotencyLevelFromJSON(object.idempotencyLevel) + : isSet(object.idempotency_level) + ? methodOptions_IdempotencyLevelFromJSON(object.idempotency_level) + : 0, + features: isSet(object.features) ? FeatureSet.fromJSON(object.features) : undefined, + uninterpretedOption: globalThis.Array.isArray(object?.uninterpretedOption) + ? object.uninterpretedOption.map((e: any) => UninterpretedOption.fromJSON(e)) + : globalThis.Array.isArray(object?.uninterpreted_option) + ? object.uninterpreted_option.map((e: any) => UninterpretedOption.fromJSON(e)) + : [], + }; + }, + + toJSON(message: MethodOptions): unknown { + const obj: any = {}; + if (message.deprecated !== undefined && message.deprecated !== false) { + obj.deprecated = message.deprecated; + } + if (message.idempotencyLevel !== undefined && message.idempotencyLevel !== 0) { + obj.idempotencyLevel = methodOptions_IdempotencyLevelToJSON(message.idempotencyLevel); + } + if (message.features !== undefined) { + obj.features = FeatureSet.toJSON(message.features); + } + if (message.uninterpretedOption?.length) { + obj.uninterpretedOption = message.uninterpretedOption.map((e) => UninterpretedOption.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): MethodOptions { + return MethodOptions.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): MethodOptions { + const message = createBaseMethodOptions(); + message.deprecated = object.deprecated ?? false; + message.idempotencyLevel = object.idempotencyLevel ?? 0; + message.features = (object.features !== undefined && object.features !== null) + ? FeatureSet.fromPartial(object.features) + : undefined; + message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseUninterpretedOption(): UninterpretedOption { + return { + name: [], + identifierValue: "", + positiveIntValue: 0, + negativeIntValue: 0, + doubleValue: 0, + stringValue: new Uint8Array(0), + aggregateValue: "", + }; +} + +export const UninterpretedOption: MessageFns = { + encode(message: UninterpretedOption, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name.length !== 0) { + for (const v of message.name) { + UninterpretedOption_NamePart.encode(v!, writer.uint32(18).fork()).join(); + } + } + if (message.identifierValue !== undefined && message.identifierValue !== "") { + writer.uint32(26).string(message.identifierValue); + } + if (message.positiveIntValue !== undefined && message.positiveIntValue !== 0) { + writer.uint32(32).uint64(message.positiveIntValue); + } + if (message.negativeIntValue !== undefined && message.negativeIntValue !== 0) { + writer.uint32(40).int64(message.negativeIntValue); + } + if (message.doubleValue !== undefined && message.doubleValue !== 0) { + writer.uint32(49).double(message.doubleValue); + } + if (message.stringValue !== undefined && message.stringValue.length !== 0) { + writer.uint32(58).bytes(message.stringValue); + } + if (message.aggregateValue !== undefined && message.aggregateValue !== "") { + writer.uint32(66).string(message.aggregateValue); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): UninterpretedOption { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUninterpretedOption(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 2: { + if (tag !== 18) { + break; + } + + const el = UninterpretedOption_NamePart.decode(reader, reader.uint32()); + if (el !== undefined) { + message.name!.push(el); + } + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.identifierValue = reader.string(); + continue; + } + case 4: { + if (tag !== 32) { + break; + } + + message.positiveIntValue = longToNumber(reader.uint64()); + continue; + } + case 5: { + if (tag !== 40) { + break; + } + + message.negativeIntValue = longToNumber(reader.int64()); + continue; + } + case 6: { + if (tag !== 49) { + break; + } + + message.doubleValue = reader.double(); + continue; + } + case 7: { + if (tag !== 58) { + break; + } + + message.stringValue = reader.bytes(); + continue; + } + case 8: { + if (tag !== 66) { + break; + } + + message.aggregateValue = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): UninterpretedOption { + return { + name: globalThis.Array.isArray(object?.name) + ? object.name.map((e: any) => UninterpretedOption_NamePart.fromJSON(e)) + : [], + identifierValue: isSet(object.identifierValue) + ? globalThis.String(object.identifierValue) + : isSet(object.identifier_value) + ? globalThis.String(object.identifier_value) + : "", + positiveIntValue: isSet(object.positiveIntValue) + ? globalThis.Number(object.positiveIntValue) + : isSet(object.positive_int_value) + ? globalThis.Number(object.positive_int_value) + : 0, + negativeIntValue: isSet(object.negativeIntValue) + ? globalThis.Number(object.negativeIntValue) + : isSet(object.negative_int_value) + ? globalThis.Number(object.negative_int_value) + : 0, + doubleValue: isSet(object.doubleValue) + ? globalThis.Number(object.doubleValue) + : isSet(object.double_value) + ? globalThis.Number(object.double_value) + : 0, + stringValue: isSet(object.stringValue) + ? bytesFromBase64(object.stringValue) + : isSet(object.string_value) + ? bytesFromBase64(object.string_value) + : new Uint8Array(0), + aggregateValue: isSet(object.aggregateValue) + ? globalThis.String(object.aggregateValue) + : isSet(object.aggregate_value) + ? globalThis.String(object.aggregate_value) + : "", + }; + }, + + toJSON(message: UninterpretedOption): unknown { + const obj: any = {}; + if (message.name?.length) { + obj.name = message.name.map((e) => UninterpretedOption_NamePart.toJSON(e)); + } + if (message.identifierValue !== undefined && message.identifierValue !== "") { + obj.identifierValue = message.identifierValue; + } + if (message.positiveIntValue !== undefined && message.positiveIntValue !== 0) { + obj.positiveIntValue = Math.round(message.positiveIntValue); + } + if (message.negativeIntValue !== undefined && message.negativeIntValue !== 0) { + obj.negativeIntValue = Math.round(message.negativeIntValue); + } + if (message.doubleValue !== undefined && message.doubleValue !== 0) { + obj.doubleValue = message.doubleValue; + } + if (message.stringValue !== undefined && message.stringValue.length !== 0) { + obj.stringValue = base64FromBytes(message.stringValue); + } + if (message.aggregateValue !== undefined && message.aggregateValue !== "") { + obj.aggregateValue = message.aggregateValue; + } + return obj; + }, + + create(base?: DeepPartial): UninterpretedOption { + return UninterpretedOption.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): UninterpretedOption { + const message = createBaseUninterpretedOption(); + message.name = object.name?.map((e) => UninterpretedOption_NamePart.fromPartial(e)) || []; + message.identifierValue = object.identifierValue ?? ""; + message.positiveIntValue = object.positiveIntValue ?? 0; + message.negativeIntValue = object.negativeIntValue ?? 0; + message.doubleValue = object.doubleValue ?? 0; + message.stringValue = object.stringValue ?? new Uint8Array(0); + message.aggregateValue = object.aggregateValue ?? ""; + return message; + }, +}; + +function createBaseUninterpretedOption_NamePart(): UninterpretedOption_NamePart { + return { namePart: "", isExtension: false }; +} + +export const UninterpretedOption_NamePart: MessageFns = { + encode(message: UninterpretedOption_NamePart, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.namePart !== undefined && message.namePart !== "") { + writer.uint32(10).string(message.namePart); + } + if (message.isExtension !== undefined && message.isExtension !== false) { + writer.uint32(16).bool(message.isExtension); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): UninterpretedOption_NamePart { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUninterpretedOption_NamePart(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.namePart = reader.string(); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.isExtension = reader.bool(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): UninterpretedOption_NamePart { + return { + namePart: isSet(object.namePart) + ? globalThis.String(object.namePart) + : isSet(object.name_part) + ? globalThis.String(object.name_part) + : "", + isExtension: isSet(object.isExtension) + ? globalThis.Boolean(object.isExtension) + : isSet(object.is_extension) + ? globalThis.Boolean(object.is_extension) + : false, + }; + }, + + toJSON(message: UninterpretedOption_NamePart): unknown { + const obj: any = {}; + if (message.namePart !== undefined && message.namePart !== "") { + obj.namePart = message.namePart; + } + if (message.isExtension !== undefined && message.isExtension !== false) { + obj.isExtension = message.isExtension; + } + return obj; + }, + + create(base?: DeepPartial): UninterpretedOption_NamePart { + return UninterpretedOption_NamePart.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): UninterpretedOption_NamePart { + const message = createBaseUninterpretedOption_NamePart(); + message.namePart = object.namePart ?? ""; + message.isExtension = object.isExtension ?? false; + return message; + }, +}; + +function createBaseFeatureSet(): FeatureSet { + return { + fieldPresence: 0, + enumType: 0, + repeatedFieldEncoding: 0, + utf8Validation: 0, + messageEncoding: 0, + jsonFormat: 0, + enforceNamingStyle: 0, + defaultSymbolVisibility: 0, + }; +} + +export const FeatureSet: MessageFns = { + encode(message: FeatureSet, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.fieldPresence !== undefined && message.fieldPresence !== 0) { + writer.uint32(8).int32(message.fieldPresence); + } + if (message.enumType !== undefined && message.enumType !== 0) { + writer.uint32(16).int32(message.enumType); + } + if (message.repeatedFieldEncoding !== undefined && message.repeatedFieldEncoding !== 0) { + writer.uint32(24).int32(message.repeatedFieldEncoding); + } + if (message.utf8Validation !== undefined && message.utf8Validation !== 0) { + writer.uint32(32).int32(message.utf8Validation); + } + if (message.messageEncoding !== undefined && message.messageEncoding !== 0) { + writer.uint32(40).int32(message.messageEncoding); + } + if (message.jsonFormat !== undefined && message.jsonFormat !== 0) { + writer.uint32(48).int32(message.jsonFormat); + } + if (message.enforceNamingStyle !== undefined && message.enforceNamingStyle !== 0) { + writer.uint32(56).int32(message.enforceNamingStyle); + } + if (message.defaultSymbolVisibility !== undefined && message.defaultSymbolVisibility !== 0) { + writer.uint32(64).int32(message.defaultSymbolVisibility); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): FeatureSet { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFeatureSet(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.fieldPresence = reader.int32() as any; + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.enumType = reader.int32() as any; + continue; + } + case 3: { + if (tag !== 24) { + break; + } + + message.repeatedFieldEncoding = reader.int32() as any; + continue; + } + case 4: { + if (tag !== 32) { + break; + } + + message.utf8Validation = reader.int32() as any; + continue; + } + case 5: { + if (tag !== 40) { + break; + } + + message.messageEncoding = reader.int32() as any; + continue; + } + case 6: { + if (tag !== 48) { + break; + } + + message.jsonFormat = reader.int32() as any; + continue; + } + case 7: { + if (tag !== 56) { + break; + } + + message.enforceNamingStyle = reader.int32() as any; + continue; + } + case 8: { + if (tag !== 64) { + break; + } + + message.defaultSymbolVisibility = reader.int32() as any; + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): FeatureSet { + return { + fieldPresence: isSet(object.fieldPresence) + ? featureSet_FieldPresenceFromJSON(object.fieldPresence) + : isSet(object.field_presence) + ? featureSet_FieldPresenceFromJSON(object.field_presence) + : 0, + enumType: isSet(object.enumType) + ? featureSet_EnumTypeFromJSON(object.enumType) + : isSet(object.enum_type) + ? featureSet_EnumTypeFromJSON(object.enum_type) + : 0, + repeatedFieldEncoding: isSet(object.repeatedFieldEncoding) + ? featureSet_RepeatedFieldEncodingFromJSON(object.repeatedFieldEncoding) + : isSet(object.repeated_field_encoding) + ? featureSet_RepeatedFieldEncodingFromJSON(object.repeated_field_encoding) + : 0, + utf8Validation: isSet(object.utf8Validation) + ? featureSet_Utf8ValidationFromJSON(object.utf8Validation) + : isSet(object.utf8_validation) + ? featureSet_Utf8ValidationFromJSON(object.utf8_validation) + : 0, + messageEncoding: isSet(object.messageEncoding) + ? featureSet_MessageEncodingFromJSON(object.messageEncoding) + : isSet(object.message_encoding) + ? featureSet_MessageEncodingFromJSON(object.message_encoding) + : 0, + jsonFormat: isSet(object.jsonFormat) + ? featureSet_JsonFormatFromJSON(object.jsonFormat) + : isSet(object.json_format) + ? featureSet_JsonFormatFromJSON(object.json_format) + : 0, + enforceNamingStyle: isSet(object.enforceNamingStyle) + ? featureSet_EnforceNamingStyleFromJSON(object.enforceNamingStyle) + : isSet(object.enforce_naming_style) + ? featureSet_EnforceNamingStyleFromJSON(object.enforce_naming_style) + : 0, + defaultSymbolVisibility: isSet(object.defaultSymbolVisibility) + ? featureSet_VisibilityFeature_DefaultSymbolVisibilityFromJSON(object.defaultSymbolVisibility) + : isSet(object.default_symbol_visibility) + ? featureSet_VisibilityFeature_DefaultSymbolVisibilityFromJSON(object.default_symbol_visibility) + : 0, + }; + }, + + toJSON(message: FeatureSet): unknown { + const obj: any = {}; + if (message.fieldPresence !== undefined && message.fieldPresence !== 0) { + obj.fieldPresence = featureSet_FieldPresenceToJSON(message.fieldPresence); + } + if (message.enumType !== undefined && message.enumType !== 0) { + obj.enumType = featureSet_EnumTypeToJSON(message.enumType); + } + if (message.repeatedFieldEncoding !== undefined && message.repeatedFieldEncoding !== 0) { + obj.repeatedFieldEncoding = featureSet_RepeatedFieldEncodingToJSON(message.repeatedFieldEncoding); + } + if (message.utf8Validation !== undefined && message.utf8Validation !== 0) { + obj.utf8Validation = featureSet_Utf8ValidationToJSON(message.utf8Validation); + } + if (message.messageEncoding !== undefined && message.messageEncoding !== 0) { + obj.messageEncoding = featureSet_MessageEncodingToJSON(message.messageEncoding); + } + if (message.jsonFormat !== undefined && message.jsonFormat !== 0) { + obj.jsonFormat = featureSet_JsonFormatToJSON(message.jsonFormat); + } + if (message.enforceNamingStyle !== undefined && message.enforceNamingStyle !== 0) { + obj.enforceNamingStyle = featureSet_EnforceNamingStyleToJSON(message.enforceNamingStyle); + } + if (message.defaultSymbolVisibility !== undefined && message.defaultSymbolVisibility !== 0) { + obj.defaultSymbolVisibility = featureSet_VisibilityFeature_DefaultSymbolVisibilityToJSON( + message.defaultSymbolVisibility, + ); + } + return obj; + }, + + create(base?: DeepPartial): FeatureSet { + return FeatureSet.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): FeatureSet { + const message = createBaseFeatureSet(); + message.fieldPresence = object.fieldPresence ?? 0; + message.enumType = object.enumType ?? 0; + message.repeatedFieldEncoding = object.repeatedFieldEncoding ?? 0; + message.utf8Validation = object.utf8Validation ?? 0; + message.messageEncoding = object.messageEncoding ?? 0; + message.jsonFormat = object.jsonFormat ?? 0; + message.enforceNamingStyle = object.enforceNamingStyle ?? 0; + message.defaultSymbolVisibility = object.defaultSymbolVisibility ?? 0; + return message; + }, +}; + +function createBaseFeatureSet_VisibilityFeature(): FeatureSet_VisibilityFeature { + return {}; +} + +export const FeatureSet_VisibilityFeature: MessageFns = { + encode(_: FeatureSet_VisibilityFeature, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): FeatureSet_VisibilityFeature { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFeatureSet_VisibilityFeature(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(_: any): FeatureSet_VisibilityFeature { + return {}; + }, + + toJSON(_: FeatureSet_VisibilityFeature): unknown { + const obj: any = {}; + return obj; + }, + + create(base?: DeepPartial): FeatureSet_VisibilityFeature { + return FeatureSet_VisibilityFeature.fromPartial(base ?? {}); + }, + fromPartial(_: DeepPartial): FeatureSet_VisibilityFeature { + const message = createBaseFeatureSet_VisibilityFeature(); + return message; + }, +}; + +function createBaseFeatureSetDefaults(): FeatureSetDefaults { + return { defaults: [], minimumEdition: 0, maximumEdition: 0 }; +} + +export const FeatureSetDefaults: MessageFns = { + encode(message: FeatureSetDefaults, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.defaults !== undefined && message.defaults.length !== 0) { + for (const v of message.defaults) { + FeatureSetDefaults_FeatureSetEditionDefault.encode(v!, writer.uint32(10).fork()).join(); + } + } + if (message.minimumEdition !== undefined && message.minimumEdition !== 0) { + writer.uint32(32).int32(message.minimumEdition); + } + if (message.maximumEdition !== undefined && message.maximumEdition !== 0) { + writer.uint32(40).int32(message.maximumEdition); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): FeatureSetDefaults { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFeatureSetDefaults(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + const el = FeatureSetDefaults_FeatureSetEditionDefault.decode(reader, reader.uint32()); + if (el !== undefined) { + message.defaults!.push(el); + } + continue; + } + case 4: { + if (tag !== 32) { + break; + } + + message.minimumEdition = reader.int32() as any; + continue; + } + case 5: { + if (tag !== 40) { + break; + } + + message.maximumEdition = reader.int32() as any; + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): FeatureSetDefaults { + return { + defaults: globalThis.Array.isArray(object?.defaults) + ? object.defaults.map((e: any) => FeatureSetDefaults_FeatureSetEditionDefault.fromJSON(e)) + : [], + minimumEdition: isSet(object.minimumEdition) + ? editionFromJSON(object.minimumEdition) + : isSet(object.minimum_edition) + ? editionFromJSON(object.minimum_edition) + : 0, + maximumEdition: isSet(object.maximumEdition) + ? editionFromJSON(object.maximumEdition) + : isSet(object.maximum_edition) + ? editionFromJSON(object.maximum_edition) + : 0, + }; + }, + + toJSON(message: FeatureSetDefaults): unknown { + const obj: any = {}; + if (message.defaults?.length) { + obj.defaults = message.defaults.map((e) => FeatureSetDefaults_FeatureSetEditionDefault.toJSON(e)); + } + if (message.minimumEdition !== undefined && message.minimumEdition !== 0) { + obj.minimumEdition = editionToJSON(message.minimumEdition); + } + if (message.maximumEdition !== undefined && message.maximumEdition !== 0) { + obj.maximumEdition = editionToJSON(message.maximumEdition); + } + return obj; + }, + + create(base?: DeepPartial): FeatureSetDefaults { + return FeatureSetDefaults.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): FeatureSetDefaults { + const message = createBaseFeatureSetDefaults(); + message.defaults = object.defaults?.map((e) => FeatureSetDefaults_FeatureSetEditionDefault.fromPartial(e)) || []; + message.minimumEdition = object.minimumEdition ?? 0; + message.maximumEdition = object.maximumEdition ?? 0; + return message; + }, +}; + +function createBaseFeatureSetDefaults_FeatureSetEditionDefault(): FeatureSetDefaults_FeatureSetEditionDefault { + return { edition: 0, overridableFeatures: undefined, fixedFeatures: undefined }; +} + +export const FeatureSetDefaults_FeatureSetEditionDefault: MessageFns = { + encode( + message: FeatureSetDefaults_FeatureSetEditionDefault, + writer: BinaryWriter = new BinaryWriter(), + ): BinaryWriter { + if (message.edition !== undefined && message.edition !== 0) { + writer.uint32(24).int32(message.edition); + } + if (message.overridableFeatures !== undefined) { + FeatureSet.encode(message.overridableFeatures, writer.uint32(34).fork()).join(); + } + if (message.fixedFeatures !== undefined) { + FeatureSet.encode(message.fixedFeatures, writer.uint32(42).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): FeatureSetDefaults_FeatureSetEditionDefault { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFeatureSetDefaults_FeatureSetEditionDefault(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 3: { + if (tag !== 24) { + break; + } + + message.edition = reader.int32() as any; + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + message.overridableFeatures = FeatureSet.decode(reader, reader.uint32()); + continue; + } + case 5: { + if (tag !== 42) { + break; + } + + message.fixedFeatures = FeatureSet.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): FeatureSetDefaults_FeatureSetEditionDefault { + return { + edition: isSet(object.edition) ? editionFromJSON(object.edition) : 0, + overridableFeatures: isSet(object.overridableFeatures) + ? FeatureSet.fromJSON(object.overridableFeatures) + : isSet(object.overridable_features) + ? FeatureSet.fromJSON(object.overridable_features) + : undefined, + fixedFeatures: isSet(object.fixedFeatures) + ? FeatureSet.fromJSON(object.fixedFeatures) + : isSet(object.fixed_features) + ? FeatureSet.fromJSON(object.fixed_features) + : undefined, + }; + }, + + toJSON(message: FeatureSetDefaults_FeatureSetEditionDefault): unknown { + const obj: any = {}; + if (message.edition !== undefined && message.edition !== 0) { + obj.edition = editionToJSON(message.edition); + } + if (message.overridableFeatures !== undefined) { + obj.overridableFeatures = FeatureSet.toJSON(message.overridableFeatures); + } + if (message.fixedFeatures !== undefined) { + obj.fixedFeatures = FeatureSet.toJSON(message.fixedFeatures); + } + return obj; + }, + + create(base?: DeepPartial): FeatureSetDefaults_FeatureSetEditionDefault { + return FeatureSetDefaults_FeatureSetEditionDefault.fromPartial(base ?? {}); + }, + fromPartial( + object: DeepPartial, + ): FeatureSetDefaults_FeatureSetEditionDefault { + const message = createBaseFeatureSetDefaults_FeatureSetEditionDefault(); + message.edition = object.edition ?? 0; + message.overridableFeatures = (object.overridableFeatures !== undefined && object.overridableFeatures !== null) + ? FeatureSet.fromPartial(object.overridableFeatures) + : undefined; + message.fixedFeatures = (object.fixedFeatures !== undefined && object.fixedFeatures !== null) + ? FeatureSet.fromPartial(object.fixedFeatures) + : undefined; + return message; + }, +}; + +function createBaseSourceCodeInfo(): SourceCodeInfo { + return { location: [] }; +} + +export const SourceCodeInfo: MessageFns = { + encode(message: SourceCodeInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.location !== undefined && message.location.length !== 0) { + for (const v of message.location) { + SourceCodeInfo_Location.encode(v!, writer.uint32(10).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): SourceCodeInfo { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSourceCodeInfo(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + const el = SourceCodeInfo_Location.decode(reader, reader.uint32()); + if (el !== undefined) { + message.location!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): SourceCodeInfo { + return { + location: globalThis.Array.isArray(object?.location) + ? object.location.map((e: any) => SourceCodeInfo_Location.fromJSON(e)) + : [], + }; + }, + + toJSON(message: SourceCodeInfo): unknown { + const obj: any = {}; + if (message.location?.length) { + obj.location = message.location.map((e) => SourceCodeInfo_Location.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): SourceCodeInfo { + return SourceCodeInfo.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): SourceCodeInfo { + const message = createBaseSourceCodeInfo(); + message.location = object.location?.map((e) => SourceCodeInfo_Location.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseSourceCodeInfo_Location(): SourceCodeInfo_Location { + return { path: [], span: [], leadingComments: "", trailingComments: "", leadingDetachedComments: [] }; +} + +export const SourceCodeInfo_Location: MessageFns = { + encode(message: SourceCodeInfo_Location, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.path !== undefined && message.path.length !== 0) { + writer.uint32(10).fork(); + for (const v of message.path) { + writer.int32(v); + } + writer.join(); + } + if (message.span !== undefined && message.span.length !== 0) { + writer.uint32(18).fork(); + for (const v of message.span) { + writer.int32(v); + } + writer.join(); + } + if (message.leadingComments !== undefined && message.leadingComments !== "") { + writer.uint32(26).string(message.leadingComments); + } + if (message.trailingComments !== undefined && message.trailingComments !== "") { + writer.uint32(34).string(message.trailingComments); + } + if (message.leadingDetachedComments !== undefined && message.leadingDetachedComments.length !== 0) { + for (const v of message.leadingDetachedComments) { + writer.uint32(50).string(v!); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): SourceCodeInfo_Location { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSourceCodeInfo_Location(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag === 8) { + message.path!.push(reader.int32()); + + continue; + } + + if (tag === 10) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.path!.push(reader.int32()); + } + + continue; + } + + break; + } + case 2: { + if (tag === 16) { + message.span!.push(reader.int32()); + + continue; + } + + if (tag === 18) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.span!.push(reader.int32()); + } + + continue; + } + + break; + } + case 3: { + if (tag !== 26) { + break; + } + + message.leadingComments = reader.string(); + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + message.trailingComments = reader.string(); + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.leadingDetachedComments!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): SourceCodeInfo_Location { + return { + path: globalThis.Array.isArray(object?.path) ? object.path.map((e: any) => globalThis.Number(e)) : [], + span: globalThis.Array.isArray(object?.span) ? object.span.map((e: any) => globalThis.Number(e)) : [], + leadingComments: isSet(object.leadingComments) + ? globalThis.String(object.leadingComments) + : isSet(object.leading_comments) + ? globalThis.String(object.leading_comments) + : "", + trailingComments: isSet(object.trailingComments) + ? globalThis.String(object.trailingComments) + : isSet(object.trailing_comments) + ? globalThis.String(object.trailing_comments) + : "", + leadingDetachedComments: globalThis.Array.isArray(object?.leadingDetachedComments) + ? object.leadingDetachedComments.map((e: any) => globalThis.String(e)) + : globalThis.Array.isArray(object?.leading_detached_comments) + ? object.leading_detached_comments.map((e: any) => globalThis.String(e)) + : [], + }; + }, + + toJSON(message: SourceCodeInfo_Location): unknown { + const obj: any = {}; + if (message.path?.length) { + obj.path = message.path.map((e) => Math.round(e)); + } + if (message.span?.length) { + obj.span = message.span.map((e) => Math.round(e)); + } + if (message.leadingComments !== undefined && message.leadingComments !== "") { + obj.leadingComments = message.leadingComments; + } + if (message.trailingComments !== undefined && message.trailingComments !== "") { + obj.trailingComments = message.trailingComments; + } + if (message.leadingDetachedComments?.length) { + obj.leadingDetachedComments = message.leadingDetachedComments; + } + return obj; + }, + + create(base?: DeepPartial): SourceCodeInfo_Location { + return SourceCodeInfo_Location.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): SourceCodeInfo_Location { + const message = createBaseSourceCodeInfo_Location(); + message.path = object.path?.map((e) => e) || []; + message.span = object.span?.map((e) => e) || []; + message.leadingComments = object.leadingComments ?? ""; + message.trailingComments = object.trailingComments ?? ""; + message.leadingDetachedComments = object.leadingDetachedComments?.map((e) => e) || []; + return message; + }, +}; + +function createBaseGeneratedCodeInfo(): GeneratedCodeInfo { + return { annotation: [] }; +} + +export const GeneratedCodeInfo: MessageFns = { + encode(message: GeneratedCodeInfo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.annotation !== undefined && message.annotation.length !== 0) { + for (const v of message.annotation) { + GeneratedCodeInfo_Annotation.encode(v!, writer.uint32(10).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): GeneratedCodeInfo { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGeneratedCodeInfo(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + const el = GeneratedCodeInfo_Annotation.decode(reader, reader.uint32()); + if (el !== undefined) { + message.annotation!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): GeneratedCodeInfo { + return { + annotation: globalThis.Array.isArray(object?.annotation) + ? object.annotation.map((e: any) => GeneratedCodeInfo_Annotation.fromJSON(e)) + : [], + }; + }, + + toJSON(message: GeneratedCodeInfo): unknown { + const obj: any = {}; + if (message.annotation?.length) { + obj.annotation = message.annotation.map((e) => GeneratedCodeInfo_Annotation.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): GeneratedCodeInfo { + return GeneratedCodeInfo.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GeneratedCodeInfo { + const message = createBaseGeneratedCodeInfo(); + message.annotation = object.annotation?.map((e) => GeneratedCodeInfo_Annotation.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseGeneratedCodeInfo_Annotation(): GeneratedCodeInfo_Annotation { + return { path: [], sourceFile: "", begin: 0, end: 0, semantic: 0 }; +} + +export const GeneratedCodeInfo_Annotation: MessageFns = { + encode(message: GeneratedCodeInfo_Annotation, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.path !== undefined && message.path.length !== 0) { + writer.uint32(10).fork(); + for (const v of message.path) { + writer.int32(v); + } + writer.join(); + } + if (message.sourceFile !== undefined && message.sourceFile !== "") { + writer.uint32(18).string(message.sourceFile); + } + if (message.begin !== undefined && message.begin !== 0) { + writer.uint32(24).int32(message.begin); + } + if (message.end !== undefined && message.end !== 0) { + writer.uint32(32).int32(message.end); + } + if (message.semantic !== undefined && message.semantic !== 0) { + writer.uint32(40).int32(message.semantic); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): GeneratedCodeInfo_Annotation { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGeneratedCodeInfo_Annotation(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag === 8) { + message.path!.push(reader.int32()); + + continue; + } + + if (tag === 10) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.path!.push(reader.int32()); + } + + continue; + } + + break; + } + case 2: { + if (tag !== 18) { + break; + } + + message.sourceFile = reader.string(); + continue; + } + case 3: { + if (tag !== 24) { + break; + } + + message.begin = reader.int32(); + continue; + } + case 4: { + if (tag !== 32) { + break; + } + + message.end = reader.int32(); + continue; + } + case 5: { + if (tag !== 40) { + break; + } + + message.semantic = reader.int32() as any; + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): GeneratedCodeInfo_Annotation { + return { + path: globalThis.Array.isArray(object?.path) ? object.path.map((e: any) => globalThis.Number(e)) : [], + sourceFile: isSet(object.sourceFile) + ? globalThis.String(object.sourceFile) + : isSet(object.source_file) + ? globalThis.String(object.source_file) + : "", + begin: isSet(object.begin) ? globalThis.Number(object.begin) : 0, + end: isSet(object.end) ? globalThis.Number(object.end) : 0, + semantic: isSet(object.semantic) ? generatedCodeInfo_Annotation_SemanticFromJSON(object.semantic) : 0, + }; + }, + + toJSON(message: GeneratedCodeInfo_Annotation): unknown { + const obj: any = {}; + if (message.path?.length) { + obj.path = message.path.map((e) => Math.round(e)); + } + if (message.sourceFile !== undefined && message.sourceFile !== "") { + obj.sourceFile = message.sourceFile; + } + if (message.begin !== undefined && message.begin !== 0) { + obj.begin = Math.round(message.begin); + } + if (message.end !== undefined && message.end !== 0) { + obj.end = Math.round(message.end); + } + if (message.semantic !== undefined && message.semantic !== 0) { + obj.semantic = generatedCodeInfo_Annotation_SemanticToJSON(message.semantic); + } + return obj; + }, + + create(base?: DeepPartial): GeneratedCodeInfo_Annotation { + return GeneratedCodeInfo_Annotation.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GeneratedCodeInfo_Annotation { + const message = createBaseGeneratedCodeInfo_Annotation(); + message.path = object.path?.map((e) => e) || []; + message.sourceFile = object.sourceFile ?? ""; + message.begin = object.begin ?? 0; + message.end = object.end ?? 0; + message.semantic = object.semantic ?? 0; + return message; + }, +}; + +function bytesFromBase64(b64: string): Uint8Array { + if ((globalThis as any).Buffer) { + return Uint8Array.from((globalThis as any).Buffer.from(b64, "base64")); + } else { + const bin = globalThis.atob(b64); + const arr = new Uint8Array(bin.length); + for (let i = 0; i < bin.length; ++i) { + arr[i] = bin.charCodeAt(i); + } + return arr; + } +} + +function base64FromBytes(arr: Uint8Array): string { + if ((globalThis as any).Buffer) { + return (globalThis as any).Buffer.from(arr).toString("base64"); + } else { + const bin: string[] = []; + arr.forEach((byte) => { + bin.push(globalThis.String.fromCharCode(byte)); + }); + return globalThis.btoa(bin.join("")); + } +} + +type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined; + +export type DeepPartial = T extends Builtin ? T + : T extends globalThis.Array ? globalThis.Array> + : T extends ReadonlyArray ? ReadonlyArray> + : T extends {} ? { [K in keyof T]?: DeepPartial } + : Partial; + +function longToNumber(int64: { toString(): string }): number { + const num = globalThis.Number(int64.toString()); + if (num > globalThis.Number.MAX_SAFE_INTEGER) { + throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER"); + } + if (num < globalThis.Number.MIN_SAFE_INTEGER) { + throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER"); + } + return num; +} + +function isSet(value: any): boolean { + return value !== null && value !== undefined; +} + +export interface MessageFns { + encode(message: T, writer?: BinaryWriter): BinaryWriter; + decode(input: BinaryReader | Uint8Array, length?: number): T; + fromJSON(object: any): T; + toJSON(message: T): unknown; + create(base?: DeepPartial): T; + fromPartial(object: DeepPartial): T; +} diff --git a/src/api/generated/google/protobuf/struct.ts b/src/api/generated/google/protobuf/struct.ts new file mode 100644 index 0000000..082ea47 --- /dev/null +++ b/src/api/generated/google/protobuf/struct.ts @@ -0,0 +1,627 @@ +// Code generated by protoc-gen-ts_proto. DO NOT EDIT. +// versions: +// protoc-gen-ts_proto v2.12.0 +// protoc v7.35.1 +// source: google/protobuf/struct.proto + +/* eslint-disable */ +import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire"; + +export const protobufPackage = "google.protobuf"; + +/** + * Represents a JSON `null`. + * + * `NullValue` is a sentinel, using an enum with only one value to represent + * the null value for the `Value` type union. + * + * A field of type `NullValue` with any value other than `0` is considered + * invalid. Most ProtoJSON serializers will emit a Value with a `null_value` set + * as a JSON `null` regardless of the integer value, and so will round trip to + * a `0` value. + */ +export enum NullValue { + /** NULL_VALUE - Null value. */ + NULL_VALUE = 0, + UNRECOGNIZED = -1, +} + +export function nullValueFromJSON(object: any): NullValue { + switch (object) { + case 0: + case "NULL_VALUE": + return NullValue.NULL_VALUE; + case -1: + case "UNRECOGNIZED": + default: + return NullValue.UNRECOGNIZED; + } +} + +export function nullValueToJSON(object: NullValue): string { + switch (object) { + case NullValue.NULL_VALUE: + return "NULL_VALUE"; + case NullValue.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +/** + * Represents a JSON object. + * + * An unordered key-value map, intending to perfectly capture the semantics of a + * JSON object. This enables parsing any arbitrary JSON payload as a message + * field in ProtoJSON format. + * + * This follows RFC 8259 guidelines for interoperable JSON: notably this type + * cannot represent large Int64 values or `NaN`/`Infinity` numbers, + * since the JSON format generally does not support those values in its number + * type. + * + * If you do not intend to parse arbitrary JSON into your message, a custom + * typed message should be preferred instead of using this type. + */ +export interface Struct { + /** Unordered map of dynamically typed values. */ + fields?: { [key: string]: any | undefined } | undefined; +} + +export interface Struct_FieldsEntry { + key: string; + value?: any | undefined; +} + +/** + * Represents a JSON 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 these + * variants. Absence of any variant is an invalid state. + */ +export interface Value { + /** Represents a JSON `null`. */ + nullValue?: + | NullValue + | undefined; + /** + * Represents a JSON number. Must not be `NaN`, `Infinity` or + * `-Infinity`, since those are not supported in JSON. This also cannot + * represent large Int64 values, since JSON format generally does not + * support them in its number type. + */ + numberValue?: + | number + | undefined; + /** Represents a JSON string. */ + stringValue?: + | string + | undefined; + /** Represents a JSON boolean (`true` or `false` literal in JSON). */ + boolValue?: + | boolean + | undefined; + /** Represents a JSON object. */ + structValue?: + | { [key: string]: any } + | undefined; + /** Represents a JSON array. */ + listValue?: Array | undefined; +} + +/** Represents a JSON array. */ +export interface ListValue { + /** Repeated field of dynamically typed values. */ + values?: any[] | undefined; +} + +function createBaseStruct(): Struct { + return { fields: {} }; +} + +export const Struct: MessageFns & StructWrapperFns = { + encode(message: Struct, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + globalThis.Object.entries(message.fields || {}).forEach(([key, value]: [string, any | undefined]) => { + if (value !== undefined) { + Struct_FieldsEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).join(); + } + }); + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Struct { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseStruct(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + const entry1 = Struct_FieldsEntry.decode(reader, reader.uint32()); + if (entry1.value !== undefined) { + message.fields![entry1.key] = entry1.value; + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Struct { + return { + fields: isObject(object.fields) + ? (globalThis.Object.entries(object.fields) as [string, any][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any]) => { + acc[key] = value as any | undefined; + return acc; + }, + {}, + ) + : {}, + }; + }, + + toJSON(message: Struct): unknown { + const obj: any = {}; + if (message.fields) { + const entries = globalThis.Object.entries(message.fields) as [string, any | undefined][]; + if (entries.length > 0) { + obj.fields = {}; + entries.forEach(([k, v]) => { + obj.fields[k] = v; + }); + } + } + return obj; + }, + + create(base?: DeepPartial): Struct { + return Struct.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Struct { + const message = createBaseStruct(); + message.fields = (globalThis.Object.entries(object.fields ?? {}) as [string, any | undefined][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any | undefined]) => { + if (value !== undefined) { + acc[key] = value; + } + return acc; + }, + {}, + ); + return message; + }, + + wrap(object: { [key: string]: any } | undefined): Struct { + const struct = createBaseStruct(); + struct.fields ??= {}; + if (object !== undefined) { + for (const key of globalThis.Object.keys(object)) { + struct.fields[key] = object[key]; + } + } + return struct; + }, + + unwrap(message: Struct): { [key: string]: any } { + const object: { [key: string]: any } = {}; + if (message.fields) { + for (const key of globalThis.Object.keys(message.fields)) { + object[key] = message.fields[key]; + } + } + return object; + }, +}; + +function createBaseStruct_FieldsEntry(): Struct_FieldsEntry { + return { key: "", value: undefined }; +} + +export const Struct_FieldsEntry: MessageFns = { + encode(message: Struct_FieldsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== undefined) { + Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Struct_FieldsEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseStruct_FieldsEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = Value.unwrap(Value.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Struct_FieldsEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object?.value) ? object.value : undefined, + }; + }, + + toJSON(message: Struct_FieldsEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== undefined) { + obj.value = message.value; + } + return obj; + }, + + create(base?: DeepPartial): Struct_FieldsEntry { + return Struct_FieldsEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Struct_FieldsEntry { + const message = createBaseStruct_FieldsEntry(); + message.key = object.key ?? ""; + message.value = object.value ?? undefined; + return message; + }, +}; + +function createBaseValue(): Value { + return { + nullValue: undefined, + numberValue: undefined, + stringValue: undefined, + boolValue: undefined, + structValue: undefined, + listValue: undefined, + }; +} + +export const Value: MessageFns & AnyValueWrapperFns = { + encode(message: Value, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.nullValue !== undefined) { + writer.uint32(8).int32(message.nullValue); + } + if (message.numberValue !== undefined) { + writer.uint32(17).double(message.numberValue); + } + if (message.stringValue !== undefined) { + writer.uint32(26).string(message.stringValue); + } + if (message.boolValue !== undefined) { + writer.uint32(32).bool(message.boolValue); + } + if (message.structValue !== undefined) { + Struct.encode(Struct.wrap(message.structValue), writer.uint32(42).fork()).join(); + } + if (message.listValue !== undefined) { + ListValue.encode(ListValue.wrap(message.listValue), writer.uint32(50).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Value { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseValue(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.nullValue = reader.int32() as any; + continue; + } + case 2: { + if (tag !== 17) { + break; + } + + message.numberValue = reader.double(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.stringValue = reader.string(); + continue; + } + case 4: { + if (tag !== 32) { + break; + } + + message.boolValue = reader.bool(); + continue; + } + case 5: { + if (tag !== 42) { + break; + } + + message.structValue = Struct.unwrap(Struct.decode(reader, reader.uint32())); + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + message.listValue = ListValue.unwrap(ListValue.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Value { + return { + nullValue: isSet(object.nullValue) + ? nullValueFromJSON(object.nullValue) + : isSet(object.null_value) + ? nullValueFromJSON(object.null_value) + : undefined, + numberValue: isSet(object.numberValue) + ? globalThis.Number(object.numberValue) + : isSet(object.number_value) + ? globalThis.Number(object.number_value) + : undefined, + stringValue: isSet(object.stringValue) + ? globalThis.String(object.stringValue) + : isSet(object.string_value) + ? globalThis.String(object.string_value) + : undefined, + boolValue: isSet(object.boolValue) + ? globalThis.Boolean(object.boolValue) + : isSet(object.bool_value) + ? globalThis.Boolean(object.bool_value) + : undefined, + structValue: isObject(object.structValue) + ? object.structValue + : isObject(object.struct_value) + ? object.struct_value + : undefined, + listValue: globalThis.Array.isArray(object.listValue) + ? [...object.listValue] + : globalThis.Array.isArray(object.list_value) + ? [...object.list_value] + : undefined, + }; + }, + + toJSON(message: Value): unknown { + const obj: any = {}; + if (message.nullValue !== undefined) { + obj.nullValue = nullValueToJSON(message.nullValue); + } + if (message.numberValue !== undefined) { + obj.numberValue = message.numberValue; + } + if (message.stringValue !== undefined) { + obj.stringValue = message.stringValue; + } + if (message.boolValue !== undefined) { + obj.boolValue = message.boolValue; + } + if (message.structValue !== undefined) { + obj.structValue = message.structValue; + } + if (message.listValue !== undefined) { + obj.listValue = message.listValue; + } + return obj; + }, + + create(base?: DeepPartial): Value { + return Value.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Value { + const message = createBaseValue(); + message.nullValue = object.nullValue ?? undefined; + message.numberValue = object.numberValue ?? undefined; + message.stringValue = object.stringValue ?? undefined; + message.boolValue = object.boolValue ?? undefined; + message.structValue = object.structValue ?? undefined; + message.listValue = object.listValue ?? undefined; + return message; + }, + + wrap(value: any): Value { + const result = createBaseValue(); + if (value === null) { + result.nullValue = NullValue.NULL_VALUE; + } else if (typeof value === "boolean") { + result.boolValue = value; + } else if (typeof value === "number") { + result.numberValue = value; + } else if (typeof value === "string") { + result.stringValue = value; + } else if (globalThis.Array.isArray(value)) { + result.listValue = value; + } else if (typeof value === "object") { + result.structValue = value; + } else if (typeof value !== "undefined") { + throw new globalThis.Error("Unsupported any value type: " + typeof value); + } + return result; + }, + + unwrap(message: any): string | number | boolean | Object | null | Array | undefined { + if (message.stringValue !== undefined) { + return message.stringValue; + } else if (message?.numberValue !== undefined) { + return message.numberValue; + } else if (message?.boolValue !== undefined) { + return message.boolValue; + } else if (message?.structValue !== undefined) { + return message.structValue as any; + } else if (message?.listValue !== undefined) { + return message.listValue; + } else if (message?.nullValue !== undefined) { + return null; + } + return undefined; + }, +}; + +function createBaseListValue(): ListValue { + return { values: [] }; +} + +export const ListValue: MessageFns & ListValueWrapperFns = { + encode(message: ListValue, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.values !== undefined && message.values.length !== 0) { + for (const v of message.values) { + Value.encode(Value.wrap(v!), writer.uint32(10).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): ListValue { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseListValue(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + const el = Value.unwrap(Value.decode(reader, reader.uint32())); + if (el !== undefined) { + message.values!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): ListValue { + return { values: globalThis.Array.isArray(object?.values) ? [...object.values] : [] }; + }, + + toJSON(message: ListValue): unknown { + const obj: any = {}; + if (message.values?.length) { + obj.values = message.values; + } + return obj; + }, + + create(base?: DeepPartial): ListValue { + return ListValue.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): ListValue { + const message = createBaseListValue(); + message.values = object.values?.map((e) => e) || []; + return message; + }, + + wrap(array: Array | undefined): ListValue { + const result = createBaseListValue(); + result.values = array ?? []; + return result; + }, + + unwrap(message: ListValue): Array { + if (message?.hasOwnProperty("values") && globalThis.Array.isArray(message.values)) { + return message.values; + } else { + return message as any; + } + }, +}; + +type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined; + +export type DeepPartial = T extends Builtin ? T + : T extends globalThis.Array ? globalThis.Array> + : T extends ReadonlyArray ? ReadonlyArray> + : T extends {} ? { [K in keyof T]?: DeepPartial } + : Partial; + +function isObject(value: any): boolean { + return typeof value === "object" && value !== null; +} + +function isSet(value: any): boolean { + return value !== null && value !== undefined; +} + +export interface MessageFns { + encode(message: T, writer?: BinaryWriter): BinaryWriter; + decode(input: BinaryReader | Uint8Array, length?: number): T; + fromJSON(object: any): T; + toJSON(message: T): unknown; + create(base?: DeepPartial): T; + fromPartial(object: DeepPartial): T; +} + +export interface StructWrapperFns { + wrap(object: { [key: string]: any } | undefined): Struct; + unwrap(message: Struct): { [key: string]: any }; +} + +export interface AnyValueWrapperFns { + wrap(value: any): Value; + unwrap(message: any): string | number | boolean | Object | null | Array | undefined; +} + +export interface ListValueWrapperFns { + wrap(array: Array | undefined): ListValue; + unwrap(message: ListValue): Array; +} diff --git a/src/api/generated/google/protobuf/timestamp.ts b/src/api/generated/google/protobuf/timestamp.ts new file mode 100644 index 0000000..1aeafeb --- /dev/null +++ b/src/api/generated/google/protobuf/timestamp.ts @@ -0,0 +1,228 @@ +// Code generated by protoc-gen-ts_proto. DO NOT EDIT. +// versions: +// protoc-gen-ts_proto v2.12.0 +// protoc v7.35.1 +// source: google/protobuf/timestamp.proto + +/* eslint-disable */ +import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire"; + +export const protobufPackage = "google.protobuf"; + +/** + * 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 Java `Instant.now()`. + * + * Instant now = Instant.now(); + * + * Timestamp timestamp = + * Timestamp.newBuilder().setSeconds(now.getEpochSecond()) + * .setNanos(now.getNano()).build(); + * + * Example 6: 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 ProtoJSON serializer should always use UTC (as indicated by + * "Z") when printing the Timestamp type and a ProtoJSON 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime() + * ) to obtain a formatter capable of generating timestamps in this format. + */ +export interface Timestamp { + /** + * Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must + * be between -62135596800 and 253402300799 inclusive (which corresponds to + * 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z). + */ + seconds?: + | number + | undefined; + /** + * Non-negative fractions of a second at nanosecond resolution. This field is + * the nanosecond portion of the duration, not an alternative to seconds. + * Negative second values with fractions must still have non-negative nanos + * values that count forward in time. Must be between 0 and 999,999,999 + * inclusive. + */ + nanos?: number | undefined; +} + +function createBaseTimestamp(): Timestamp { + return { seconds: 0, nanos: 0 }; +} + +export const Timestamp: MessageFns = { + encode(message: Timestamp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.seconds !== undefined && message.seconds !== 0) { + writer.uint32(8).int64(message.seconds); + } + if (message.nanos !== undefined && message.nanos !== 0) { + writer.uint32(16).int32(message.nanos); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Timestamp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseTimestamp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.seconds = longToNumber(reader.int64()); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.nanos = reader.int32(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Timestamp { + return { + seconds: isSet(object.seconds) ? globalThis.Number(object.seconds) : 0, + nanos: isSet(object.nanos) ? globalThis.Number(object.nanos) : 0, + }; + }, + + toJSON(message: Timestamp): unknown { + const obj: any = {}; + if (message.seconds !== undefined && message.seconds !== 0) { + obj.seconds = Math.round(message.seconds); + } + if (message.nanos !== undefined && message.nanos !== 0) { + obj.nanos = Math.round(message.nanos); + } + return obj; + }, + + create(base?: DeepPartial): Timestamp { + return Timestamp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Timestamp { + const message = createBaseTimestamp(); + message.seconds = object.seconds ?? 0; + message.nanos = object.nanos ?? 0; + return message; + }, +}; + +type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined; + +export type DeepPartial = T extends Builtin ? T + : T extends globalThis.Array ? globalThis.Array> + : T extends ReadonlyArray ? ReadonlyArray> + : T extends {} ? { [K in keyof T]?: DeepPartial } + : Partial; + +function longToNumber(int64: { toString(): string }): number { + const num = globalThis.Number(int64.toString()); + if (num > globalThis.Number.MAX_SAFE_INTEGER) { + throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER"); + } + if (num < globalThis.Number.MIN_SAFE_INTEGER) { + throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER"); + } + return num; +} + +function isSet(value: any): boolean { + return value !== null && value !== undefined; +} + +export interface MessageFns { + encode(message: T, writer?: BinaryWriter): BinaryWriter; + decode(input: BinaryReader | Uint8Array, length?: number): T; + fromJSON(object: any): T; + toJSON(message: T): unknown; + create(base?: DeepPartial): T; + fromPartial(object: DeepPartial): T; +} diff --git a/src/api/generated/main.ts b/src/api/generated/main.ts new file mode 100644 index 0000000..98a5809 --- /dev/null +++ b/src/api/generated/main.ts @@ -0,0 +1,4041 @@ +// Code generated by protoc-gen-ts_proto. DO NOT EDIT. +// versions: +// protoc-gen-ts_proto v2.12.0 +// protoc v7.35.1 +// source: main.proto + +/* eslint-disable */ +import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire"; +import { HttpBody } from "./google/api/httpbody"; +import { Timestamp } from "./google/protobuf/timestamp"; + +export const protobufPackage = "crabs.evening_detective_server"; + +export interface PingReq { +} + +export interface PingRsp { +} + +export interface EchoReq { + text?: string | undefined; +} + +export interface EchoRsp { + text?: string | undefined; +} + +export interface SignupReq { + username?: string | undefined; + email?: string | undefined; +} + +export interface SignupRsp { + error?: string | undefined; +} + +export interface RefreshPasswordReq { + email?: string | undefined; +} + +export interface RefreshPasswordRsp { + error?: string | undefined; +} + +export interface LoginReq { + email?: string | undefined; + password?: string | undefined; +} + +export interface LoginRsp { + error?: string | undefined; + accessToken?: string | undefined; + refreshToken?: string | undefined; +} + +export interface RefreshReq { + refreshToken?: string | undefined; +} + +export interface RefreshRsp { + error?: string | undefined; + accessToken?: string | undefined; + refreshToken?: string | undefined; +} + +export interface GetUsersReq { +} + +export interface GetUsersRsp { + error?: string | undefined; + users?: User[] | undefined; +} + +export interface User { + id?: number | undefined; + username?: string | undefined; + email?: string | undefined; + roles?: string[] | undefined; + isActive?: boolean | undefined; + createdAt?: Date | undefined; +} + +export interface GetUserByIdReq { + id?: number | undefined; +} + +export interface GetUserByIdRsp { + error?: string | undefined; + user?: User | undefined; +} + +export interface GetMeReq { +} + +export interface GetMeRsp { + error?: string | undefined; + user?: User | undefined; +} + +export interface AddUserRoleReq { + id?: number | undefined; + role?: string | undefined; +} + +export interface AddUserRoleRsp { + error?: string | undefined; +} + +export interface DeleteUserRoleReq { + id?: number | undefined; + role?: string | undefined; +} + +export interface DeleteUserRoleRsp { + error?: string | undefined; +} + +export interface GetPermissionsReq { +} + +export interface GetPermissionsRsp { + error?: string | undefined; + permissions?: string[] | undefined; +} + +export interface UploadFileReq { + filename?: string | undefined; + data?: Uint8Array | undefined; +} + +export interface UploadFileRsp { + error?: string | undefined; + filename?: string | undefined; +} + +export interface DownloadFileReq { + filename?: string | undefined; +} + +export interface AddScenarioReq { + name?: string | undefined; +} + +export interface AddScenarioRsp { + error?: string | undefined; + id?: number | undefined; +} + +export interface GetMyScenariosReq { +} + +export interface GetMyScenariosRsp { + error?: string | undefined; + scenarios?: Scenario[] | undefined; +} + +export interface GetScenarioReq { + id?: number | undefined; +} + +export interface GetScenarioRsp { + error?: string | undefined; + scenario?: Scenario | undefined; +} + +export interface Scenario { + id?: number | undefined; + name?: string | undefined; + description?: string | undefined; + image?: string | undefined; + story?: Story | undefined; + author?: User | undefined; + updatedAt?: Date | undefined; + createdAt?: Date | undefined; + publishedAt?: Date | undefined; +} + +export interface Story { + places?: Place[] | undefined; +} + +export interface Place { + code?: string | undefined; + name?: string | undefined; + text?: string | undefined; + image?: string | undefined; + hidden?: boolean | undefined; + applications?: Application[] | undefined; + doors?: Door[] | undefined; + keys?: Key[] | undefined; +} + +export interface Application { + name?: string | undefined; + image?: string | undefined; +} + +export interface Door { + code?: string | undefined; + name?: string | undefined; + keys?: Key[] | undefined; +} + +export interface Key { + name?: string | undefined; +} + +export interface UpdateScenarioReq { + id?: number | undefined; + name?: string | undefined; + description?: string | undefined; + image?: string | undefined; +} + +export interface UpdateScenarioRsp { + error?: string | undefined; +} + +export interface DeleteScenarioReq { + id?: number | undefined; +} + +export interface DeleteScenarioRsp { + error?: string | undefined; +} + +export interface AddScenarioPlaceReq { + id?: number | undefined; + place?: Place | undefined; +} + +export interface AddScenarioPlaceRsp { + error?: string | undefined; +} + +export interface UpdateScenarioPlaceReq { + id?: number | undefined; + code?: string | undefined; + place?: Place | undefined; +} + +export interface UpdateScenarioPlaceRsp { + error?: string | undefined; +} + +export interface DeleteScenarioPlaceReq { + id?: number | undefined; + code?: string | undefined; +} + +export interface DeleteScenarioPlaceRsp { + error?: string | undefined; +} + +function createBasePingReq(): PingReq { + return {}; +} + +export const PingReq: MessageFns = { + encode(_: PingReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): PingReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBasePingReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(_: any): PingReq { + return {}; + }, + + toJSON(_: PingReq): unknown { + const obj: any = {}; + return obj; + }, + + create(base?: DeepPartial): PingReq { + return PingReq.fromPartial(base ?? {}); + }, + fromPartial(_: DeepPartial): PingReq { + const message = createBasePingReq(); + return message; + }, +}; + +function createBasePingRsp(): PingRsp { + return {}; +} + +export const PingRsp: MessageFns = { + encode(_: PingRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): PingRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBasePingRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(_: any): PingRsp { + return {}; + }, + + toJSON(_: PingRsp): unknown { + const obj: any = {}; + return obj; + }, + + create(base?: DeepPartial): PingRsp { + return PingRsp.fromPartial(base ?? {}); + }, + fromPartial(_: DeepPartial): PingRsp { + const message = createBasePingRsp(); + return message; + }, +}; + +function createBaseEchoReq(): EchoReq { + return { text: "" }; +} + +export const EchoReq: MessageFns = { + encode(message: EchoReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.text !== undefined && message.text !== "") { + writer.uint32(10).string(message.text); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): EchoReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEchoReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.text = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): EchoReq { + return { text: isSet(object.text) ? globalThis.String(object.text) : "" }; + }, + + toJSON(message: EchoReq): unknown { + const obj: any = {}; + if (message.text !== undefined && message.text !== "") { + obj.text = message.text; + } + return obj; + }, + + create(base?: DeepPartial): EchoReq { + return EchoReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): EchoReq { + const message = createBaseEchoReq(); + message.text = object.text ?? ""; + return message; + }, +}; + +function createBaseEchoRsp(): EchoRsp { + return { text: "" }; +} + +export const EchoRsp: MessageFns = { + encode(message: EchoRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.text !== undefined && message.text !== "") { + writer.uint32(10).string(message.text); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): EchoRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEchoRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.text = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): EchoRsp { + return { text: isSet(object.text) ? globalThis.String(object.text) : "" }; + }, + + toJSON(message: EchoRsp): unknown { + const obj: any = {}; + if (message.text !== undefined && message.text !== "") { + obj.text = message.text; + } + return obj; + }, + + create(base?: DeepPartial): EchoRsp { + return EchoRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): EchoRsp { + const message = createBaseEchoRsp(); + message.text = object.text ?? ""; + return message; + }, +}; + +function createBaseSignupReq(): SignupReq { + return { username: "", email: "" }; +} + +export const SignupReq: MessageFns = { + encode(message: SignupReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.username !== undefined && message.username !== "") { + writer.uint32(10).string(message.username); + } + if (message.email !== undefined && message.email !== "") { + writer.uint32(18).string(message.email); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): SignupReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSignupReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.username = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.email = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): SignupReq { + return { + username: isSet(object.username) ? globalThis.String(object.username) : "", + email: isSet(object.email) ? globalThis.String(object.email) : "", + }; + }, + + toJSON(message: SignupReq): unknown { + const obj: any = {}; + if (message.username !== undefined && message.username !== "") { + obj.username = message.username; + } + if (message.email !== undefined && message.email !== "") { + obj.email = message.email; + } + return obj; + }, + + create(base?: DeepPartial): SignupReq { + return SignupReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): SignupReq { + const message = createBaseSignupReq(); + message.username = object.username ?? ""; + message.email = object.email ?? ""; + return message; + }, +}; + +function createBaseSignupRsp(): SignupRsp { + return { error: "" }; +} + +export const SignupRsp: MessageFns = { + encode(message: SignupRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): SignupRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSignupRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): SignupRsp { + return { error: isSet(object.error) ? globalThis.String(object.error) : "" }; + }, + + toJSON(message: SignupRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + return obj; + }, + + create(base?: DeepPartial): SignupRsp { + return SignupRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): SignupRsp { + const message = createBaseSignupRsp(); + message.error = object.error ?? ""; + return message; + }, +}; + +function createBaseRefreshPasswordReq(): RefreshPasswordReq { + return { email: "" }; +} + +export const RefreshPasswordReq: MessageFns = { + encode(message: RefreshPasswordReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.email !== undefined && message.email !== "") { + writer.uint32(10).string(message.email); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): RefreshPasswordReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRefreshPasswordReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.email = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): RefreshPasswordReq { + return { email: isSet(object.email) ? globalThis.String(object.email) : "" }; + }, + + toJSON(message: RefreshPasswordReq): unknown { + const obj: any = {}; + if (message.email !== undefined && message.email !== "") { + obj.email = message.email; + } + return obj; + }, + + create(base?: DeepPartial): RefreshPasswordReq { + return RefreshPasswordReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): RefreshPasswordReq { + const message = createBaseRefreshPasswordReq(); + message.email = object.email ?? ""; + return message; + }, +}; + +function createBaseRefreshPasswordRsp(): RefreshPasswordRsp { + return { error: "" }; +} + +export const RefreshPasswordRsp: MessageFns = { + encode(message: RefreshPasswordRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): RefreshPasswordRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRefreshPasswordRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): RefreshPasswordRsp { + return { error: isSet(object.error) ? globalThis.String(object.error) : "" }; + }, + + toJSON(message: RefreshPasswordRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + return obj; + }, + + create(base?: DeepPartial): RefreshPasswordRsp { + return RefreshPasswordRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): RefreshPasswordRsp { + const message = createBaseRefreshPasswordRsp(); + message.error = object.error ?? ""; + return message; + }, +}; + +function createBaseLoginReq(): LoginReq { + return { email: "", password: "" }; +} + +export const LoginReq: MessageFns = { + encode(message: LoginReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.email !== undefined && message.email !== "") { + writer.uint32(10).string(message.email); + } + if (message.password !== undefined && message.password !== "") { + writer.uint32(18).string(message.password); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): LoginReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoginReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.email = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.password = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): LoginReq { + return { + email: isSet(object.email) ? globalThis.String(object.email) : "", + password: isSet(object.password) ? globalThis.String(object.password) : "", + }; + }, + + toJSON(message: LoginReq): unknown { + const obj: any = {}; + if (message.email !== undefined && message.email !== "") { + obj.email = message.email; + } + if (message.password !== undefined && message.password !== "") { + obj.password = message.password; + } + return obj; + }, + + create(base?: DeepPartial): LoginReq { + return LoginReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): LoginReq { + const message = createBaseLoginReq(); + message.email = object.email ?? ""; + message.password = object.password ?? ""; + return message; + }, +}; + +function createBaseLoginRsp(): LoginRsp { + return { error: "", accessToken: "", refreshToken: "" }; +} + +export const LoginRsp: MessageFns = { + encode(message: LoginRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + if (message.accessToken !== undefined && message.accessToken !== "") { + writer.uint32(18).string(message.accessToken); + } + if (message.refreshToken !== undefined && message.refreshToken !== "") { + writer.uint32(26).string(message.refreshToken); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): LoginRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLoginRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.accessToken = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.refreshToken = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): LoginRsp { + return { + error: isSet(object.error) ? globalThis.String(object.error) : "", + accessToken: isSet(object.accessToken) ? globalThis.String(object.accessToken) : "", + refreshToken: isSet(object.refreshToken) ? globalThis.String(object.refreshToken) : "", + }; + }, + + toJSON(message: LoginRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + if (message.accessToken !== undefined && message.accessToken !== "") { + obj.accessToken = message.accessToken; + } + if (message.refreshToken !== undefined && message.refreshToken !== "") { + obj.refreshToken = message.refreshToken; + } + return obj; + }, + + create(base?: DeepPartial): LoginRsp { + return LoginRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): LoginRsp { + const message = createBaseLoginRsp(); + message.error = object.error ?? ""; + message.accessToken = object.accessToken ?? ""; + message.refreshToken = object.refreshToken ?? ""; + return message; + }, +}; + +function createBaseRefreshReq(): RefreshReq { + return { refreshToken: "" }; +} + +export const RefreshReq: MessageFns = { + encode(message: RefreshReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.refreshToken !== undefined && message.refreshToken !== "") { + writer.uint32(10).string(message.refreshToken); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): RefreshReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRefreshReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.refreshToken = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): RefreshReq { + return { refreshToken: isSet(object.refreshToken) ? globalThis.String(object.refreshToken) : "" }; + }, + + toJSON(message: RefreshReq): unknown { + const obj: any = {}; + if (message.refreshToken !== undefined && message.refreshToken !== "") { + obj.refreshToken = message.refreshToken; + } + return obj; + }, + + create(base?: DeepPartial): RefreshReq { + return RefreshReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): RefreshReq { + const message = createBaseRefreshReq(); + message.refreshToken = object.refreshToken ?? ""; + return message; + }, +}; + +function createBaseRefreshRsp(): RefreshRsp { + return { error: "", accessToken: "", refreshToken: "" }; +} + +export const RefreshRsp: MessageFns = { + encode(message: RefreshRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + if (message.accessToken !== undefined && message.accessToken !== "") { + writer.uint32(18).string(message.accessToken); + } + if (message.refreshToken !== undefined && message.refreshToken !== "") { + writer.uint32(26).string(message.refreshToken); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): RefreshRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseRefreshRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.accessToken = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.refreshToken = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): RefreshRsp { + return { + error: isSet(object.error) ? globalThis.String(object.error) : "", + accessToken: isSet(object.accessToken) ? globalThis.String(object.accessToken) : "", + refreshToken: isSet(object.refreshToken) ? globalThis.String(object.refreshToken) : "", + }; + }, + + toJSON(message: RefreshRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + if (message.accessToken !== undefined && message.accessToken !== "") { + obj.accessToken = message.accessToken; + } + if (message.refreshToken !== undefined && message.refreshToken !== "") { + obj.refreshToken = message.refreshToken; + } + return obj; + }, + + create(base?: DeepPartial): RefreshRsp { + return RefreshRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): RefreshRsp { + const message = createBaseRefreshRsp(); + message.error = object.error ?? ""; + message.accessToken = object.accessToken ?? ""; + message.refreshToken = object.refreshToken ?? ""; + return message; + }, +}; + +function createBaseGetUsersReq(): GetUsersReq { + return {}; +} + +export const GetUsersReq: MessageFns = { + encode(_: GetUsersReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): GetUsersReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGetUsersReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(_: any): GetUsersReq { + return {}; + }, + + toJSON(_: GetUsersReq): unknown { + const obj: any = {}; + return obj; + }, + + create(base?: DeepPartial): GetUsersReq { + return GetUsersReq.fromPartial(base ?? {}); + }, + fromPartial(_: DeepPartial): GetUsersReq { + const message = createBaseGetUsersReq(); + return message; + }, +}; + +function createBaseGetUsersRsp(): GetUsersRsp { + return { error: "", users: [] }; +} + +export const GetUsersRsp: MessageFns = { + encode(message: GetUsersRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + if (message.users !== undefined && message.users.length !== 0) { + for (const v of message.users) { + User.encode(v!, writer.uint32(18).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): GetUsersRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGetUsersRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + const el = User.decode(reader, reader.uint32()); + if (el !== undefined) { + message.users!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): GetUsersRsp { + return { + error: isSet(object.error) ? globalThis.String(object.error) : "", + users: globalThis.Array.isArray(object?.users) ? object.users.map((e: any) => User.fromJSON(e)) : [], + }; + }, + + toJSON(message: GetUsersRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + if (message.users?.length) { + obj.users = message.users.map((e) => User.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): GetUsersRsp { + return GetUsersRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GetUsersRsp { + const message = createBaseGetUsersRsp(); + message.error = object.error ?? ""; + message.users = object.users?.map((e) => User.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseUser(): User { + return { id: 0, username: "", email: "", roles: [], isActive: false, createdAt: undefined }; +} + +export const User: MessageFns = { + encode(message: User, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.id !== undefined && message.id !== 0) { + writer.uint32(8).int32(message.id); + } + if (message.username !== undefined && message.username !== "") { + writer.uint32(18).string(message.username); + } + if (message.email !== undefined && message.email !== "") { + writer.uint32(26).string(message.email); + } + if (message.roles !== undefined && message.roles.length !== 0) { + for (const v of message.roles) { + writer.uint32(34).string(v!); + } + } + if (message.isActive !== undefined && message.isActive !== false) { + writer.uint32(40).bool(message.isActive); + } + if (message.createdAt !== undefined) { + Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(50).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): User { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUser(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.id = reader.int32(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.username = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.email = reader.string(); + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.roles!.push(el); + } + continue; + } + case 5: { + if (tag !== 40) { + break; + } + + message.isActive = reader.bool(); + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): User { + return { + id: isSet(object.id) ? globalThis.Number(object.id) : 0, + username: isSet(object.username) ? globalThis.String(object.username) : "", + email: isSet(object.email) ? globalThis.String(object.email) : "", + roles: globalThis.Array.isArray(object?.roles) ? object.roles.map((e: any) => globalThis.String(e)) : [], + isActive: isSet(object.isActive) + ? globalThis.Boolean(object.isActive) + : isSet(object.is_active) + ? globalThis.Boolean(object.is_active) + : false, + createdAt: isSet(object.createdAt) + ? fromJsonTimestamp(object.createdAt) + : isSet(object.created_at) + ? fromJsonTimestamp(object.created_at) + : undefined, + }; + }, + + toJSON(message: User): unknown { + const obj: any = {}; + if (message.id !== undefined && message.id !== 0) { + obj.id = Math.round(message.id); + } + if (message.username !== undefined && message.username !== "") { + obj.username = message.username; + } + if (message.email !== undefined && message.email !== "") { + obj.email = message.email; + } + if (message.roles?.length) { + obj.roles = message.roles; + } + if (message.isActive !== undefined && message.isActive !== false) { + obj.isActive = message.isActive; + } + if (message.createdAt !== undefined) { + obj.createdAt = message.createdAt.toISOString(); + } + return obj; + }, + + create(base?: DeepPartial): User { + return User.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): User { + const message = createBaseUser(); + message.id = object.id ?? 0; + message.username = object.username ?? ""; + message.email = object.email ?? ""; + message.roles = object.roles?.map((e) => e) || []; + message.isActive = object.isActive ?? false; + message.createdAt = object.createdAt ?? undefined; + return message; + }, +}; + +function createBaseGetUserByIdReq(): GetUserByIdReq { + return { id: 0 }; +} + +export const GetUserByIdReq: MessageFns = { + encode(message: GetUserByIdReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.id !== undefined && message.id !== 0) { + writer.uint32(8).int32(message.id); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): GetUserByIdReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGetUserByIdReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.id = reader.int32(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): GetUserByIdReq { + return { id: isSet(object.id) ? globalThis.Number(object.id) : 0 }; + }, + + toJSON(message: GetUserByIdReq): unknown { + const obj: any = {}; + if (message.id !== undefined && message.id !== 0) { + obj.id = Math.round(message.id); + } + return obj; + }, + + create(base?: DeepPartial): GetUserByIdReq { + return GetUserByIdReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GetUserByIdReq { + const message = createBaseGetUserByIdReq(); + message.id = object.id ?? 0; + return message; + }, +}; + +function createBaseGetUserByIdRsp(): GetUserByIdRsp { + return { error: "", user: undefined }; +} + +export const GetUserByIdRsp: MessageFns = { + encode(message: GetUserByIdRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + if (message.user !== undefined) { + User.encode(message.user, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): GetUserByIdRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGetUserByIdRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.user = User.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): GetUserByIdRsp { + return { + error: isSet(object.error) ? globalThis.String(object.error) : "", + user: isSet(object.user) ? User.fromJSON(object.user) : undefined, + }; + }, + + toJSON(message: GetUserByIdRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + if (message.user !== undefined) { + obj.user = User.toJSON(message.user); + } + return obj; + }, + + create(base?: DeepPartial): GetUserByIdRsp { + return GetUserByIdRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GetUserByIdRsp { + const message = createBaseGetUserByIdRsp(); + message.error = object.error ?? ""; + message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined; + return message; + }, +}; + +function createBaseGetMeReq(): GetMeReq { + return {}; +} + +export const GetMeReq: MessageFns = { + encode(_: GetMeReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): GetMeReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGetMeReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(_: any): GetMeReq { + return {}; + }, + + toJSON(_: GetMeReq): unknown { + const obj: any = {}; + return obj; + }, + + create(base?: DeepPartial): GetMeReq { + return GetMeReq.fromPartial(base ?? {}); + }, + fromPartial(_: DeepPartial): GetMeReq { + const message = createBaseGetMeReq(); + return message; + }, +}; + +function createBaseGetMeRsp(): GetMeRsp { + return { error: "", user: undefined }; +} + +export const GetMeRsp: MessageFns = { + encode(message: GetMeRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + if (message.user !== undefined) { + User.encode(message.user, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): GetMeRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGetMeRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.user = User.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): GetMeRsp { + return { + error: isSet(object.error) ? globalThis.String(object.error) : "", + user: isSet(object.user) ? User.fromJSON(object.user) : undefined, + }; + }, + + toJSON(message: GetMeRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + if (message.user !== undefined) { + obj.user = User.toJSON(message.user); + } + return obj; + }, + + create(base?: DeepPartial): GetMeRsp { + return GetMeRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GetMeRsp { + const message = createBaseGetMeRsp(); + message.error = object.error ?? ""; + message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined; + return message; + }, +}; + +function createBaseAddUserRoleReq(): AddUserRoleReq { + return { id: 0, role: "" }; +} + +export const AddUserRoleReq: MessageFns = { + encode(message: AddUserRoleReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.id !== undefined && message.id !== 0) { + writer.uint32(8).int32(message.id); + } + if (message.role !== undefined && message.role !== "") { + writer.uint32(18).string(message.role); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): AddUserRoleReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseAddUserRoleReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.id = reader.int32(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.role = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): AddUserRoleReq { + return { + id: isSet(object.id) ? globalThis.Number(object.id) : 0, + role: isSet(object.role) ? globalThis.String(object.role) : "", + }; + }, + + toJSON(message: AddUserRoleReq): unknown { + const obj: any = {}; + if (message.id !== undefined && message.id !== 0) { + obj.id = Math.round(message.id); + } + if (message.role !== undefined && message.role !== "") { + obj.role = message.role; + } + return obj; + }, + + create(base?: DeepPartial): AddUserRoleReq { + return AddUserRoleReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): AddUserRoleReq { + const message = createBaseAddUserRoleReq(); + message.id = object.id ?? 0; + message.role = object.role ?? ""; + return message; + }, +}; + +function createBaseAddUserRoleRsp(): AddUserRoleRsp { + return { error: "" }; +} + +export const AddUserRoleRsp: MessageFns = { + encode(message: AddUserRoleRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): AddUserRoleRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseAddUserRoleRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): AddUserRoleRsp { + return { error: isSet(object.error) ? globalThis.String(object.error) : "" }; + }, + + toJSON(message: AddUserRoleRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + return obj; + }, + + create(base?: DeepPartial): AddUserRoleRsp { + return AddUserRoleRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): AddUserRoleRsp { + const message = createBaseAddUserRoleRsp(); + message.error = object.error ?? ""; + return message; + }, +}; + +function createBaseDeleteUserRoleReq(): DeleteUserRoleReq { + return { id: 0, role: "" }; +} + +export const DeleteUserRoleReq: MessageFns = { + encode(message: DeleteUserRoleReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.id !== undefined && message.id !== 0) { + writer.uint32(8).int32(message.id); + } + if (message.role !== undefined && message.role !== "") { + writer.uint32(18).string(message.role); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): DeleteUserRoleReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseDeleteUserRoleReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.id = reader.int32(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.role = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): DeleteUserRoleReq { + return { + id: isSet(object.id) ? globalThis.Number(object.id) : 0, + role: isSet(object.role) ? globalThis.String(object.role) : "", + }; + }, + + toJSON(message: DeleteUserRoleReq): unknown { + const obj: any = {}; + if (message.id !== undefined && message.id !== 0) { + obj.id = Math.round(message.id); + } + if (message.role !== undefined && message.role !== "") { + obj.role = message.role; + } + return obj; + }, + + create(base?: DeepPartial): DeleteUserRoleReq { + return DeleteUserRoleReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): DeleteUserRoleReq { + const message = createBaseDeleteUserRoleReq(); + message.id = object.id ?? 0; + message.role = object.role ?? ""; + return message; + }, +}; + +function createBaseDeleteUserRoleRsp(): DeleteUserRoleRsp { + return { error: "" }; +} + +export const DeleteUserRoleRsp: MessageFns = { + encode(message: DeleteUserRoleRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): DeleteUserRoleRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseDeleteUserRoleRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): DeleteUserRoleRsp { + return { error: isSet(object.error) ? globalThis.String(object.error) : "" }; + }, + + toJSON(message: DeleteUserRoleRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + return obj; + }, + + create(base?: DeepPartial): DeleteUserRoleRsp { + return DeleteUserRoleRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): DeleteUserRoleRsp { + const message = createBaseDeleteUserRoleRsp(); + message.error = object.error ?? ""; + return message; + }, +}; + +function createBaseGetPermissionsReq(): GetPermissionsReq { + return {}; +} + +export const GetPermissionsReq: MessageFns = { + encode(_: GetPermissionsReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): GetPermissionsReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGetPermissionsReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(_: any): GetPermissionsReq { + return {}; + }, + + toJSON(_: GetPermissionsReq): unknown { + const obj: any = {}; + return obj; + }, + + create(base?: DeepPartial): GetPermissionsReq { + return GetPermissionsReq.fromPartial(base ?? {}); + }, + fromPartial(_: DeepPartial): GetPermissionsReq { + const message = createBaseGetPermissionsReq(); + return message; + }, +}; + +function createBaseGetPermissionsRsp(): GetPermissionsRsp { + return { error: "", permissions: [] }; +} + +export const GetPermissionsRsp: MessageFns = { + encode(message: GetPermissionsRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + if (message.permissions !== undefined && message.permissions.length !== 0) { + for (const v of message.permissions) { + writer.uint32(18).string(v!); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): GetPermissionsRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGetPermissionsRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.permissions!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): GetPermissionsRsp { + return { + error: isSet(object.error) ? globalThis.String(object.error) : "", + permissions: globalThis.Array.isArray(object?.permissions) + ? object.permissions.map((e: any) => globalThis.String(e)) + : [], + }; + }, + + toJSON(message: GetPermissionsRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + if (message.permissions?.length) { + obj.permissions = message.permissions; + } + return obj; + }, + + create(base?: DeepPartial): GetPermissionsRsp { + return GetPermissionsRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GetPermissionsRsp { + const message = createBaseGetPermissionsRsp(); + message.error = object.error ?? ""; + message.permissions = object.permissions?.map((e) => e) || []; + return message; + }, +}; + +function createBaseUploadFileReq(): UploadFileReq { + return { filename: "", data: new Uint8Array(0) }; +} + +export const UploadFileReq: MessageFns = { + encode(message: UploadFileReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.filename !== undefined && message.filename !== "") { + writer.uint32(10).string(message.filename); + } + if (message.data !== undefined && message.data.length !== 0) { + writer.uint32(18).bytes(message.data); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): UploadFileReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUploadFileReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.filename = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.data = reader.bytes(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): UploadFileReq { + return { + filename: isSet(object.filename) ? globalThis.String(object.filename) : "", + data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(0), + }; + }, + + toJSON(message: UploadFileReq): unknown { + const obj: any = {}; + if (message.filename !== undefined && message.filename !== "") { + obj.filename = message.filename; + } + if (message.data !== undefined && message.data.length !== 0) { + obj.data = base64FromBytes(message.data); + } + return obj; + }, + + create(base?: DeepPartial): UploadFileReq { + return UploadFileReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): UploadFileReq { + const message = createBaseUploadFileReq(); + message.filename = object.filename ?? ""; + message.data = object.data ?? new Uint8Array(0); + return message; + }, +}; + +function createBaseUploadFileRsp(): UploadFileRsp { + return { error: "", filename: "" }; +} + +export const UploadFileRsp: MessageFns = { + encode(message: UploadFileRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + if (message.filename !== undefined && message.filename !== "") { + writer.uint32(18).string(message.filename); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): UploadFileRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUploadFileRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.filename = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): UploadFileRsp { + return { + error: isSet(object.error) ? globalThis.String(object.error) : "", + filename: isSet(object.filename) ? globalThis.String(object.filename) : "", + }; + }, + + toJSON(message: UploadFileRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + if (message.filename !== undefined && message.filename !== "") { + obj.filename = message.filename; + } + return obj; + }, + + create(base?: DeepPartial): UploadFileRsp { + return UploadFileRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): UploadFileRsp { + const message = createBaseUploadFileRsp(); + message.error = object.error ?? ""; + message.filename = object.filename ?? ""; + return message; + }, +}; + +function createBaseDownloadFileReq(): DownloadFileReq { + return { filename: "" }; +} + +export const DownloadFileReq: MessageFns = { + encode(message: DownloadFileReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.filename !== undefined && message.filename !== "") { + writer.uint32(10).string(message.filename); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): DownloadFileReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseDownloadFileReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.filename = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): DownloadFileReq { + return { filename: isSet(object.filename) ? globalThis.String(object.filename) : "" }; + }, + + toJSON(message: DownloadFileReq): unknown { + const obj: any = {}; + if (message.filename !== undefined && message.filename !== "") { + obj.filename = message.filename; + } + return obj; + }, + + create(base?: DeepPartial): DownloadFileReq { + return DownloadFileReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): DownloadFileReq { + const message = createBaseDownloadFileReq(); + message.filename = object.filename ?? ""; + return message; + }, +}; + +function createBaseAddScenarioReq(): AddScenarioReq { + return { name: "" }; +} + +export const AddScenarioReq: MessageFns = { + encode(message: AddScenarioReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): AddScenarioReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseAddScenarioReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): AddScenarioReq { + return { name: isSet(object.name) ? globalThis.String(object.name) : "" }; + }, + + toJSON(message: AddScenarioReq): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + return obj; + }, + + create(base?: DeepPartial): AddScenarioReq { + return AddScenarioReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): AddScenarioReq { + const message = createBaseAddScenarioReq(); + message.name = object.name ?? ""; + return message; + }, +}; + +function createBaseAddScenarioRsp(): AddScenarioRsp { + return { error: "", id: 0 }; +} + +export const AddScenarioRsp: MessageFns = { + encode(message: AddScenarioRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + if (message.id !== undefined && message.id !== 0) { + writer.uint32(16).int32(message.id); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): AddScenarioRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseAddScenarioRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.id = reader.int32(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): AddScenarioRsp { + return { + error: isSet(object.error) ? globalThis.String(object.error) : "", + id: isSet(object.id) ? globalThis.Number(object.id) : 0, + }; + }, + + toJSON(message: AddScenarioRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + if (message.id !== undefined && message.id !== 0) { + obj.id = Math.round(message.id); + } + return obj; + }, + + create(base?: DeepPartial): AddScenarioRsp { + return AddScenarioRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): AddScenarioRsp { + const message = createBaseAddScenarioRsp(); + message.error = object.error ?? ""; + message.id = object.id ?? 0; + return message; + }, +}; + +function createBaseGetMyScenariosReq(): GetMyScenariosReq { + return {}; +} + +export const GetMyScenariosReq: MessageFns = { + encode(_: GetMyScenariosReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): GetMyScenariosReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGetMyScenariosReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(_: any): GetMyScenariosReq { + return {}; + }, + + toJSON(_: GetMyScenariosReq): unknown { + const obj: any = {}; + return obj; + }, + + create(base?: DeepPartial): GetMyScenariosReq { + return GetMyScenariosReq.fromPartial(base ?? {}); + }, + fromPartial(_: DeepPartial): GetMyScenariosReq { + const message = createBaseGetMyScenariosReq(); + return message; + }, +}; + +function createBaseGetMyScenariosRsp(): GetMyScenariosRsp { + return { error: "", scenarios: [] }; +} + +export const GetMyScenariosRsp: MessageFns = { + encode(message: GetMyScenariosRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + if (message.scenarios !== undefined && message.scenarios.length !== 0) { + for (const v of message.scenarios) { + Scenario.encode(v!, writer.uint32(18).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): GetMyScenariosRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGetMyScenariosRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + const el = Scenario.decode(reader, reader.uint32()); + if (el !== undefined) { + message.scenarios!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): GetMyScenariosRsp { + return { + error: isSet(object.error) ? globalThis.String(object.error) : "", + scenarios: globalThis.Array.isArray(object?.scenarios) + ? object.scenarios.map((e: any) => Scenario.fromJSON(e)) + : [], + }; + }, + + toJSON(message: GetMyScenariosRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + if (message.scenarios?.length) { + obj.scenarios = message.scenarios.map((e) => Scenario.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): GetMyScenariosRsp { + return GetMyScenariosRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GetMyScenariosRsp { + const message = createBaseGetMyScenariosRsp(); + message.error = object.error ?? ""; + message.scenarios = object.scenarios?.map((e) => Scenario.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseGetScenarioReq(): GetScenarioReq { + return { id: 0 }; +} + +export const GetScenarioReq: MessageFns = { + encode(message: GetScenarioReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.id !== undefined && message.id !== 0) { + writer.uint32(8).int32(message.id); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): GetScenarioReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGetScenarioReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.id = reader.int32(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): GetScenarioReq { + return { id: isSet(object.id) ? globalThis.Number(object.id) : 0 }; + }, + + toJSON(message: GetScenarioReq): unknown { + const obj: any = {}; + if (message.id !== undefined && message.id !== 0) { + obj.id = Math.round(message.id); + } + return obj; + }, + + create(base?: DeepPartial): GetScenarioReq { + return GetScenarioReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GetScenarioReq { + const message = createBaseGetScenarioReq(); + message.id = object.id ?? 0; + return message; + }, +}; + +function createBaseGetScenarioRsp(): GetScenarioRsp { + return { error: "", scenario: undefined }; +} + +export const GetScenarioRsp: MessageFns = { + encode(message: GetScenarioRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + if (message.scenario !== undefined) { + Scenario.encode(message.scenario, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): GetScenarioRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGetScenarioRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.scenario = Scenario.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): GetScenarioRsp { + return { + error: isSet(object.error) ? globalThis.String(object.error) : "", + scenario: isSet(object.scenario) ? Scenario.fromJSON(object.scenario) : undefined, + }; + }, + + toJSON(message: GetScenarioRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + if (message.scenario !== undefined) { + obj.scenario = Scenario.toJSON(message.scenario); + } + return obj; + }, + + create(base?: DeepPartial): GetScenarioRsp { + return GetScenarioRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): GetScenarioRsp { + const message = createBaseGetScenarioRsp(); + message.error = object.error ?? ""; + message.scenario = (object.scenario !== undefined && object.scenario !== null) + ? Scenario.fromPartial(object.scenario) + : undefined; + return message; + }, +}; + +function createBaseScenario(): Scenario { + return { + id: 0, + name: "", + description: undefined, + image: undefined, + story: undefined, + author: undefined, + updatedAt: undefined, + createdAt: undefined, + publishedAt: undefined, + }; +} + +export const Scenario: MessageFns = { + encode(message: Scenario, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.id !== undefined && message.id !== 0) { + writer.uint32(8).int32(message.id); + } + if (message.name !== undefined && message.name !== "") { + writer.uint32(18).string(message.name); + } + if (message.description !== undefined) { + writer.uint32(26).string(message.description); + } + if (message.image !== undefined) { + writer.uint32(34).string(message.image); + } + if (message.story !== undefined) { + Story.encode(message.story, writer.uint32(42).fork()).join(); + } + if (message.author !== undefined) { + User.encode(message.author, writer.uint32(50).fork()).join(); + } + if (message.updatedAt !== undefined) { + Timestamp.encode(toTimestamp(message.updatedAt), writer.uint32(58).fork()).join(); + } + if (message.createdAt !== undefined) { + Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(66).fork()).join(); + } + if (message.publishedAt !== undefined) { + Timestamp.encode(toTimestamp(message.publishedAt), writer.uint32(74).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Scenario { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseScenario(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.id = reader.int32(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.name = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.description = reader.string(); + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + message.image = reader.string(); + continue; + } + case 5: { + if (tag !== 42) { + break; + } + + message.story = Story.decode(reader, reader.uint32()); + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + message.author = User.decode(reader, reader.uint32()); + continue; + } + case 7: { + if (tag !== 58) { + break; + } + + message.updatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32())); + continue; + } + case 8: { + if (tag !== 66) { + break; + } + + message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32())); + continue; + } + case 9: { + if (tag !== 74) { + break; + } + + message.publishedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Scenario { + return { + id: isSet(object.id) ? globalThis.Number(object.id) : 0, + name: isSet(object.name) ? globalThis.String(object.name) : "", + description: isSet(object.description) ? globalThis.String(object.description) : undefined, + image: isSet(object.image) ? globalThis.String(object.image) : undefined, + story: isSet(object.story) ? Story.fromJSON(object.story) : undefined, + author: isSet(object.author) ? User.fromJSON(object.author) : undefined, + updatedAt: isSet(object.updatedAt) + ? fromJsonTimestamp(object.updatedAt) + : isSet(object.updated_at) + ? fromJsonTimestamp(object.updated_at) + : undefined, + createdAt: isSet(object.createdAt) + ? fromJsonTimestamp(object.createdAt) + : isSet(object.created_at) + ? fromJsonTimestamp(object.created_at) + : undefined, + publishedAt: isSet(object.publishedAt) + ? fromJsonTimestamp(object.publishedAt) + : isSet(object.published_at) + ? fromJsonTimestamp(object.published_at) + : undefined, + }; + }, + + toJSON(message: Scenario): unknown { + const obj: any = {}; + if (message.id !== undefined && message.id !== 0) { + obj.id = Math.round(message.id); + } + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.description !== undefined) { + obj.description = message.description; + } + if (message.image !== undefined) { + obj.image = message.image; + } + if (message.story !== undefined) { + obj.story = Story.toJSON(message.story); + } + if (message.author !== undefined) { + obj.author = User.toJSON(message.author); + } + if (message.updatedAt !== undefined) { + obj.updatedAt = message.updatedAt.toISOString(); + } + if (message.createdAt !== undefined) { + obj.createdAt = message.createdAt.toISOString(); + } + if (message.publishedAt !== undefined) { + obj.publishedAt = message.publishedAt.toISOString(); + } + return obj; + }, + + create(base?: DeepPartial): Scenario { + return Scenario.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Scenario { + const message = createBaseScenario(); + message.id = object.id ?? 0; + message.name = object.name ?? ""; + message.description = object.description ?? undefined; + message.image = object.image ?? undefined; + message.story = (object.story !== undefined && object.story !== null) ? Story.fromPartial(object.story) : undefined; + message.author = (object.author !== undefined && object.author !== null) + ? User.fromPartial(object.author) + : undefined; + message.updatedAt = object.updatedAt ?? undefined; + message.createdAt = object.createdAt ?? undefined; + message.publishedAt = object.publishedAt ?? undefined; + return message; + }, +}; + +function createBaseStory(): Story { + return { places: [] }; +} + +export const Story: MessageFns = { + encode(message: Story, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.places !== undefined && message.places.length !== 0) { + for (const v of message.places) { + Place.encode(v!, writer.uint32(10).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Story { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseStory(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + const el = Place.decode(reader, reader.uint32()); + if (el !== undefined) { + message.places!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Story { + return { places: globalThis.Array.isArray(object?.places) ? object.places.map((e: any) => Place.fromJSON(e)) : [] }; + }, + + toJSON(message: Story): unknown { + const obj: any = {}; + if (message.places?.length) { + obj.places = message.places.map((e) => Place.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): Story { + return Story.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Story { + const message = createBaseStory(); + message.places = object.places?.map((e) => Place.fromPartial(e)) || []; + return message; + }, +}; + +function createBasePlace(): Place { + return { code: "", name: "", text: "", image: "", hidden: false, applications: [], doors: [], keys: [] }; +} + +export const Place: MessageFns = { + encode(message: Place, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.code !== undefined && message.code !== "") { + writer.uint32(10).string(message.code); + } + if (message.name !== undefined && message.name !== "") { + writer.uint32(18).string(message.name); + } + if (message.text !== undefined && message.text !== "") { + writer.uint32(26).string(message.text); + } + if (message.image !== undefined && message.image !== "") { + writer.uint32(34).string(message.image); + } + if (message.hidden !== undefined && message.hidden !== false) { + writer.uint32(40).bool(message.hidden); + } + if (message.applications !== undefined && message.applications.length !== 0) { + for (const v of message.applications) { + Application.encode(v!, writer.uint32(50).fork()).join(); + } + } + if (message.doors !== undefined && message.doors.length !== 0) { + for (const v of message.doors) { + Door.encode(v!, writer.uint32(58).fork()).join(); + } + } + if (message.keys !== undefined && message.keys.length !== 0) { + for (const v of message.keys) { + Key.encode(v!, writer.uint32(66).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Place { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBasePlace(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.code = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.name = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.text = reader.string(); + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + message.image = reader.string(); + continue; + } + case 5: { + if (tag !== 40) { + break; + } + + message.hidden = reader.bool(); + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + const el = Application.decode(reader, reader.uint32()); + if (el !== undefined) { + message.applications!.push(el); + } + continue; + } + case 7: { + if (tag !== 58) { + break; + } + + const el = Door.decode(reader, reader.uint32()); + if (el !== undefined) { + message.doors!.push(el); + } + continue; + } + case 8: { + if (tag !== 66) { + break; + } + + const el = Key.decode(reader, reader.uint32()); + if (el !== undefined) { + message.keys!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Place { + return { + code: isSet(object.code) ? globalThis.String(object.code) : "", + name: isSet(object.name) ? globalThis.String(object.name) : "", + text: isSet(object.text) ? globalThis.String(object.text) : "", + image: isSet(object.image) ? globalThis.String(object.image) : "", + hidden: isSet(object.hidden) ? globalThis.Boolean(object.hidden) : false, + applications: globalThis.Array.isArray(object?.applications) + ? object.applications.map((e: any) => Application.fromJSON(e)) + : [], + doors: globalThis.Array.isArray(object?.doors) ? object.doors.map((e: any) => Door.fromJSON(e)) : [], + keys: globalThis.Array.isArray(object?.keys) ? object.keys.map((e: any) => Key.fromJSON(e)) : [], + }; + }, + + toJSON(message: Place): unknown { + const obj: any = {}; + if (message.code !== undefined && message.code !== "") { + obj.code = message.code; + } + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.text !== undefined && message.text !== "") { + obj.text = message.text; + } + if (message.image !== undefined && message.image !== "") { + obj.image = message.image; + } + if (message.hidden !== undefined && message.hidden !== false) { + obj.hidden = message.hidden; + } + if (message.applications?.length) { + obj.applications = message.applications.map((e) => Application.toJSON(e)); + } + if (message.doors?.length) { + obj.doors = message.doors.map((e) => Door.toJSON(e)); + } + if (message.keys?.length) { + obj.keys = message.keys.map((e) => Key.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): Place { + return Place.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Place { + const message = createBasePlace(); + message.code = object.code ?? ""; + message.name = object.name ?? ""; + message.text = object.text ?? ""; + message.image = object.image ?? ""; + message.hidden = object.hidden ?? false; + message.applications = object.applications?.map((e) => Application.fromPartial(e)) || []; + message.doors = object.doors?.map((e) => Door.fromPartial(e)) || []; + message.keys = object.keys?.map((e) => Key.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseApplication(): Application { + return { name: "", image: "" }; +} + +export const Application: MessageFns = { + encode(message: Application, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.image !== undefined && message.image !== "") { + writer.uint32(18).string(message.image); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Application { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseApplication(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.image = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Application { + return { + name: isSet(object.name) ? globalThis.String(object.name) : "", + image: isSet(object.image) ? globalThis.String(object.image) : "", + }; + }, + + toJSON(message: Application): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.image !== undefined && message.image !== "") { + obj.image = message.image; + } + return obj; + }, + + create(base?: DeepPartial): Application { + return Application.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Application { + const message = createBaseApplication(); + message.name = object.name ?? ""; + message.image = object.image ?? ""; + return message; + }, +}; + +function createBaseDoor(): Door { + return { code: "", name: "", keys: [] }; +} + +export const Door: MessageFns = { + encode(message: Door, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.code !== undefined && message.code !== "") { + writer.uint32(10).string(message.code); + } + if (message.name !== undefined && message.name !== "") { + writer.uint32(18).string(message.name); + } + if (message.keys !== undefined && message.keys.length !== 0) { + for (const v of message.keys) { + Key.encode(v!, writer.uint32(26).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Door { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseDoor(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.code = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.name = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + const el = Key.decode(reader, reader.uint32()); + if (el !== undefined) { + message.keys!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Door { + return { + code: isSet(object.code) ? globalThis.String(object.code) : "", + name: isSet(object.name) ? globalThis.String(object.name) : "", + keys: globalThis.Array.isArray(object?.keys) ? object.keys.map((e: any) => Key.fromJSON(e)) : [], + }; + }, + + toJSON(message: Door): unknown { + const obj: any = {}; + if (message.code !== undefined && message.code !== "") { + obj.code = message.code; + } + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.keys?.length) { + obj.keys = message.keys.map((e) => Key.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): Door { + return Door.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Door { + const message = createBaseDoor(); + message.code = object.code ?? ""; + message.name = object.name ?? ""; + message.keys = object.keys?.map((e) => Key.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseKey(): Key { + return { name: "" }; +} + +export const Key: MessageFns = { + encode(message: Key, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Key { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseKey(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Key { + return { name: isSet(object.name) ? globalThis.String(object.name) : "" }; + }, + + toJSON(message: Key): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + return obj; + }, + + create(base?: DeepPartial): Key { + return Key.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Key { + const message = createBaseKey(); + message.name = object.name ?? ""; + return message; + }, +}; + +function createBaseUpdateScenarioReq(): UpdateScenarioReq { + return { id: 0, name: "", description: "", image: "" }; +} + +export const UpdateScenarioReq: MessageFns = { + encode(message: UpdateScenarioReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.id !== undefined && message.id !== 0) { + writer.uint32(8).int32(message.id); + } + if (message.name !== undefined && message.name !== "") { + writer.uint32(18).string(message.name); + } + if (message.description !== undefined && message.description !== "") { + writer.uint32(26).string(message.description); + } + if (message.image !== undefined && message.image !== "") { + writer.uint32(34).string(message.image); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): UpdateScenarioReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUpdateScenarioReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.id = reader.int32(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.name = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.description = reader.string(); + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + message.image = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): UpdateScenarioReq { + return { + id: isSet(object.id) ? globalThis.Number(object.id) : 0, + name: isSet(object.name) ? globalThis.String(object.name) : "", + description: isSet(object.description) ? globalThis.String(object.description) : "", + image: isSet(object.image) ? globalThis.String(object.image) : "", + }; + }, + + toJSON(message: UpdateScenarioReq): unknown { + const obj: any = {}; + if (message.id !== undefined && message.id !== 0) { + obj.id = Math.round(message.id); + } + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.description !== undefined && message.description !== "") { + obj.description = message.description; + } + if (message.image !== undefined && message.image !== "") { + obj.image = message.image; + } + return obj; + }, + + create(base?: DeepPartial): UpdateScenarioReq { + return UpdateScenarioReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): UpdateScenarioReq { + const message = createBaseUpdateScenarioReq(); + message.id = object.id ?? 0; + message.name = object.name ?? ""; + message.description = object.description ?? ""; + message.image = object.image ?? ""; + return message; + }, +}; + +function createBaseUpdateScenarioRsp(): UpdateScenarioRsp { + return { error: "" }; +} + +export const UpdateScenarioRsp: MessageFns = { + encode(message: UpdateScenarioRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): UpdateScenarioRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUpdateScenarioRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): UpdateScenarioRsp { + return { error: isSet(object.error) ? globalThis.String(object.error) : "" }; + }, + + toJSON(message: UpdateScenarioRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + return obj; + }, + + create(base?: DeepPartial): UpdateScenarioRsp { + return UpdateScenarioRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): UpdateScenarioRsp { + const message = createBaseUpdateScenarioRsp(); + message.error = object.error ?? ""; + return message; + }, +}; + +function createBaseDeleteScenarioReq(): DeleteScenarioReq { + return { id: 0 }; +} + +export const DeleteScenarioReq: MessageFns = { + encode(message: DeleteScenarioReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.id !== undefined && message.id !== 0) { + writer.uint32(8).int32(message.id); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): DeleteScenarioReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseDeleteScenarioReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.id = reader.int32(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): DeleteScenarioReq { + return { id: isSet(object.id) ? globalThis.Number(object.id) : 0 }; + }, + + toJSON(message: DeleteScenarioReq): unknown { + const obj: any = {}; + if (message.id !== undefined && message.id !== 0) { + obj.id = Math.round(message.id); + } + return obj; + }, + + create(base?: DeepPartial): DeleteScenarioReq { + return DeleteScenarioReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): DeleteScenarioReq { + const message = createBaseDeleteScenarioReq(); + message.id = object.id ?? 0; + return message; + }, +}; + +function createBaseDeleteScenarioRsp(): DeleteScenarioRsp { + return { error: "" }; +} + +export const DeleteScenarioRsp: MessageFns = { + encode(message: DeleteScenarioRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): DeleteScenarioRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseDeleteScenarioRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): DeleteScenarioRsp { + return { error: isSet(object.error) ? globalThis.String(object.error) : "" }; + }, + + toJSON(message: DeleteScenarioRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + return obj; + }, + + create(base?: DeepPartial): DeleteScenarioRsp { + return DeleteScenarioRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): DeleteScenarioRsp { + const message = createBaseDeleteScenarioRsp(); + message.error = object.error ?? ""; + return message; + }, +}; + +function createBaseAddScenarioPlaceReq(): AddScenarioPlaceReq { + return { id: 0, place: undefined }; +} + +export const AddScenarioPlaceReq: MessageFns = { + encode(message: AddScenarioPlaceReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.id !== undefined && message.id !== 0) { + writer.uint32(8).int32(message.id); + } + if (message.place !== undefined) { + Place.encode(message.place, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): AddScenarioPlaceReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseAddScenarioPlaceReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.id = reader.int32(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.place = Place.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): AddScenarioPlaceReq { + return { + id: isSet(object.id) ? globalThis.Number(object.id) : 0, + place: isSet(object.place) ? Place.fromJSON(object.place) : undefined, + }; + }, + + toJSON(message: AddScenarioPlaceReq): unknown { + const obj: any = {}; + if (message.id !== undefined && message.id !== 0) { + obj.id = Math.round(message.id); + } + if (message.place !== undefined) { + obj.place = Place.toJSON(message.place); + } + return obj; + }, + + create(base?: DeepPartial): AddScenarioPlaceReq { + return AddScenarioPlaceReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): AddScenarioPlaceReq { + const message = createBaseAddScenarioPlaceReq(); + message.id = object.id ?? 0; + message.place = (object.place !== undefined && object.place !== null) ? Place.fromPartial(object.place) : undefined; + return message; + }, +}; + +function createBaseAddScenarioPlaceRsp(): AddScenarioPlaceRsp { + return { error: "" }; +} + +export const AddScenarioPlaceRsp: MessageFns = { + encode(message: AddScenarioPlaceRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): AddScenarioPlaceRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseAddScenarioPlaceRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): AddScenarioPlaceRsp { + return { error: isSet(object.error) ? globalThis.String(object.error) : "" }; + }, + + toJSON(message: AddScenarioPlaceRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + return obj; + }, + + create(base?: DeepPartial): AddScenarioPlaceRsp { + return AddScenarioPlaceRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): AddScenarioPlaceRsp { + const message = createBaseAddScenarioPlaceRsp(); + message.error = object.error ?? ""; + return message; + }, +}; + +function createBaseUpdateScenarioPlaceReq(): UpdateScenarioPlaceReq { + return { id: 0, code: "", place: undefined }; +} + +export const UpdateScenarioPlaceReq: MessageFns = { + encode(message: UpdateScenarioPlaceReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.id !== undefined && message.id !== 0) { + writer.uint32(8).int32(message.id); + } + if (message.code !== undefined && message.code !== "") { + writer.uint32(18).string(message.code); + } + if (message.place !== undefined) { + Place.encode(message.place, writer.uint32(26).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): UpdateScenarioPlaceReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUpdateScenarioPlaceReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.id = reader.int32(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.code = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.place = Place.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): UpdateScenarioPlaceReq { + return { + id: isSet(object.id) ? globalThis.Number(object.id) : 0, + code: isSet(object.code) ? globalThis.String(object.code) : "", + place: isSet(object.place) ? Place.fromJSON(object.place) : undefined, + }; + }, + + toJSON(message: UpdateScenarioPlaceReq): unknown { + const obj: any = {}; + if (message.id !== undefined && message.id !== 0) { + obj.id = Math.round(message.id); + } + if (message.code !== undefined && message.code !== "") { + obj.code = message.code; + } + if (message.place !== undefined) { + obj.place = Place.toJSON(message.place); + } + return obj; + }, + + create(base?: DeepPartial): UpdateScenarioPlaceReq { + return UpdateScenarioPlaceReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): UpdateScenarioPlaceReq { + const message = createBaseUpdateScenarioPlaceReq(); + message.id = object.id ?? 0; + message.code = object.code ?? ""; + message.place = (object.place !== undefined && object.place !== null) ? Place.fromPartial(object.place) : undefined; + return message; + }, +}; + +function createBaseUpdateScenarioPlaceRsp(): UpdateScenarioPlaceRsp { + return { error: "" }; +} + +export const UpdateScenarioPlaceRsp: MessageFns = { + encode(message: UpdateScenarioPlaceRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): UpdateScenarioPlaceRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUpdateScenarioPlaceRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): UpdateScenarioPlaceRsp { + return { error: isSet(object.error) ? globalThis.String(object.error) : "" }; + }, + + toJSON(message: UpdateScenarioPlaceRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + return obj; + }, + + create(base?: DeepPartial): UpdateScenarioPlaceRsp { + return UpdateScenarioPlaceRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): UpdateScenarioPlaceRsp { + const message = createBaseUpdateScenarioPlaceRsp(); + message.error = object.error ?? ""; + return message; + }, +}; + +function createBaseDeleteScenarioPlaceReq(): DeleteScenarioPlaceReq { + return { id: 0, code: "" }; +} + +export const DeleteScenarioPlaceReq: MessageFns = { + encode(message: DeleteScenarioPlaceReq, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.id !== undefined && message.id !== 0) { + writer.uint32(8).int32(message.id); + } + if (message.code !== undefined && message.code !== "") { + writer.uint32(18).string(message.code); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): DeleteScenarioPlaceReq { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseDeleteScenarioPlaceReq(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.id = reader.int32(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.code = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): DeleteScenarioPlaceReq { + return { + id: isSet(object.id) ? globalThis.Number(object.id) : 0, + code: isSet(object.code) ? globalThis.String(object.code) : "", + }; + }, + + toJSON(message: DeleteScenarioPlaceReq): unknown { + const obj: any = {}; + if (message.id !== undefined && message.id !== 0) { + obj.id = Math.round(message.id); + } + if (message.code !== undefined && message.code !== "") { + obj.code = message.code; + } + return obj; + }, + + create(base?: DeepPartial): DeleteScenarioPlaceReq { + return DeleteScenarioPlaceReq.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): DeleteScenarioPlaceReq { + const message = createBaseDeleteScenarioPlaceReq(); + message.id = object.id ?? 0; + message.code = object.code ?? ""; + return message; + }, +}; + +function createBaseDeleteScenarioPlaceRsp(): DeleteScenarioPlaceRsp { + return { error: "" }; +} + +export const DeleteScenarioPlaceRsp: MessageFns = { + encode(message: DeleteScenarioPlaceRsp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.error !== undefined && message.error !== "") { + writer.uint32(10).string(message.error); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): DeleteScenarioPlaceRsp { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseDeleteScenarioPlaceRsp(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.error = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): DeleteScenarioPlaceRsp { + return { error: isSet(object.error) ? globalThis.String(object.error) : "" }; + }, + + toJSON(message: DeleteScenarioPlaceRsp): unknown { + const obj: any = {}; + if (message.error !== undefined && message.error !== "") { + obj.error = message.error; + } + return obj; + }, + + create(base?: DeepPartial): DeleteScenarioPlaceRsp { + return DeleteScenarioPlaceRsp.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): DeleteScenarioPlaceRsp { + const message = createBaseDeleteScenarioPlaceRsp(); + message.error = object.error ?? ""; + return message; + }, +}; + +export interface EveningDetectiveServer { + Ping(request: PingReq): Promise; + Echo(request: EchoReq): Promise; + Signup(request: SignupReq): Promise; + RefreshPassword(request: RefreshPasswordReq): Promise; + Login(request: LoginReq): Promise; + Refresh(request: RefreshReq): Promise; + GetUsers(request: GetUsersReq): Promise; + GetUserById(request: GetUserByIdReq): Promise; + GetMe(request: GetMeReq): Promise; + AddUserRole(request: AddUserRoleReq): Promise; + DeleteUserRole(request: DeleteUserRoleReq): Promise; + GetPermissions(request: GetPermissionsReq): Promise; + UploadFile(request: UploadFileReq): Promise; + DownloadFile(request: DownloadFileReq): Promise; + AddScenario(request: AddScenarioReq): Promise; + GetMyScenarios(request: GetMyScenariosReq): Promise; + GetScenario(request: GetScenarioReq): Promise; + UpdateScenario(request: UpdateScenarioReq): Promise; + DeleteScenario(request: DeleteScenarioReq): Promise; + AddScenarioPlace(request: AddScenarioPlaceReq): Promise; + UpdateScenarioPlace(request: UpdateScenarioPlaceReq): Promise; + DeleteScenarioPlace(request: DeleteScenarioPlaceReq): Promise; +} + +function bytesFromBase64(b64: string): Uint8Array { + if ((globalThis as any).Buffer) { + return Uint8Array.from((globalThis as any).Buffer.from(b64, "base64")); + } else { + const bin = globalThis.atob(b64); + const arr = new Uint8Array(bin.length); + for (let i = 0; i < bin.length; ++i) { + arr[i] = bin.charCodeAt(i); + } + return arr; + } +} + +function base64FromBytes(arr: Uint8Array): string { + if ((globalThis as any).Buffer) { + return (globalThis as any).Buffer.from(arr).toString("base64"); + } else { + const bin: string[] = []; + arr.forEach((byte) => { + bin.push(globalThis.String.fromCharCode(byte)); + }); + return globalThis.btoa(bin.join("")); + } +} + +type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined; + +export type DeepPartial = T extends Builtin ? T + : T extends globalThis.Array ? globalThis.Array> + : T extends ReadonlyArray ? ReadonlyArray> + : T extends {} ? { [K in keyof T]?: DeepPartial } + : Partial; + +function toTimestamp(date: Date): Timestamp { + const seconds = Math.trunc(date.getTime() / 1_000); + const nanos = (date.getTime() % 1_000) * 1_000_000; + return { seconds, nanos }; +} + +function fromTimestamp(t: Timestamp): Date { + let millis = (t.seconds || 0) * 1_000; + millis += (t.nanos || 0) / 1_000_000; + return new globalThis.Date(millis); +} + +function fromJsonTimestamp(o: any): Date { + if (o instanceof globalThis.Date) { + return o; + } else if (typeof o === "string") { + return new globalThis.Date(o); + } else { + return fromTimestamp(Timestamp.fromJSON(o)); + } +} + +function isSet(value: any): boolean { + return value !== null && value !== undefined; +} + +export interface MessageFns { + encode(message: T, writer?: BinaryWriter): BinaryWriter; + decode(input: BinaryReader | Uint8Array, length?: number): T; + fromJSON(object: any): T; + toJSON(message: T): unknown; + create(base?: DeepPartial): T; + fromPartial(object: DeepPartial): T; +} diff --git a/src/api/generated/protoc-gen-openapiv2/options/annotations.ts b/src/api/generated/protoc-gen-openapiv2/options/annotations.ts new file mode 100644 index 0000000..5c9a0d3 --- /dev/null +++ b/src/api/generated/protoc-gen-openapiv2/options/annotations.ts @@ -0,0 +1,9 @@ +// Code generated by protoc-gen-ts_proto. DO NOT EDIT. +// versions: +// protoc-gen-ts_proto v2.12.0 +// protoc v7.35.1 +// source: protoc-gen-openapiv2/options/annotations.proto + +/* eslint-disable */ + +export const protobufPackage = "grpc.gateway.protoc_gen_openapiv2.options"; diff --git a/src/api/generated/protoc-gen-openapiv2/options/openapiv2.ts b/src/api/generated/protoc-gen-openapiv2/options/openapiv2.ts new file mode 100644 index 0000000..405ba97 --- /dev/null +++ b/src/api/generated/protoc-gen-openapiv2/options/openapiv2.ts @@ -0,0 +1,6011 @@ +// Code generated by protoc-gen-ts_proto. DO NOT EDIT. +// versions: +// protoc-gen-ts_proto v2.12.0 +// protoc v7.35.1 +// source: protoc-gen-openapiv2/options/openapiv2.proto + +/* eslint-disable */ +import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire"; +import { Value } from "../../google/protobuf/struct"; + +export const protobufPackage = "grpc.gateway.protoc_gen_openapiv2.options"; + +/** + * Scheme describes the schemes supported by the OpenAPI Swagger + * and Operation objects. + */ +export enum Scheme { + UNKNOWN = 0, + HTTP = 1, + HTTPS = 2, + WS = 3, + WSS = 4, + UNRECOGNIZED = -1, +} + +export function schemeFromJSON(object: any): Scheme { + switch (object) { + case 0: + case "UNKNOWN": + return Scheme.UNKNOWN; + case 1: + case "HTTP": + return Scheme.HTTP; + case 2: + case "HTTPS": + return Scheme.HTTPS; + case 3: + case "WS": + return Scheme.WS; + case 4: + case "WSS": + return Scheme.WSS; + case -1: + case "UNRECOGNIZED": + default: + return Scheme.UNRECOGNIZED; + } +} + +export function schemeToJSON(object: Scheme): string { + switch (object) { + case Scheme.UNKNOWN: + return "UNKNOWN"; + case Scheme.HTTP: + return "HTTP"; + case Scheme.HTTPS: + return "HTTPS"; + case Scheme.WS: + return "WS"; + case Scheme.WSS: + return "WSS"; + case Scheme.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +/** + * `Swagger` is a representation of OpenAPI v2 specification's Swagger object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#swaggerObject + * + * Example: + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { + * info: { + * title: "Echo API"; + * version: "1.0"; + * description: ""; + * contact: { + * name: "gRPC-Gateway project"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway"; + * email: "none@example.com"; + * }; + * license: { + * name: "BSD 3-Clause License"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/main/LICENSE"; + * }; + * }; + * schemes: HTTPS; + * consumes: "application/json"; + * produces: "application/json"; + * }; + */ +export interface Swagger { + /** + * Specifies the OpenAPI Specification version being used. It can be + * used by the OpenAPI UI and other clients to interpret the API listing. The + * value MUST be "2.0". + */ + swagger?: + | string + | undefined; + /** + * Provides metadata about the API. The metadata can be used by the + * clients if needed. + */ + info?: + | Info + | undefined; + /** + * The host (name or ip) serving the API. This MUST be the host only and does + * not include the scheme nor sub-paths. It MAY include a port. If the host is + * not included, the host serving the documentation is to be used (including + * the port). The host does not support path templating. + */ + host?: + | string + | undefined; + /** + * The base path on which the API is served, which is relative to the host. If + * it is not included, the API is served directly under the host. The value + * MUST start with a leading slash (/). The basePath does not support path + * templating. + * Note that using `base_path` does not change the endpoint paths that are + * generated in the resulting OpenAPI file. If you wish to use `base_path` + * with relatively generated OpenAPI paths, the `base_path` prefix must be + * manually removed from your `google.api.http` paths and your code changed to + * serve the API from the `base_path`. + */ + basePath?: + | string + | undefined; + /** + * The transfer protocol of the API. Values MUST be from the list: "http", + * "https", "ws", "wss". If the schemes is not included, the default scheme to + * be used is the one used to access the OpenAPI definition itself. + */ + schemes?: + | Scheme[] + | undefined; + /** + * A list of MIME types the APIs can consume. This is global to all APIs but + * can be overridden on specific API calls. Value MUST be as described under + * Mime Types. + */ + consumes?: + | string[] + | undefined; + /** + * A list of MIME types the APIs can produce. This is global to all APIs but + * can be overridden on specific API calls. Value MUST be as described under + * Mime Types. + */ + produces?: + | string[] + | undefined; + /** + * An object to hold responses that can be used across operations. This + * property does not define global responses for all operations. + */ + responses?: + | { [key: string]: Response } + | undefined; + /** Security scheme definitions that can be used across the specification. */ + securityDefinitions?: + | SecurityDefinitions + | undefined; + /** + * A declaration of which security schemes are applied for the API as a whole. + * The list of values describes alternative security schemes that can be used + * (that is, there is a logical OR between the security requirements). + * Individual operations can override this definition. + */ + security?: + | SecurityRequirement[] + | undefined; + /** + * A list of tags for API documentation control. Tags can be used for logical + * grouping of operations by resources or any other qualifier. + */ + tags?: + | Tag[] + | undefined; + /** Additional external documentation. */ + externalDocs?: + | ExternalDocumentation + | undefined; + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + */ + extensions?: { [key: string]: any | undefined } | undefined; +} + +export interface Swagger_ResponsesEntry { + key: string; + value?: Response | undefined; +} + +export interface Swagger_ExtensionsEntry { + key: string; + value?: any | undefined; +} + +/** + * `Operation` is a representation of OpenAPI v2 specification's Operation object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#operationObject + * + * Example: + * + * service EchoService { + * rpc Echo(SimpleMessage) returns (SimpleMessage) { + * option (google.api.http) = { + * get: "/v1/example/echo/{id}" + * }; + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = { + * summary: "Get a message."; + * operation_id: "getMessage"; + * tags: "echo"; + * responses: { + * key: "200" + * value: { + * description: "OK"; + * } + * } + * }; + * } + * } + */ +export interface Operation { + /** + * A list of tags for API documentation control. Tags can be used for logical + * grouping of operations by resources or any other qualifier. + */ + tags?: + | string[] + | undefined; + /** + * A short summary of what the operation does. For maximum readability in the + * swagger-ui, this field SHOULD be less than 120 characters. + */ + summary?: + | string + | undefined; + /** + * A verbose explanation of the operation behavior. GFM syntax can be used for + * rich text representation. + */ + description?: + | string + | undefined; + /** Additional external documentation for this operation. */ + externalDocs?: + | ExternalDocumentation + | undefined; + /** + * Unique string used to identify the operation. The id MUST be unique among + * all operations described in the API. Tools and libraries MAY use the + * operationId to uniquely identify an operation, therefore, it is recommended + * to follow common programming naming conventions. + */ + operationId?: + | string + | undefined; + /** + * A list of MIME types the operation can consume. This overrides the consumes + * definition at the OpenAPI Object. An empty value MAY be used to clear the + * global definition. Value MUST be as described under Mime Types. + */ + consumes?: + | string[] + | undefined; + /** + * A list of MIME types the operation can produce. This overrides the produces + * definition at the OpenAPI Object. An empty value MAY be used to clear the + * global definition. Value MUST be as described under Mime Types. + */ + produces?: + | string[] + | undefined; + /** + * The list of possible responses as they are returned from executing this + * operation. + */ + responses?: + | { [key: string]: Response } + | undefined; + /** + * The transfer protocol for the operation. Values MUST be from the list: + * "http", "https", "ws", "wss". The value overrides the OpenAPI Object + * schemes definition. + */ + schemes?: + | Scheme[] + | undefined; + /** + * Declares this operation to be deprecated. Usage of the declared operation + * should be refrained. Default value is false. + */ + deprecated?: + | boolean + | undefined; + /** + * A declaration of which security schemes are applied for this operation. The + * list of values describes alternative security schemes that can be used + * (that is, there is a logical OR between the security requirements). This + * definition overrides any declared top-level security. To remove a top-level + * security declaration, an empty array can be used. + */ + security?: + | SecurityRequirement[] + | undefined; + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + */ + extensions?: + | { [key: string]: any | undefined } + | undefined; + /** + * Custom parameters such as HTTP request headers. + * See: https://swagger.io/docs/specification/2-0/describing-parameters/ + * and https://swagger.io/specification/v2/#parameter-object. + */ + parameters?: Parameters | undefined; +} + +export interface Operation_ResponsesEntry { + key: string; + value?: Response | undefined; +} + +export interface Operation_ExtensionsEntry { + key: string; + value?: any | undefined; +} + +/** + * `Parameters` is a representation of OpenAPI v2 specification's parameters object. + * Note: This technically breaks compatibility with the OpenAPI 2 definition structure as we only + * allow header parameters to be set here since we do not want users specifying custom non-header + * parameters beyond those inferred from the Protobuf schema. + * See: https://swagger.io/specification/v2/#parameter-object + */ +export interface Parameters { + /** + * `Headers` is one or more HTTP header parameter. + * See: https://swagger.io/docs/specification/2-0/describing-parameters/#header-parameters + */ + headers?: HeaderParameter[] | undefined; +} + +/** + * `HeaderParameter` a HTTP header parameter. + * See: https://swagger.io/specification/v2/#parameter-object + */ +export interface HeaderParameter { + /** `Name` is the header name. */ + name?: + | string + | undefined; + /** `Description` is a short description of the header. */ + description?: + | string + | undefined; + /** + * `Type` is the type of the object. The value MUST be one of "string", "number", "integer", or "boolean". The "array" type is not supported. + * See: https://swagger.io/specification/v2/#parameterType. + */ + type?: + | HeaderParameter_Type + | undefined; + /** `Format` The extending format for the previously mentioned type. */ + format?: + | string + | undefined; + /** `Required` indicates if the header is optional */ + required?: boolean | undefined; +} + +/** + * `Type` is a supported HTTP header type. + * See https://swagger.io/specification/v2/#parameterType. + */ +export enum HeaderParameter_Type { + UNKNOWN = 0, + STRING = 1, + NUMBER = 2, + INTEGER = 3, + BOOLEAN = 4, + UNRECOGNIZED = -1, +} + +export function headerParameter_TypeFromJSON(object: any): HeaderParameter_Type { + switch (object) { + case 0: + case "UNKNOWN": + return HeaderParameter_Type.UNKNOWN; + case 1: + case "STRING": + return HeaderParameter_Type.STRING; + case 2: + case "NUMBER": + return HeaderParameter_Type.NUMBER; + case 3: + case "INTEGER": + return HeaderParameter_Type.INTEGER; + case 4: + case "BOOLEAN": + return HeaderParameter_Type.BOOLEAN; + case -1: + case "UNRECOGNIZED": + default: + return HeaderParameter_Type.UNRECOGNIZED; + } +} + +export function headerParameter_TypeToJSON(object: HeaderParameter_Type): string { + switch (object) { + case HeaderParameter_Type.UNKNOWN: + return "UNKNOWN"; + case HeaderParameter_Type.STRING: + return "STRING"; + case HeaderParameter_Type.NUMBER: + return "NUMBER"; + case HeaderParameter_Type.INTEGER: + return "INTEGER"; + case HeaderParameter_Type.BOOLEAN: + return "BOOLEAN"; + case HeaderParameter_Type.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +/** + * `Header` is a representation of OpenAPI v2 specification's Header object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#headerObject + */ +export interface Header { + /** `Description` is a short description of the header. */ + description?: + | string + | undefined; + /** The type of the object. The value MUST be one of "string", "number", "integer", or "boolean". The "array" type is not supported. */ + type?: + | string + | undefined; + /** `Format` The extending format for the previously mentioned type. */ + format?: + | string + | undefined; + /** + * `Default` Declares the value of the header that the server will use if none is provided. + * See: https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-6.2. + * Unlike JSON Schema this value MUST conform to the defined type for the header. + */ + default?: + | string + | undefined; + /** 'Pattern' See https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-5.2.3. */ + pattern?: string | undefined; +} + +/** + * `Response` is a representation of OpenAPI v2 specification's Response object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#responseObject + */ +export interface Response { + /** + * `Description` is a short description of the response. + * GFM syntax can be used for rich text representation. + */ + description?: + | string + | undefined; + /** + * `Schema` optionally defines the structure of the response. + * If `Schema` is not provided, it means there is no content to the response. + */ + schema?: + | Schema + | undefined; + /** + * `Headers` A list of headers that are sent with the response. + * `Header` name is expected to be a string in the canonical format of the MIME header key + * See: https://golang.org/pkg/net/textproto/#CanonicalMIMEHeaderKey + */ + headers?: + | { [key: string]: Header } + | undefined; + /** + * `Examples` gives per-mimetype response examples. + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#example-object + */ + examples?: + | { [key: string]: string } + | undefined; + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + */ + extensions?: { [key: string]: any | undefined } | undefined; +} + +export interface Response_HeadersEntry { + key: string; + value?: Header | undefined; +} + +export interface Response_ExamplesEntry { + key: string; + value: string; +} + +export interface Response_ExtensionsEntry { + key: string; + value?: any | undefined; +} + +/** + * `Info` is a representation of OpenAPI v2 specification's Info object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#infoObject + * + * Example: + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { + * info: { + * title: "Echo API"; + * version: "1.0"; + * description: ""; + * contact: { + * name: "gRPC-Gateway project"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway"; + * email: "none@example.com"; + * }; + * license: { + * name: "BSD 3-Clause License"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/main/LICENSE"; + * }; + * }; + * ... + * }; + */ +export interface Info { + /** The title of the application. */ + title?: + | string + | undefined; + /** + * A short description of the application. GFM syntax can be used for rich + * text representation. + */ + description?: + | string + | undefined; + /** The Terms of Service for the API. */ + termsOfService?: + | string + | undefined; + /** The contact information for the exposed API. */ + contact?: + | Contact + | undefined; + /** The license information for the exposed API. */ + license?: + | License + | undefined; + /** + * Provides the version of the application API (not to be confused + * with the specification version). + */ + version?: + | string + | undefined; + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + */ + extensions?: { [key: string]: any | undefined } | undefined; +} + +export interface Info_ExtensionsEntry { + key: string; + value?: any | undefined; +} + +/** + * `Contact` is a representation of OpenAPI v2 specification's Contact object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#contactObject + * + * Example: + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { + * info: { + * ... + * contact: { + * name: "gRPC-Gateway project"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway"; + * email: "none@example.com"; + * }; + * ... + * }; + * ... + * }; + */ +export interface Contact { + /** The identifying name of the contact person/organization. */ + name?: + | string + | undefined; + /** + * The URL pointing to the contact information. MUST be in the format of a + * URL. + */ + url?: + | string + | undefined; + /** + * The email address of the contact person/organization. MUST be in the format + * of an email address. + */ + email?: string | undefined; +} + +/** + * `License` is a representation of OpenAPI v2 specification's License object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#licenseObject + * + * Example: + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { + * info: { + * ... + * license: { + * name: "BSD 3-Clause License"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/main/LICENSE"; + * }; + * ... + * }; + * ... + * }; + */ +export interface License { + /** The license name used for the API. */ + name?: + | string + | undefined; + /** A URL to the license used for the API. MUST be in the format of a URL. */ + url?: string | undefined; +} + +/** + * `ExternalDocumentation` is a representation of OpenAPI v2 specification's + * ExternalDocumentation object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#externalDocumentationObject + * + * Example: + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { + * ... + * external_docs: { + * description: "More about gRPC-Gateway"; + * url: "https://github.com/grpc-ecosystem/grpc-gateway"; + * } + * ... + * }; + */ +export interface ExternalDocumentation { + /** + * A short description of the target documentation. GFM syntax can be used for + * rich text representation. + */ + description?: + | string + | undefined; + /** + * The URL for the target documentation. Value MUST be in the format + * of a URL. + */ + url?: string | undefined; +} + +/** + * `Schema` is a representation of OpenAPI v2 specification's Schema object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject + */ +export interface Schema { + jsonSchema?: + | JSONSchema + | undefined; + /** + * Adds support for polymorphism. The discriminator is the schema property + * name that is used to differentiate between other schema that inherit this + * schema. The property name used MUST be defined at this schema and it MUST + * be in the required property list. When used, the value MUST be the name of + * this schema or any schema that inherits it. + */ + discriminator?: + | string + | undefined; + /** + * Relevant only for Schema "properties" definitions. Declares the property as + * "read only". This means that it MAY be sent as part of a response but MUST + * NOT be sent as part of the request. Properties marked as readOnly being + * true SHOULD NOT be in the required list of the defined schema. Default + * value is false. + */ + readOnly?: + | boolean + | undefined; + /** Additional external documentation for this schema. */ + externalDocs?: + | ExternalDocumentation + | undefined; + /** + * A free-form property to include an example of an instance for this schema in JSON. + * This is copied verbatim to the output. + */ + example?: string | undefined; +} + +/** + * `EnumSchema` is subset of fields from the OpenAPI v2 specification's Schema object. + * Only fields that are applicable to Enums are included + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject + * + * Example: + * + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_enum) = { + * ... + * title: "MyEnum"; + * description:"This is my nice enum"; + * example: "ZERO"; + * required: true; + * ... + * }; + */ +export interface EnumSchema { + /** A short description of the schema. */ + description?: string | undefined; + default?: + | string + | undefined; + /** The title of the schema. */ + title?: string | undefined; + required?: boolean | undefined; + readOnly?: + | boolean + | undefined; + /** Additional external documentation for this schema. */ + externalDocs?: ExternalDocumentation | undefined; + example?: + | string + | undefined; + /** + * Ref is used to define an external reference to include in the message. + * This could be a fully qualified proto message reference, and that type must + * be imported into the protofile. If no message is identified, the Ref will + * be used verbatim in the output. + * For example: + * `ref: ".google.protobuf.Timestamp"`. + */ + ref?: + | string + | undefined; + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + */ + extensions?: { [key: string]: any | undefined } | undefined; +} + +export interface EnumSchema_ExtensionsEntry { + key: string; + value?: any | undefined; +} + +/** + * `JSONSchema` represents properties from JSON Schema taken, and as used, in + * the OpenAPI v2 spec. + * + * This includes changes made by OpenAPI v2. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject + * + * See also: https://cswr.github.io/JsonSchema/spec/basic_types/, + * https://github.com/json-schema-org/json-schema-spec/blob/master/schema.json + * + * Example: + * + * message SimpleMessage { + * option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema) = { + * json_schema: { + * title: "SimpleMessage" + * description: "A simple message." + * required: ["id"] + * } + * }; + * + * // Id represents the message identifier. + * string id = 1; [ + * (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = { + * description: "The unique identifier of the simple message." + * }]; + * } + */ +export interface JSONSchema { + /** + * Ref is used to define an external reference to include in the message. + * This could be a fully qualified proto message reference, and that type must + * be imported into the protofile. If no message is identified, the Ref will + * be used verbatim in the output. + * For example: + * `ref: ".google.protobuf.Timestamp"`. + */ + ref?: + | string + | undefined; + /** The title of the schema. */ + title?: + | string + | undefined; + /** A short description of the schema. */ + description?: string | undefined; + default?: string | undefined; + readOnly?: + | boolean + | undefined; + /** + * A free-form property to include a JSON example of this field. This is copied + * verbatim to the output swagger.json. Quotes must be escaped. + * This property is the same for 2.0 and 3.0.0 https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/3.0.0.md#schemaObject https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject + */ + example?: string | undefined; + multipleOf?: + | number + | undefined; + /** + * Maximum represents an inclusive upper limit for a numeric instance. The + * value of MUST be a number, + */ + maximum?: number | undefined; + exclusiveMaximum?: + | boolean + | undefined; + /** + * minimum represents an inclusive lower limit for a numeric instance. The + * value of MUST be a number, + */ + minimum?: number | undefined; + exclusiveMinimum?: boolean | undefined; + maxLength?: number | undefined; + minLength?: number | undefined; + pattern?: string | undefined; + maxItems?: number | undefined; + minItems?: number | undefined; + uniqueItems?: boolean | undefined; + maxProperties?: number | undefined; + minProperties?: number | undefined; + required?: + | string[] + | undefined; + /** Items in 'array' must be unique. */ + array?: string[] | undefined; + type?: + | JSONSchema_JSONSchemaSimpleTypes[] + | undefined; + /** `Format` */ + format?: + | string + | undefined; + /** Items in `enum` must be unique https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-5.5.1 */ + enum?: + | string[] + | undefined; + /** Additional field level properties used when generating the OpenAPI v2 file. */ + fieldConfiguration?: + | JSONSchema_FieldConfiguration + | undefined; + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + */ + extensions?: { [key: string]: any | undefined } | undefined; +} + +export enum JSONSchema_JSONSchemaSimpleTypes { + UNKNOWN = 0, + ARRAY = 1, + BOOLEAN = 2, + INTEGER = 3, + NULL = 4, + NUMBER = 5, + OBJECT = 6, + STRING = 7, + UNRECOGNIZED = -1, +} + +export function jSONSchema_JSONSchemaSimpleTypesFromJSON(object: any): JSONSchema_JSONSchemaSimpleTypes { + switch (object) { + case 0: + case "UNKNOWN": + return JSONSchema_JSONSchemaSimpleTypes.UNKNOWN; + case 1: + case "ARRAY": + return JSONSchema_JSONSchemaSimpleTypes.ARRAY; + case 2: + case "BOOLEAN": + return JSONSchema_JSONSchemaSimpleTypes.BOOLEAN; + case 3: + case "INTEGER": + return JSONSchema_JSONSchemaSimpleTypes.INTEGER; + case 4: + case "NULL": + return JSONSchema_JSONSchemaSimpleTypes.NULL; + case 5: + case "NUMBER": + return JSONSchema_JSONSchemaSimpleTypes.NUMBER; + case 6: + case "OBJECT": + return JSONSchema_JSONSchemaSimpleTypes.OBJECT; + case 7: + case "STRING": + return JSONSchema_JSONSchemaSimpleTypes.STRING; + case -1: + case "UNRECOGNIZED": + default: + return JSONSchema_JSONSchemaSimpleTypes.UNRECOGNIZED; + } +} + +export function jSONSchema_JSONSchemaSimpleTypesToJSON(object: JSONSchema_JSONSchemaSimpleTypes): string { + switch (object) { + case JSONSchema_JSONSchemaSimpleTypes.UNKNOWN: + return "UNKNOWN"; + case JSONSchema_JSONSchemaSimpleTypes.ARRAY: + return "ARRAY"; + case JSONSchema_JSONSchemaSimpleTypes.BOOLEAN: + return "BOOLEAN"; + case JSONSchema_JSONSchemaSimpleTypes.INTEGER: + return "INTEGER"; + case JSONSchema_JSONSchemaSimpleTypes.NULL: + return "NULL"; + case JSONSchema_JSONSchemaSimpleTypes.NUMBER: + return "NUMBER"; + case JSONSchema_JSONSchemaSimpleTypes.OBJECT: + return "OBJECT"; + case JSONSchema_JSONSchemaSimpleTypes.STRING: + return "STRING"; + case JSONSchema_JSONSchemaSimpleTypes.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +/** + * 'FieldConfiguration' provides additional field level properties used when generating the OpenAPI v2 file. + * These properties are not defined by OpenAPIv2, but they are used to control the generation. + */ +export interface JSONSchema_FieldConfiguration { + /** + * Alternative parameter name when used as path parameter. If set, this will + * be used as the complete parameter name when this field is used as a path + * parameter. Use this to avoid having auto generated path parameter names + * for overlapping paths. + */ + pathParamName?: + | string + | undefined; + /** + * Declares this field to be deprecated. Allows for the generated OpenAPI + * parameter to be marked as deprecated without affecting the proto field. + */ + deprecated?: boolean | undefined; +} + +export interface JSONSchema_ExtensionsEntry { + key: string; + value?: any | undefined; +} + +/** + * `Tag` is a representation of OpenAPI v2 specification's Tag object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#tagObject + */ +export interface Tag { + /** + * The name of the tag. Use it to allow override of the name of a + * global Tag object, then use that name to reference the tag throughout the + * OpenAPI file. + */ + name?: + | string + | undefined; + /** + * A short description for the tag. GFM syntax can be used for rich text + * representation. + */ + description?: + | string + | undefined; + /** Additional external documentation for this tag. */ + externalDocs?: + | ExternalDocumentation + | undefined; + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + */ + extensions?: { [key: string]: any | undefined } | undefined; +} + +export interface Tag_ExtensionsEntry { + key: string; + value?: any | undefined; +} + +/** + * `SecurityDefinitions` is a representation of OpenAPI v2 specification's + * Security Definitions object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#securityDefinitionsObject + * + * A declaration of the security schemes available to be used in the + * specification. This does not enforce the security schemes on the operations + * and only serves to provide the relevant details for each scheme. + */ +export interface SecurityDefinitions { + /** + * A single security scheme definition, mapping a "name" to the scheme it + * defines. + */ + security?: { [key: string]: SecurityScheme } | undefined; +} + +export interface SecurityDefinitions_SecurityEntry { + key: string; + value?: SecurityScheme | undefined; +} + +/** + * `SecurityScheme` is a representation of OpenAPI v2 specification's + * Security Scheme object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#securitySchemeObject + * + * Allows the definition of a security scheme that can be used by the + * operations. Supported schemes are basic authentication, an API key (either as + * a header or as a query parameter) and OAuth2's common flows (implicit, + * password, application and access code). + */ +export interface SecurityScheme { + /** + * The type of the security scheme. Valid values are "basic", + * "apiKey" or "oauth2". + */ + type?: + | SecurityScheme_Type + | undefined; + /** A short description for security scheme. */ + description?: + | string + | undefined; + /** + * The name of the header or query parameter to be used. + * Valid for apiKey. + */ + name?: + | string + | undefined; + /** + * The location of the API key. Valid values are "query" or + * "header". + * Valid for apiKey. + */ + in?: + | SecurityScheme_In + | undefined; + /** + * The flow used by the OAuth2 security scheme. Valid values are + * "implicit", "password", "application" or "accessCode". + * Valid for oauth2. + */ + flow?: + | SecurityScheme_Flow + | undefined; + /** + * The authorization URL to be used for this flow. This SHOULD be in + * the form of a URL. + * Valid for oauth2/implicit and oauth2/accessCode. + */ + authorizationUrl?: + | string + | undefined; + /** + * The token URL to be used for this flow. This SHOULD be in the + * form of a URL. + * Valid for oauth2/password, oauth2/application and oauth2/accessCode. + */ + tokenUrl?: + | string + | undefined; + /** + * The available scopes for the OAuth2 security scheme. + * Valid for oauth2. + */ + scopes?: + | Scopes + | undefined; + /** + * Custom properties that start with "x-" such as "x-foo" used to describe + * extra functionality that is not covered by the standard OpenAPI Specification. + * See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + */ + extensions?: { [key: string]: any | undefined } | undefined; +} + +/** + * The type of the security scheme. Valid values are "basic", + * "apiKey" or "oauth2". + */ +export enum SecurityScheme_Type { + TYPE_INVALID = 0, + TYPE_BASIC = 1, + TYPE_API_KEY = 2, + TYPE_OAUTH2 = 3, + UNRECOGNIZED = -1, +} + +export function securityScheme_TypeFromJSON(object: any): SecurityScheme_Type { + switch (object) { + case 0: + case "TYPE_INVALID": + return SecurityScheme_Type.TYPE_INVALID; + case 1: + case "TYPE_BASIC": + return SecurityScheme_Type.TYPE_BASIC; + case 2: + case "TYPE_API_KEY": + return SecurityScheme_Type.TYPE_API_KEY; + case 3: + case "TYPE_OAUTH2": + return SecurityScheme_Type.TYPE_OAUTH2; + case -1: + case "UNRECOGNIZED": + default: + return SecurityScheme_Type.UNRECOGNIZED; + } +} + +export function securityScheme_TypeToJSON(object: SecurityScheme_Type): string { + switch (object) { + case SecurityScheme_Type.TYPE_INVALID: + return "TYPE_INVALID"; + case SecurityScheme_Type.TYPE_BASIC: + return "TYPE_BASIC"; + case SecurityScheme_Type.TYPE_API_KEY: + return "TYPE_API_KEY"; + case SecurityScheme_Type.TYPE_OAUTH2: + return "TYPE_OAUTH2"; + case SecurityScheme_Type.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +/** The location of the API key. Valid values are "query" or "header". */ +export enum SecurityScheme_In { + IN_INVALID = 0, + IN_QUERY = 1, + IN_HEADER = 2, + UNRECOGNIZED = -1, +} + +export function securityScheme_InFromJSON(object: any): SecurityScheme_In { + switch (object) { + case 0: + case "IN_INVALID": + return SecurityScheme_In.IN_INVALID; + case 1: + case "IN_QUERY": + return SecurityScheme_In.IN_QUERY; + case 2: + case "IN_HEADER": + return SecurityScheme_In.IN_HEADER; + case -1: + case "UNRECOGNIZED": + default: + return SecurityScheme_In.UNRECOGNIZED; + } +} + +export function securityScheme_InToJSON(object: SecurityScheme_In): string { + switch (object) { + case SecurityScheme_In.IN_INVALID: + return "IN_INVALID"; + case SecurityScheme_In.IN_QUERY: + return "IN_QUERY"; + case SecurityScheme_In.IN_HEADER: + return "IN_HEADER"; + case SecurityScheme_In.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +/** + * The flow used by the OAuth2 security scheme. Valid values are + * "implicit", "password", "application" or "accessCode". + */ +export enum SecurityScheme_Flow { + FLOW_INVALID = 0, + FLOW_IMPLICIT = 1, + FLOW_PASSWORD = 2, + FLOW_APPLICATION = 3, + FLOW_ACCESS_CODE = 4, + UNRECOGNIZED = -1, +} + +export function securityScheme_FlowFromJSON(object: any): SecurityScheme_Flow { + switch (object) { + case 0: + case "FLOW_INVALID": + return SecurityScheme_Flow.FLOW_INVALID; + case 1: + case "FLOW_IMPLICIT": + return SecurityScheme_Flow.FLOW_IMPLICIT; + case 2: + case "FLOW_PASSWORD": + return SecurityScheme_Flow.FLOW_PASSWORD; + case 3: + case "FLOW_APPLICATION": + return SecurityScheme_Flow.FLOW_APPLICATION; + case 4: + case "FLOW_ACCESS_CODE": + return SecurityScheme_Flow.FLOW_ACCESS_CODE; + case -1: + case "UNRECOGNIZED": + default: + return SecurityScheme_Flow.UNRECOGNIZED; + } +} + +export function securityScheme_FlowToJSON(object: SecurityScheme_Flow): string { + switch (object) { + case SecurityScheme_Flow.FLOW_INVALID: + return "FLOW_INVALID"; + case SecurityScheme_Flow.FLOW_IMPLICIT: + return "FLOW_IMPLICIT"; + case SecurityScheme_Flow.FLOW_PASSWORD: + return "FLOW_PASSWORD"; + case SecurityScheme_Flow.FLOW_APPLICATION: + return "FLOW_APPLICATION"; + case SecurityScheme_Flow.FLOW_ACCESS_CODE: + return "FLOW_ACCESS_CODE"; + case SecurityScheme_Flow.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + +export interface SecurityScheme_ExtensionsEntry { + key: string; + value?: any | undefined; +} + +/** + * `SecurityRequirement` is a representation of OpenAPI v2 specification's + * Security Requirement object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#securityRequirementObject + * + * Lists the required security schemes to execute this operation. The object can + * have multiple security schemes declared in it which are all required (that + * is, there is a logical AND between the schemes). + * + * The name used for each property MUST correspond to a security scheme + * declared in the Security Definitions. + */ +export interface SecurityRequirement { + /** + * Each name must correspond to a security scheme which is declared in + * the Security Definitions. If the security scheme is of type "oauth2", + * then the value is a list of scope names required for the execution. + * For other security scheme types, the array MUST be empty. + */ + securityRequirement?: { [key: string]: SecurityRequirement_SecurityRequirementValue } | undefined; +} + +/** + * If the security scheme is of type "oauth2", then the value is a list of + * scope names required for the execution. For other security scheme types, + * the array MUST be empty. + */ +export interface SecurityRequirement_SecurityRequirementValue { + scope?: string[] | undefined; +} + +export interface SecurityRequirement_SecurityRequirementEntry { + key: string; + value?: SecurityRequirement_SecurityRequirementValue | undefined; +} + +/** + * `Scopes` is a representation of OpenAPI v2 specification's Scopes object. + * + * See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#scopesObject + * + * Lists the available scopes for an OAuth2 security scheme. + */ +export interface Scopes { + /** + * Maps between a name of a scope to a short description of it (as the value + * of the property). + */ + scope?: { [key: string]: string } | undefined; +} + +export interface Scopes_ScopeEntry { + key: string; + value: string; +} + +function createBaseSwagger(): Swagger { + return { + swagger: "", + info: undefined, + host: "", + basePath: "", + schemes: [], + consumes: [], + produces: [], + responses: {}, + securityDefinitions: undefined, + security: [], + tags: [], + externalDocs: undefined, + extensions: {}, + }; +} + +export const Swagger: MessageFns = { + encode(message: Swagger, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.swagger !== undefined && message.swagger !== "") { + writer.uint32(10).string(message.swagger); + } + if (message.info !== undefined) { + Info.encode(message.info, writer.uint32(18).fork()).join(); + } + if (message.host !== undefined && message.host !== "") { + writer.uint32(26).string(message.host); + } + if (message.basePath !== undefined && message.basePath !== "") { + writer.uint32(34).string(message.basePath); + } + if (message.schemes !== undefined && message.schemes.length !== 0) { + writer.uint32(42).fork(); + for (const v of message.schemes) { + writer.int32(v); + } + writer.join(); + } + if (message.consumes !== undefined && message.consumes.length !== 0) { + for (const v of message.consumes) { + writer.uint32(50).string(v!); + } + } + if (message.produces !== undefined && message.produces.length !== 0) { + for (const v of message.produces) { + writer.uint32(58).string(v!); + } + } + globalThis.Object.entries(message.responses || {}).forEach(([key, value]: [string, Response]) => { + Swagger_ResponsesEntry.encode({ key: key as any, value }, writer.uint32(82).fork()).join(); + }); + if (message.securityDefinitions !== undefined) { + SecurityDefinitions.encode(message.securityDefinitions, writer.uint32(90).fork()).join(); + } + if (message.security !== undefined && message.security.length !== 0) { + for (const v of message.security) { + SecurityRequirement.encode(v!, writer.uint32(98).fork()).join(); + } + } + if (message.tags !== undefined && message.tags.length !== 0) { + for (const v of message.tags) { + Tag.encode(v!, writer.uint32(106).fork()).join(); + } + } + if (message.externalDocs !== undefined) { + ExternalDocumentation.encode(message.externalDocs, writer.uint32(114).fork()).join(); + } + globalThis.Object.entries(message.extensions || {}).forEach(([key, value]: [string, any | undefined]) => { + if (value !== undefined) { + Swagger_ExtensionsEntry.encode({ key: key as any, value }, writer.uint32(122).fork()).join(); + } + }); + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Swagger { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSwagger(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.swagger = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.info = Info.decode(reader, reader.uint32()); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.host = reader.string(); + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + message.basePath = reader.string(); + continue; + } + case 5: { + if (tag === 40) { + message.schemes!.push(reader.int32() as any); + + continue; + } + + if (tag === 42) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.schemes!.push(reader.int32() as any); + } + + continue; + } + + break; + } + case 6: { + if (tag !== 50) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.consumes!.push(el); + } + continue; + } + case 7: { + if (tag !== 58) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.produces!.push(el); + } + continue; + } + case 10: { + if (tag !== 82) { + break; + } + + const entry10 = Swagger_ResponsesEntry.decode(reader, reader.uint32()); + if (entry10.value !== undefined) { + message.responses![entry10.key] = entry10.value; + } + continue; + } + case 11: { + if (tag !== 90) { + break; + } + + message.securityDefinitions = SecurityDefinitions.decode(reader, reader.uint32()); + continue; + } + case 12: { + if (tag !== 98) { + break; + } + + const el = SecurityRequirement.decode(reader, reader.uint32()); + if (el !== undefined) { + message.security!.push(el); + } + continue; + } + case 13: { + if (tag !== 106) { + break; + } + + const el = Tag.decode(reader, reader.uint32()); + if (el !== undefined) { + message.tags!.push(el); + } + continue; + } + case 14: { + if (tag !== 114) { + break; + } + + message.externalDocs = ExternalDocumentation.decode(reader, reader.uint32()); + continue; + } + case 15: { + if (tag !== 122) { + break; + } + + const entry15 = Swagger_ExtensionsEntry.decode(reader, reader.uint32()); + if (entry15.value !== undefined) { + message.extensions![entry15.key] = entry15.value; + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Swagger { + return { + swagger: isSet(object.swagger) ? globalThis.String(object.swagger) : "", + info: isSet(object.info) ? Info.fromJSON(object.info) : undefined, + host: isSet(object.host) ? globalThis.String(object.host) : "", + basePath: isSet(object.basePath) + ? globalThis.String(object.basePath) + : isSet(object.base_path) + ? globalThis.String(object.base_path) + : "", + schemes: globalThis.Array.isArray(object?.schemes) ? object.schemes.map((e: any) => schemeFromJSON(e)) : [], + consumes: globalThis.Array.isArray(object?.consumes) ? object.consumes.map((e: any) => globalThis.String(e)) : [], + produces: globalThis.Array.isArray(object?.produces) ? object.produces.map((e: any) => globalThis.String(e)) : [], + responses: isObject(object.responses) + ? (globalThis.Object.entries(object.responses) as [string, any][]).reduce( + (acc: { [key: string]: Response }, [key, value]: [string, any]) => { + acc[key] = Response.fromJSON(value); + return acc; + }, + {}, + ) + : {}, + securityDefinitions: isSet(object.securityDefinitions) + ? SecurityDefinitions.fromJSON(object.securityDefinitions) + : isSet(object.security_definitions) + ? SecurityDefinitions.fromJSON(object.security_definitions) + : undefined, + security: globalThis.Array.isArray(object?.security) + ? object.security.map((e: any) => SecurityRequirement.fromJSON(e)) + : [], + tags: globalThis.Array.isArray(object?.tags) + ? object.tags.map((e: any) => Tag.fromJSON(e)) + : [], + externalDocs: isSet(object.externalDocs) + ? ExternalDocumentation.fromJSON(object.externalDocs) + : isSet(object.external_docs) + ? ExternalDocumentation.fromJSON(object.external_docs) + : undefined, + extensions: isObject(object.extensions) + ? (globalThis.Object.entries(object.extensions) as [string, any][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any]) => { + acc[key] = value as any | undefined; + return acc; + }, + {}, + ) + : {}, + }; + }, + + toJSON(message: Swagger): unknown { + const obj: any = {}; + if (message.swagger !== undefined && message.swagger !== "") { + obj.swagger = message.swagger; + } + if (message.info !== undefined) { + obj.info = Info.toJSON(message.info); + } + if (message.host !== undefined && message.host !== "") { + obj.host = message.host; + } + if (message.basePath !== undefined && message.basePath !== "") { + obj.basePath = message.basePath; + } + if (message.schemes?.length) { + obj.schemes = message.schemes.map((e) => schemeToJSON(e)); + } + if (message.consumes?.length) { + obj.consumes = message.consumes; + } + if (message.produces?.length) { + obj.produces = message.produces; + } + if (message.responses) { + const entries = globalThis.Object.entries(message.responses) as [string, Response][]; + if (entries.length > 0) { + obj.responses = {}; + entries.forEach(([k, v]) => { + obj.responses[k] = Response.toJSON(v); + }); + } + } + if (message.securityDefinitions !== undefined) { + obj.securityDefinitions = SecurityDefinitions.toJSON(message.securityDefinitions); + } + if (message.security?.length) { + obj.security = message.security.map((e) => SecurityRequirement.toJSON(e)); + } + if (message.tags?.length) { + obj.tags = message.tags.map((e) => Tag.toJSON(e)); + } + if (message.externalDocs !== undefined) { + obj.externalDocs = ExternalDocumentation.toJSON(message.externalDocs); + } + if (message.extensions) { + const entries = globalThis.Object.entries(message.extensions) as [string, any | undefined][]; + if (entries.length > 0) { + obj.extensions = {}; + entries.forEach(([k, v]) => { + obj.extensions[k] = v; + }); + } + } + return obj; + }, + + create(base?: DeepPartial): Swagger { + return Swagger.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Swagger { + const message = createBaseSwagger(); + message.swagger = object.swagger ?? ""; + message.info = (object.info !== undefined && object.info !== null) ? Info.fromPartial(object.info) : undefined; + message.host = object.host ?? ""; + message.basePath = object.basePath ?? ""; + message.schemes = object.schemes?.map((e) => e) || []; + message.consumes = object.consumes?.map((e) => e) || []; + message.produces = object.produces?.map((e) => e) || []; + message.responses = (globalThis.Object.entries(object.responses ?? {}) as [string, Response][]).reduce( + (acc: { [key: string]: Response }, [key, value]: [string, Response]) => { + if (value !== undefined) { + acc[key] = Response.fromPartial(value); + } + return acc; + }, + {}, + ); + message.securityDefinitions = (object.securityDefinitions !== undefined && object.securityDefinitions !== null) + ? SecurityDefinitions.fromPartial(object.securityDefinitions) + : undefined; + message.security = object.security?.map((e) => SecurityRequirement.fromPartial(e)) || []; + message.tags = object.tags?.map((e) => Tag.fromPartial(e)) || []; + message.externalDocs = (object.externalDocs !== undefined && object.externalDocs !== null) + ? ExternalDocumentation.fromPartial(object.externalDocs) + : undefined; + message.extensions = (globalThis.Object.entries(object.extensions ?? {}) as [string, any | undefined][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any | undefined]) => { + if (value !== undefined) { + acc[key] = value; + } + return acc; + }, + {}, + ); + return message; + }, +}; + +function createBaseSwagger_ResponsesEntry(): Swagger_ResponsesEntry { + return { key: "", value: undefined }; +} + +export const Swagger_ResponsesEntry: MessageFns = { + encode(message: Swagger_ResponsesEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== undefined) { + Response.encode(message.value, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Swagger_ResponsesEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSwagger_ResponsesEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = Response.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Swagger_ResponsesEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object.value) ? Response.fromJSON(object.value) : undefined, + }; + }, + + toJSON(message: Swagger_ResponsesEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== undefined) { + obj.value = Response.toJSON(message.value); + } + return obj; + }, + + create(base?: DeepPartial): Swagger_ResponsesEntry { + return Swagger_ResponsesEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Swagger_ResponsesEntry { + const message = createBaseSwagger_ResponsesEntry(); + message.key = object.key ?? ""; + message.value = (object.value !== undefined && object.value !== null) + ? Response.fromPartial(object.value) + : undefined; + return message; + }, +}; + +function createBaseSwagger_ExtensionsEntry(): Swagger_ExtensionsEntry { + return { key: "", value: undefined }; +} + +export const Swagger_ExtensionsEntry: MessageFns = { + encode(message: Swagger_ExtensionsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== undefined) { + Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Swagger_ExtensionsEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSwagger_ExtensionsEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = Value.unwrap(Value.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Swagger_ExtensionsEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object?.value) ? object.value : undefined, + }; + }, + + toJSON(message: Swagger_ExtensionsEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== undefined) { + obj.value = message.value; + } + return obj; + }, + + create(base?: DeepPartial): Swagger_ExtensionsEntry { + return Swagger_ExtensionsEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Swagger_ExtensionsEntry { + const message = createBaseSwagger_ExtensionsEntry(); + message.key = object.key ?? ""; + message.value = object.value ?? undefined; + return message; + }, +}; + +function createBaseOperation(): Operation { + return { + tags: [], + summary: "", + description: "", + externalDocs: undefined, + operationId: "", + consumes: [], + produces: [], + responses: {}, + schemes: [], + deprecated: false, + security: [], + extensions: {}, + parameters: undefined, + }; +} + +export const Operation: MessageFns = { + encode(message: Operation, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.tags !== undefined && message.tags.length !== 0) { + for (const v of message.tags) { + writer.uint32(10).string(v!); + } + } + if (message.summary !== undefined && message.summary !== "") { + writer.uint32(18).string(message.summary); + } + if (message.description !== undefined && message.description !== "") { + writer.uint32(26).string(message.description); + } + if (message.externalDocs !== undefined) { + ExternalDocumentation.encode(message.externalDocs, writer.uint32(34).fork()).join(); + } + if (message.operationId !== undefined && message.operationId !== "") { + writer.uint32(42).string(message.operationId); + } + if (message.consumes !== undefined && message.consumes.length !== 0) { + for (const v of message.consumes) { + writer.uint32(50).string(v!); + } + } + if (message.produces !== undefined && message.produces.length !== 0) { + for (const v of message.produces) { + writer.uint32(58).string(v!); + } + } + globalThis.Object.entries(message.responses || {}).forEach(([key, value]: [string, Response]) => { + Operation_ResponsesEntry.encode({ key: key as any, value }, writer.uint32(74).fork()).join(); + }); + if (message.schemes !== undefined && message.schemes.length !== 0) { + writer.uint32(82).fork(); + for (const v of message.schemes) { + writer.int32(v); + } + writer.join(); + } + if (message.deprecated !== undefined && message.deprecated !== false) { + writer.uint32(88).bool(message.deprecated); + } + if (message.security !== undefined && message.security.length !== 0) { + for (const v of message.security) { + SecurityRequirement.encode(v!, writer.uint32(98).fork()).join(); + } + } + globalThis.Object.entries(message.extensions || {}).forEach(([key, value]: [string, any | undefined]) => { + if (value !== undefined) { + Operation_ExtensionsEntry.encode({ key: key as any, value }, writer.uint32(106).fork()).join(); + } + }); + if (message.parameters !== undefined) { + Parameters.encode(message.parameters, writer.uint32(114).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Operation { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseOperation(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.tags!.push(el); + } + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.summary = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.description = reader.string(); + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + message.externalDocs = ExternalDocumentation.decode(reader, reader.uint32()); + continue; + } + case 5: { + if (tag !== 42) { + break; + } + + message.operationId = reader.string(); + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.consumes!.push(el); + } + continue; + } + case 7: { + if (tag !== 58) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.produces!.push(el); + } + continue; + } + case 9: { + if (tag !== 74) { + break; + } + + const entry9 = Operation_ResponsesEntry.decode(reader, reader.uint32()); + if (entry9.value !== undefined) { + message.responses![entry9.key] = entry9.value; + } + continue; + } + case 10: { + if (tag === 80) { + message.schemes!.push(reader.int32() as any); + + continue; + } + + if (tag === 82) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.schemes!.push(reader.int32() as any); + } + + continue; + } + + break; + } + case 11: { + if (tag !== 88) { + break; + } + + message.deprecated = reader.bool(); + continue; + } + case 12: { + if (tag !== 98) { + break; + } + + const el = SecurityRequirement.decode(reader, reader.uint32()); + if (el !== undefined) { + message.security!.push(el); + } + continue; + } + case 13: { + if (tag !== 106) { + break; + } + + const entry13 = Operation_ExtensionsEntry.decode(reader, reader.uint32()); + if (entry13.value !== undefined) { + message.extensions![entry13.key] = entry13.value; + } + continue; + } + case 14: { + if (tag !== 114) { + break; + } + + message.parameters = Parameters.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Operation { + return { + tags: globalThis.Array.isArray(object?.tags) ? object.tags.map((e: any) => globalThis.String(e)) : [], + summary: isSet(object.summary) ? globalThis.String(object.summary) : "", + description: isSet(object.description) ? globalThis.String(object.description) : "", + externalDocs: isSet(object.externalDocs) + ? ExternalDocumentation.fromJSON(object.externalDocs) + : isSet(object.external_docs) + ? ExternalDocumentation.fromJSON(object.external_docs) + : undefined, + operationId: isSet(object.operationId) + ? globalThis.String(object.operationId) + : isSet(object.operation_id) + ? globalThis.String(object.operation_id) + : "", + consumes: globalThis.Array.isArray(object?.consumes) ? object.consumes.map((e: any) => globalThis.String(e)) : [], + produces: globalThis.Array.isArray(object?.produces) ? object.produces.map((e: any) => globalThis.String(e)) : [], + responses: isObject(object.responses) + ? (globalThis.Object.entries(object.responses) as [string, any][]).reduce( + (acc: { [key: string]: Response }, [key, value]: [string, any]) => { + acc[key] = Response.fromJSON(value); + return acc; + }, + {}, + ) + : {}, + schemes: globalThis.Array.isArray(object?.schemes) ? object.schemes.map((e: any) => schemeFromJSON(e)) : [], + deprecated: isSet(object.deprecated) ? globalThis.Boolean(object.deprecated) : false, + security: globalThis.Array.isArray(object?.security) + ? object.security.map((e: any) => SecurityRequirement.fromJSON(e)) + : [], + extensions: isObject(object.extensions) + ? (globalThis.Object.entries(object.extensions) as [string, any][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any]) => { + acc[key] = value as any | undefined; + return acc; + }, + {}, + ) + : {}, + parameters: isSet(object.parameters) ? Parameters.fromJSON(object.parameters) : undefined, + }; + }, + + toJSON(message: Operation): unknown { + const obj: any = {}; + if (message.tags?.length) { + obj.tags = message.tags; + } + if (message.summary !== undefined && message.summary !== "") { + obj.summary = message.summary; + } + if (message.description !== undefined && message.description !== "") { + obj.description = message.description; + } + if (message.externalDocs !== undefined) { + obj.externalDocs = ExternalDocumentation.toJSON(message.externalDocs); + } + if (message.operationId !== undefined && message.operationId !== "") { + obj.operationId = message.operationId; + } + if (message.consumes?.length) { + obj.consumes = message.consumes; + } + if (message.produces?.length) { + obj.produces = message.produces; + } + if (message.responses) { + const entries = globalThis.Object.entries(message.responses) as [string, Response][]; + if (entries.length > 0) { + obj.responses = {}; + entries.forEach(([k, v]) => { + obj.responses[k] = Response.toJSON(v); + }); + } + } + if (message.schemes?.length) { + obj.schemes = message.schemes.map((e) => schemeToJSON(e)); + } + if (message.deprecated !== undefined && message.deprecated !== false) { + obj.deprecated = message.deprecated; + } + if (message.security?.length) { + obj.security = message.security.map((e) => SecurityRequirement.toJSON(e)); + } + if (message.extensions) { + const entries = globalThis.Object.entries(message.extensions) as [string, any | undefined][]; + if (entries.length > 0) { + obj.extensions = {}; + entries.forEach(([k, v]) => { + obj.extensions[k] = v; + }); + } + } + if (message.parameters !== undefined) { + obj.parameters = Parameters.toJSON(message.parameters); + } + return obj; + }, + + create(base?: DeepPartial): Operation { + return Operation.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Operation { + const message = createBaseOperation(); + message.tags = object.tags?.map((e) => e) || []; + message.summary = object.summary ?? ""; + message.description = object.description ?? ""; + message.externalDocs = (object.externalDocs !== undefined && object.externalDocs !== null) + ? ExternalDocumentation.fromPartial(object.externalDocs) + : undefined; + message.operationId = object.operationId ?? ""; + message.consumes = object.consumes?.map((e) => e) || []; + message.produces = object.produces?.map((e) => e) || []; + message.responses = (globalThis.Object.entries(object.responses ?? {}) as [string, Response][]).reduce( + (acc: { [key: string]: Response }, [key, value]: [string, Response]) => { + if (value !== undefined) { + acc[key] = Response.fromPartial(value); + } + return acc; + }, + {}, + ); + message.schemes = object.schemes?.map((e) => e) || []; + message.deprecated = object.deprecated ?? false; + message.security = object.security?.map((e) => SecurityRequirement.fromPartial(e)) || []; + message.extensions = (globalThis.Object.entries(object.extensions ?? {}) as [string, any | undefined][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any | undefined]) => { + if (value !== undefined) { + acc[key] = value; + } + return acc; + }, + {}, + ); + message.parameters = (object.parameters !== undefined && object.parameters !== null) + ? Parameters.fromPartial(object.parameters) + : undefined; + return message; + }, +}; + +function createBaseOperation_ResponsesEntry(): Operation_ResponsesEntry { + return { key: "", value: undefined }; +} + +export const Operation_ResponsesEntry: MessageFns = { + encode(message: Operation_ResponsesEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== undefined) { + Response.encode(message.value, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Operation_ResponsesEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseOperation_ResponsesEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = Response.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Operation_ResponsesEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object.value) ? Response.fromJSON(object.value) : undefined, + }; + }, + + toJSON(message: Operation_ResponsesEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== undefined) { + obj.value = Response.toJSON(message.value); + } + return obj; + }, + + create(base?: DeepPartial): Operation_ResponsesEntry { + return Operation_ResponsesEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Operation_ResponsesEntry { + const message = createBaseOperation_ResponsesEntry(); + message.key = object.key ?? ""; + message.value = (object.value !== undefined && object.value !== null) + ? Response.fromPartial(object.value) + : undefined; + return message; + }, +}; + +function createBaseOperation_ExtensionsEntry(): Operation_ExtensionsEntry { + return { key: "", value: undefined }; +} + +export const Operation_ExtensionsEntry: MessageFns = { + encode(message: Operation_ExtensionsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== undefined) { + Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Operation_ExtensionsEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseOperation_ExtensionsEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = Value.unwrap(Value.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Operation_ExtensionsEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object?.value) ? object.value : undefined, + }; + }, + + toJSON(message: Operation_ExtensionsEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== undefined) { + obj.value = message.value; + } + return obj; + }, + + create(base?: DeepPartial): Operation_ExtensionsEntry { + return Operation_ExtensionsEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Operation_ExtensionsEntry { + const message = createBaseOperation_ExtensionsEntry(); + message.key = object.key ?? ""; + message.value = object.value ?? undefined; + return message; + }, +}; + +function createBaseParameters(): Parameters { + return { headers: [] }; +} + +export const Parameters: MessageFns = { + encode(message: Parameters, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.headers !== undefined && message.headers.length !== 0) { + for (const v of message.headers) { + HeaderParameter.encode(v!, writer.uint32(10).fork()).join(); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Parameters { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseParameters(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + const el = HeaderParameter.decode(reader, reader.uint32()); + if (el !== undefined) { + message.headers!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Parameters { + return { + headers: globalThis.Array.isArray(object?.headers) + ? object.headers.map((e: any) => HeaderParameter.fromJSON(e)) + : [], + }; + }, + + toJSON(message: Parameters): unknown { + const obj: any = {}; + if (message.headers?.length) { + obj.headers = message.headers.map((e) => HeaderParameter.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): Parameters { + return Parameters.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Parameters { + const message = createBaseParameters(); + message.headers = object.headers?.map((e) => HeaderParameter.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseHeaderParameter(): HeaderParameter { + return { name: "", description: "", type: 0, format: "", required: false }; +} + +export const HeaderParameter: MessageFns = { + encode(message: HeaderParameter, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.description !== undefined && message.description !== "") { + writer.uint32(18).string(message.description); + } + if (message.type !== undefined && message.type !== 0) { + writer.uint32(24).int32(message.type); + } + if (message.format !== undefined && message.format !== "") { + writer.uint32(34).string(message.format); + } + if (message.required !== undefined && message.required !== false) { + writer.uint32(40).bool(message.required); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): HeaderParameter { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseHeaderParameter(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.description = reader.string(); + continue; + } + case 3: { + if (tag !== 24) { + break; + } + + message.type = reader.int32() as any; + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + message.format = reader.string(); + continue; + } + case 5: { + if (tag !== 40) { + break; + } + + message.required = reader.bool(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): HeaderParameter { + return { + name: isSet(object.name) ? globalThis.String(object.name) : "", + description: isSet(object.description) ? globalThis.String(object.description) : "", + type: isSet(object.type) ? headerParameter_TypeFromJSON(object.type) : 0, + format: isSet(object.format) ? globalThis.String(object.format) : "", + required: isSet(object.required) ? globalThis.Boolean(object.required) : false, + }; + }, + + toJSON(message: HeaderParameter): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.description !== undefined && message.description !== "") { + obj.description = message.description; + } + if (message.type !== undefined && message.type !== 0) { + obj.type = headerParameter_TypeToJSON(message.type); + } + if (message.format !== undefined && message.format !== "") { + obj.format = message.format; + } + if (message.required !== undefined && message.required !== false) { + obj.required = message.required; + } + return obj; + }, + + create(base?: DeepPartial): HeaderParameter { + return HeaderParameter.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): HeaderParameter { + const message = createBaseHeaderParameter(); + message.name = object.name ?? ""; + message.description = object.description ?? ""; + message.type = object.type ?? 0; + message.format = object.format ?? ""; + message.required = object.required ?? false; + return message; + }, +}; + +function createBaseHeader(): Header { + return { description: "", type: "", format: "", default: "", pattern: "" }; +} + +export const Header: MessageFns
= { + encode(message: Header, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.description !== undefined && message.description !== "") { + writer.uint32(10).string(message.description); + } + if (message.type !== undefined && message.type !== "") { + writer.uint32(18).string(message.type); + } + if (message.format !== undefined && message.format !== "") { + writer.uint32(26).string(message.format); + } + if (message.default !== undefined && message.default !== "") { + writer.uint32(50).string(message.default); + } + if (message.pattern !== undefined && message.pattern !== "") { + writer.uint32(106).string(message.pattern); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Header { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseHeader(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.description = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.type = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.format = reader.string(); + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + message.default = reader.string(); + continue; + } + case 13: { + if (tag !== 106) { + break; + } + + message.pattern = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Header { + return { + description: isSet(object.description) ? globalThis.String(object.description) : "", + type: isSet(object.type) ? globalThis.String(object.type) : "", + format: isSet(object.format) ? globalThis.String(object.format) : "", + default: isSet(object.default) ? globalThis.String(object.default) : "", + pattern: isSet(object.pattern) ? globalThis.String(object.pattern) : "", + }; + }, + + toJSON(message: Header): unknown { + const obj: any = {}; + if (message.description !== undefined && message.description !== "") { + obj.description = message.description; + } + if (message.type !== undefined && message.type !== "") { + obj.type = message.type; + } + if (message.format !== undefined && message.format !== "") { + obj.format = message.format; + } + if (message.default !== undefined && message.default !== "") { + obj.default = message.default; + } + if (message.pattern !== undefined && message.pattern !== "") { + obj.pattern = message.pattern; + } + return obj; + }, + + create(base?: DeepPartial
): Header { + return Header.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial
): Header { + const message = createBaseHeader(); + message.description = object.description ?? ""; + message.type = object.type ?? ""; + message.format = object.format ?? ""; + message.default = object.default ?? ""; + message.pattern = object.pattern ?? ""; + return message; + }, +}; + +function createBaseResponse(): Response { + return { description: "", schema: undefined, headers: {}, examples: {}, extensions: {} }; +} + +export const Response: MessageFns = { + encode(message: Response, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.description !== undefined && message.description !== "") { + writer.uint32(10).string(message.description); + } + if (message.schema !== undefined) { + Schema.encode(message.schema, writer.uint32(18).fork()).join(); + } + globalThis.Object.entries(message.headers || {}).forEach(([key, value]: [string, Header]) => { + Response_HeadersEntry.encode({ key: key as any, value }, writer.uint32(26).fork()).join(); + }); + globalThis.Object.entries(message.examples || {}).forEach(([key, value]: [string, string]) => { + Response_ExamplesEntry.encode({ key: key as any, value }, writer.uint32(34).fork()).join(); + }); + globalThis.Object.entries(message.extensions || {}).forEach(([key, value]: [string, any | undefined]) => { + if (value !== undefined) { + Response_ExtensionsEntry.encode({ key: key as any, value }, writer.uint32(42).fork()).join(); + } + }); + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Response { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.description = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.schema = Schema.decode(reader, reader.uint32()); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + const entry3 = Response_HeadersEntry.decode(reader, reader.uint32()); + if (entry3.value !== undefined) { + message.headers![entry3.key] = entry3.value; + } + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + const entry4 = Response_ExamplesEntry.decode(reader, reader.uint32()); + if (entry4.value !== undefined) { + message.examples![entry4.key] = entry4.value; + } + continue; + } + case 5: { + if (tag !== 42) { + break; + } + + const entry5 = Response_ExtensionsEntry.decode(reader, reader.uint32()); + if (entry5.value !== undefined) { + message.extensions![entry5.key] = entry5.value; + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Response { + return { + description: isSet(object.description) ? globalThis.String(object.description) : "", + schema: isSet(object.schema) ? Schema.fromJSON(object.schema) : undefined, + headers: isObject(object.headers) + ? (globalThis.Object.entries(object.headers) as [string, any][]).reduce( + (acc: { [key: string]: Header }, [key, value]: [string, any]) => { + acc[key] = Header.fromJSON(value); + return acc; + }, + {}, + ) + : {}, + examples: isObject(object.examples) + ? (globalThis.Object.entries(object.examples) as [string, any][]).reduce( + (acc: { [key: string]: string }, [key, value]: [string, any]) => { + acc[key] = globalThis.String(value); + return acc; + }, + {}, + ) + : {}, + extensions: isObject(object.extensions) + ? (globalThis.Object.entries(object.extensions) as [string, any][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any]) => { + acc[key] = value as any | undefined; + return acc; + }, + {}, + ) + : {}, + }; + }, + + toJSON(message: Response): unknown { + const obj: any = {}; + if (message.description !== undefined && message.description !== "") { + obj.description = message.description; + } + if (message.schema !== undefined) { + obj.schema = Schema.toJSON(message.schema); + } + if (message.headers) { + const entries = globalThis.Object.entries(message.headers) as [string, Header][]; + if (entries.length > 0) { + obj.headers = {}; + entries.forEach(([k, v]) => { + obj.headers[k] = Header.toJSON(v); + }); + } + } + if (message.examples) { + const entries = globalThis.Object.entries(message.examples) as [string, string][]; + if (entries.length > 0) { + obj.examples = {}; + entries.forEach(([k, v]) => { + obj.examples[k] = v; + }); + } + } + if (message.extensions) { + const entries = globalThis.Object.entries(message.extensions) as [string, any | undefined][]; + if (entries.length > 0) { + obj.extensions = {}; + entries.forEach(([k, v]) => { + obj.extensions[k] = v; + }); + } + } + return obj; + }, + + create(base?: DeepPartial): Response { + return Response.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Response { + const message = createBaseResponse(); + message.description = object.description ?? ""; + message.schema = (object.schema !== undefined && object.schema !== null) + ? Schema.fromPartial(object.schema) + : undefined; + message.headers = (globalThis.Object.entries(object.headers ?? {}) as [string, Header][]).reduce( + (acc: { [key: string]: Header }, [key, value]: [string, Header]) => { + if (value !== undefined) { + acc[key] = Header.fromPartial(value); + } + return acc; + }, + {}, + ); + message.examples = (globalThis.Object.entries(object.examples ?? {}) as [string, string][]).reduce( + (acc: { [key: string]: string }, [key, value]: [string, string]) => { + if (value !== undefined) { + acc[key] = globalThis.String(value); + } + return acc; + }, + {}, + ); + message.extensions = (globalThis.Object.entries(object.extensions ?? {}) as [string, any | undefined][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any | undefined]) => { + if (value !== undefined) { + acc[key] = value; + } + return acc; + }, + {}, + ); + return message; + }, +}; + +function createBaseResponse_HeadersEntry(): Response_HeadersEntry { + return { key: "", value: undefined }; +} + +export const Response_HeadersEntry: MessageFns = { + encode(message: Response_HeadersEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== undefined) { + Header.encode(message.value, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Response_HeadersEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseResponse_HeadersEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = Header.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Response_HeadersEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object.value) ? Header.fromJSON(object.value) : undefined, + }; + }, + + toJSON(message: Response_HeadersEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== undefined) { + obj.value = Header.toJSON(message.value); + } + return obj; + }, + + create(base?: DeepPartial): Response_HeadersEntry { + return Response_HeadersEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Response_HeadersEntry { + const message = createBaseResponse_HeadersEntry(); + message.key = object.key ?? ""; + message.value = (object.value !== undefined && object.value !== null) + ? Header.fromPartial(object.value) + : undefined; + return message; + }, +}; + +function createBaseResponse_ExamplesEntry(): Response_ExamplesEntry { + return { key: "", value: "" }; +} + +export const Response_ExamplesEntry: MessageFns = { + encode(message: Response_ExamplesEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== "") { + writer.uint32(18).string(message.value); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Response_ExamplesEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseResponse_ExamplesEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Response_ExamplesEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object.value) ? globalThis.String(object.value) : "", + }; + }, + + toJSON(message: Response_ExamplesEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== "") { + obj.value = message.value; + } + return obj; + }, + + create(base?: DeepPartial): Response_ExamplesEntry { + return Response_ExamplesEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Response_ExamplesEntry { + const message = createBaseResponse_ExamplesEntry(); + message.key = object.key ?? ""; + message.value = object.value ?? ""; + return message; + }, +}; + +function createBaseResponse_ExtensionsEntry(): Response_ExtensionsEntry { + return { key: "", value: undefined }; +} + +export const Response_ExtensionsEntry: MessageFns = { + encode(message: Response_ExtensionsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== undefined) { + Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Response_ExtensionsEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseResponse_ExtensionsEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = Value.unwrap(Value.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Response_ExtensionsEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object?.value) ? object.value : undefined, + }; + }, + + toJSON(message: Response_ExtensionsEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== undefined) { + obj.value = message.value; + } + return obj; + }, + + create(base?: DeepPartial): Response_ExtensionsEntry { + return Response_ExtensionsEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Response_ExtensionsEntry { + const message = createBaseResponse_ExtensionsEntry(); + message.key = object.key ?? ""; + message.value = object.value ?? undefined; + return message; + }, +}; + +function createBaseInfo(): Info { + return { + title: "", + description: "", + termsOfService: "", + contact: undefined, + license: undefined, + version: "", + extensions: {}, + }; +} + +export const Info: MessageFns = { + encode(message: Info, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.title !== undefined && message.title !== "") { + writer.uint32(10).string(message.title); + } + if (message.description !== undefined && message.description !== "") { + writer.uint32(18).string(message.description); + } + if (message.termsOfService !== undefined && message.termsOfService !== "") { + writer.uint32(26).string(message.termsOfService); + } + if (message.contact !== undefined) { + Contact.encode(message.contact, writer.uint32(34).fork()).join(); + } + if (message.license !== undefined) { + License.encode(message.license, writer.uint32(42).fork()).join(); + } + if (message.version !== undefined && message.version !== "") { + writer.uint32(50).string(message.version); + } + globalThis.Object.entries(message.extensions || {}).forEach(([key, value]: [string, any | undefined]) => { + if (value !== undefined) { + Info_ExtensionsEntry.encode({ key: key as any, value }, writer.uint32(58).fork()).join(); + } + }); + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Info { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseInfo(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.title = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.description = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.termsOfService = reader.string(); + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + message.contact = Contact.decode(reader, reader.uint32()); + continue; + } + case 5: { + if (tag !== 42) { + break; + } + + message.license = License.decode(reader, reader.uint32()); + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + message.version = reader.string(); + continue; + } + case 7: { + if (tag !== 58) { + break; + } + + const entry7 = Info_ExtensionsEntry.decode(reader, reader.uint32()); + if (entry7.value !== undefined) { + message.extensions![entry7.key] = entry7.value; + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Info { + return { + title: isSet(object.title) ? globalThis.String(object.title) : "", + description: isSet(object.description) ? globalThis.String(object.description) : "", + termsOfService: isSet(object.termsOfService) + ? globalThis.String(object.termsOfService) + : isSet(object.terms_of_service) + ? globalThis.String(object.terms_of_service) + : "", + contact: isSet(object.contact) ? Contact.fromJSON(object.contact) : undefined, + license: isSet(object.license) ? License.fromJSON(object.license) : undefined, + version: isSet(object.version) ? globalThis.String(object.version) : "", + extensions: isObject(object.extensions) + ? (globalThis.Object.entries(object.extensions) as [string, any][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any]) => { + acc[key] = value as any | undefined; + return acc; + }, + {}, + ) + : {}, + }; + }, + + toJSON(message: Info): unknown { + const obj: any = {}; + if (message.title !== undefined && message.title !== "") { + obj.title = message.title; + } + if (message.description !== undefined && message.description !== "") { + obj.description = message.description; + } + if (message.termsOfService !== undefined && message.termsOfService !== "") { + obj.termsOfService = message.termsOfService; + } + if (message.contact !== undefined) { + obj.contact = Contact.toJSON(message.contact); + } + if (message.license !== undefined) { + obj.license = License.toJSON(message.license); + } + if (message.version !== undefined && message.version !== "") { + obj.version = message.version; + } + if (message.extensions) { + const entries = globalThis.Object.entries(message.extensions) as [string, any | undefined][]; + if (entries.length > 0) { + obj.extensions = {}; + entries.forEach(([k, v]) => { + obj.extensions[k] = v; + }); + } + } + return obj; + }, + + create(base?: DeepPartial): Info { + return Info.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Info { + const message = createBaseInfo(); + message.title = object.title ?? ""; + message.description = object.description ?? ""; + message.termsOfService = object.termsOfService ?? ""; + message.contact = (object.contact !== undefined && object.contact !== null) + ? Contact.fromPartial(object.contact) + : undefined; + message.license = (object.license !== undefined && object.license !== null) + ? License.fromPartial(object.license) + : undefined; + message.version = object.version ?? ""; + message.extensions = (globalThis.Object.entries(object.extensions ?? {}) as [string, any | undefined][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any | undefined]) => { + if (value !== undefined) { + acc[key] = value; + } + return acc; + }, + {}, + ); + return message; + }, +}; + +function createBaseInfo_ExtensionsEntry(): Info_ExtensionsEntry { + return { key: "", value: undefined }; +} + +export const Info_ExtensionsEntry: MessageFns = { + encode(message: Info_ExtensionsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== undefined) { + Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Info_ExtensionsEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseInfo_ExtensionsEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = Value.unwrap(Value.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Info_ExtensionsEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object?.value) ? object.value : undefined, + }; + }, + + toJSON(message: Info_ExtensionsEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== undefined) { + obj.value = message.value; + } + return obj; + }, + + create(base?: DeepPartial): Info_ExtensionsEntry { + return Info_ExtensionsEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Info_ExtensionsEntry { + const message = createBaseInfo_ExtensionsEntry(); + message.key = object.key ?? ""; + message.value = object.value ?? undefined; + return message; + }, +}; + +function createBaseContact(): Contact { + return { name: "", url: "", email: "" }; +} + +export const Contact: MessageFns = { + encode(message: Contact, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.url !== undefined && message.url !== "") { + writer.uint32(18).string(message.url); + } + if (message.email !== undefined && message.email !== "") { + writer.uint32(26).string(message.email); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Contact { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseContact(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.url = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.email = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Contact { + return { + name: isSet(object.name) ? globalThis.String(object.name) : "", + url: isSet(object.url) ? globalThis.String(object.url) : "", + email: isSet(object.email) ? globalThis.String(object.email) : "", + }; + }, + + toJSON(message: Contact): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.url !== undefined && message.url !== "") { + obj.url = message.url; + } + if (message.email !== undefined && message.email !== "") { + obj.email = message.email; + } + return obj; + }, + + create(base?: DeepPartial): Contact { + return Contact.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Contact { + const message = createBaseContact(); + message.name = object.name ?? ""; + message.url = object.url ?? ""; + message.email = object.email ?? ""; + return message; + }, +}; + +function createBaseLicense(): License { + return { name: "", url: "" }; +} + +export const License: MessageFns = { + encode(message: License, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.url !== undefined && message.url !== "") { + writer.uint32(18).string(message.url); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): License { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseLicense(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.url = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): License { + return { + name: isSet(object.name) ? globalThis.String(object.name) : "", + url: isSet(object.url) ? globalThis.String(object.url) : "", + }; + }, + + toJSON(message: License): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.url !== undefined && message.url !== "") { + obj.url = message.url; + } + return obj; + }, + + create(base?: DeepPartial): License { + return License.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): License { + const message = createBaseLicense(); + message.name = object.name ?? ""; + message.url = object.url ?? ""; + return message; + }, +}; + +function createBaseExternalDocumentation(): ExternalDocumentation { + return { description: "", url: "" }; +} + +export const ExternalDocumentation: MessageFns = { + encode(message: ExternalDocumentation, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.description !== undefined && message.description !== "") { + writer.uint32(10).string(message.description); + } + if (message.url !== undefined && message.url !== "") { + writer.uint32(18).string(message.url); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): ExternalDocumentation { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseExternalDocumentation(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.description = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.url = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): ExternalDocumentation { + return { + description: isSet(object.description) ? globalThis.String(object.description) : "", + url: isSet(object.url) ? globalThis.String(object.url) : "", + }; + }, + + toJSON(message: ExternalDocumentation): unknown { + const obj: any = {}; + if (message.description !== undefined && message.description !== "") { + obj.description = message.description; + } + if (message.url !== undefined && message.url !== "") { + obj.url = message.url; + } + return obj; + }, + + create(base?: DeepPartial): ExternalDocumentation { + return ExternalDocumentation.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): ExternalDocumentation { + const message = createBaseExternalDocumentation(); + message.description = object.description ?? ""; + message.url = object.url ?? ""; + return message; + }, +}; + +function createBaseSchema(): Schema { + return { jsonSchema: undefined, discriminator: "", readOnly: false, externalDocs: undefined, example: "" }; +} + +export const Schema: MessageFns = { + encode(message: Schema, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.jsonSchema !== undefined) { + JSONSchema.encode(message.jsonSchema, writer.uint32(10).fork()).join(); + } + if (message.discriminator !== undefined && message.discriminator !== "") { + writer.uint32(18).string(message.discriminator); + } + if (message.readOnly !== undefined && message.readOnly !== false) { + writer.uint32(24).bool(message.readOnly); + } + if (message.externalDocs !== undefined) { + ExternalDocumentation.encode(message.externalDocs, writer.uint32(42).fork()).join(); + } + if (message.example !== undefined && message.example !== "") { + writer.uint32(50).string(message.example); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Schema { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSchema(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.jsonSchema = JSONSchema.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.discriminator = reader.string(); + continue; + } + case 3: { + if (tag !== 24) { + break; + } + + message.readOnly = reader.bool(); + continue; + } + case 5: { + if (tag !== 42) { + break; + } + + message.externalDocs = ExternalDocumentation.decode(reader, reader.uint32()); + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + message.example = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Schema { + return { + jsonSchema: isSet(object.jsonSchema) + ? JSONSchema.fromJSON(object.jsonSchema) + : isSet(object.json_schema) + ? JSONSchema.fromJSON(object.json_schema) + : undefined, + discriminator: isSet(object.discriminator) ? globalThis.String(object.discriminator) : "", + readOnly: isSet(object.readOnly) + ? globalThis.Boolean(object.readOnly) + : isSet(object.read_only) + ? globalThis.Boolean(object.read_only) + : false, + externalDocs: isSet(object.externalDocs) + ? ExternalDocumentation.fromJSON(object.externalDocs) + : isSet(object.external_docs) + ? ExternalDocumentation.fromJSON(object.external_docs) + : undefined, + example: isSet(object.example) ? globalThis.String(object.example) : "", + }; + }, + + toJSON(message: Schema): unknown { + const obj: any = {}; + if (message.jsonSchema !== undefined) { + obj.jsonSchema = JSONSchema.toJSON(message.jsonSchema); + } + if (message.discriminator !== undefined && message.discriminator !== "") { + obj.discriminator = message.discriminator; + } + if (message.readOnly !== undefined && message.readOnly !== false) { + obj.readOnly = message.readOnly; + } + if (message.externalDocs !== undefined) { + obj.externalDocs = ExternalDocumentation.toJSON(message.externalDocs); + } + if (message.example !== undefined && message.example !== "") { + obj.example = message.example; + } + return obj; + }, + + create(base?: DeepPartial): Schema { + return Schema.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Schema { + const message = createBaseSchema(); + message.jsonSchema = (object.jsonSchema !== undefined && object.jsonSchema !== null) + ? JSONSchema.fromPartial(object.jsonSchema) + : undefined; + message.discriminator = object.discriminator ?? ""; + message.readOnly = object.readOnly ?? false; + message.externalDocs = (object.externalDocs !== undefined && object.externalDocs !== null) + ? ExternalDocumentation.fromPartial(object.externalDocs) + : undefined; + message.example = object.example ?? ""; + return message; + }, +}; + +function createBaseEnumSchema(): EnumSchema { + return { + description: "", + default: "", + title: "", + required: false, + readOnly: false, + externalDocs: undefined, + example: "", + ref: "", + extensions: {}, + }; +} + +export const EnumSchema: MessageFns = { + encode(message: EnumSchema, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.description !== undefined && message.description !== "") { + writer.uint32(10).string(message.description); + } + if (message.default !== undefined && message.default !== "") { + writer.uint32(18).string(message.default); + } + if (message.title !== undefined && message.title !== "") { + writer.uint32(26).string(message.title); + } + if (message.required !== undefined && message.required !== false) { + writer.uint32(32).bool(message.required); + } + if (message.readOnly !== undefined && message.readOnly !== false) { + writer.uint32(40).bool(message.readOnly); + } + if (message.externalDocs !== undefined) { + ExternalDocumentation.encode(message.externalDocs, writer.uint32(50).fork()).join(); + } + if (message.example !== undefined && message.example !== "") { + writer.uint32(58).string(message.example); + } + if (message.ref !== undefined && message.ref !== "") { + writer.uint32(66).string(message.ref); + } + globalThis.Object.entries(message.extensions || {}).forEach(([key, value]: [string, any | undefined]) => { + if (value !== undefined) { + EnumSchema_ExtensionsEntry.encode({ key: key as any, value }, writer.uint32(74).fork()).join(); + } + }); + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): EnumSchema { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEnumSchema(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.description = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.default = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.title = reader.string(); + continue; + } + case 4: { + if (tag !== 32) { + break; + } + + message.required = reader.bool(); + continue; + } + case 5: { + if (tag !== 40) { + break; + } + + message.readOnly = reader.bool(); + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + message.externalDocs = ExternalDocumentation.decode(reader, reader.uint32()); + continue; + } + case 7: { + if (tag !== 58) { + break; + } + + message.example = reader.string(); + continue; + } + case 8: { + if (tag !== 66) { + break; + } + + message.ref = reader.string(); + continue; + } + case 9: { + if (tag !== 74) { + break; + } + + const entry9 = EnumSchema_ExtensionsEntry.decode(reader, reader.uint32()); + if (entry9.value !== undefined) { + message.extensions![entry9.key] = entry9.value; + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): EnumSchema { + return { + description: isSet(object.description) ? globalThis.String(object.description) : "", + default: isSet(object.default) ? globalThis.String(object.default) : "", + title: isSet(object.title) ? globalThis.String(object.title) : "", + required: isSet(object.required) ? globalThis.Boolean(object.required) : false, + readOnly: isSet(object.readOnly) + ? globalThis.Boolean(object.readOnly) + : isSet(object.read_only) + ? globalThis.Boolean(object.read_only) + : false, + externalDocs: isSet(object.externalDocs) + ? ExternalDocumentation.fromJSON(object.externalDocs) + : isSet(object.external_docs) + ? ExternalDocumentation.fromJSON(object.external_docs) + : undefined, + example: isSet(object.example) ? globalThis.String(object.example) : "", + ref: isSet(object.ref) ? globalThis.String(object.ref) : "", + extensions: isObject(object.extensions) + ? (globalThis.Object.entries(object.extensions) as [string, any][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any]) => { + acc[key] = value as any | undefined; + return acc; + }, + {}, + ) + : {}, + }; + }, + + toJSON(message: EnumSchema): unknown { + const obj: any = {}; + if (message.description !== undefined && message.description !== "") { + obj.description = message.description; + } + if (message.default !== undefined && message.default !== "") { + obj.default = message.default; + } + if (message.title !== undefined && message.title !== "") { + obj.title = message.title; + } + if (message.required !== undefined && message.required !== false) { + obj.required = message.required; + } + if (message.readOnly !== undefined && message.readOnly !== false) { + obj.readOnly = message.readOnly; + } + if (message.externalDocs !== undefined) { + obj.externalDocs = ExternalDocumentation.toJSON(message.externalDocs); + } + if (message.example !== undefined && message.example !== "") { + obj.example = message.example; + } + if (message.ref !== undefined && message.ref !== "") { + obj.ref = message.ref; + } + if (message.extensions) { + const entries = globalThis.Object.entries(message.extensions) as [string, any | undefined][]; + if (entries.length > 0) { + obj.extensions = {}; + entries.forEach(([k, v]) => { + obj.extensions[k] = v; + }); + } + } + return obj; + }, + + create(base?: DeepPartial): EnumSchema { + return EnumSchema.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): EnumSchema { + const message = createBaseEnumSchema(); + message.description = object.description ?? ""; + message.default = object.default ?? ""; + message.title = object.title ?? ""; + message.required = object.required ?? false; + message.readOnly = object.readOnly ?? false; + message.externalDocs = (object.externalDocs !== undefined && object.externalDocs !== null) + ? ExternalDocumentation.fromPartial(object.externalDocs) + : undefined; + message.example = object.example ?? ""; + message.ref = object.ref ?? ""; + message.extensions = (globalThis.Object.entries(object.extensions ?? {}) as [string, any | undefined][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any | undefined]) => { + if (value !== undefined) { + acc[key] = value; + } + return acc; + }, + {}, + ); + return message; + }, +}; + +function createBaseEnumSchema_ExtensionsEntry(): EnumSchema_ExtensionsEntry { + return { key: "", value: undefined }; +} + +export const EnumSchema_ExtensionsEntry: MessageFns = { + encode(message: EnumSchema_ExtensionsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== undefined) { + Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): EnumSchema_ExtensionsEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEnumSchema_ExtensionsEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = Value.unwrap(Value.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): EnumSchema_ExtensionsEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object?.value) ? object.value : undefined, + }; + }, + + toJSON(message: EnumSchema_ExtensionsEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== undefined) { + obj.value = message.value; + } + return obj; + }, + + create(base?: DeepPartial): EnumSchema_ExtensionsEntry { + return EnumSchema_ExtensionsEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): EnumSchema_ExtensionsEntry { + const message = createBaseEnumSchema_ExtensionsEntry(); + message.key = object.key ?? ""; + message.value = object.value ?? undefined; + return message; + }, +}; + +function createBaseJSONSchema(): JSONSchema { + return { + ref: "", + title: "", + description: "", + default: "", + readOnly: false, + example: "", + multipleOf: 0, + maximum: 0, + exclusiveMaximum: false, + minimum: 0, + exclusiveMinimum: false, + maxLength: 0, + minLength: 0, + pattern: "", + maxItems: 0, + minItems: 0, + uniqueItems: false, + maxProperties: 0, + minProperties: 0, + required: [], + array: [], + type: [], + format: "", + enum: [], + fieldConfiguration: undefined, + extensions: {}, + }; +} + +export const JSONSchema: MessageFns = { + encode(message: JSONSchema, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.ref !== undefined && message.ref !== "") { + writer.uint32(26).string(message.ref); + } + if (message.title !== undefined && message.title !== "") { + writer.uint32(42).string(message.title); + } + if (message.description !== undefined && message.description !== "") { + writer.uint32(50).string(message.description); + } + if (message.default !== undefined && message.default !== "") { + writer.uint32(58).string(message.default); + } + if (message.readOnly !== undefined && message.readOnly !== false) { + writer.uint32(64).bool(message.readOnly); + } + if (message.example !== undefined && message.example !== "") { + writer.uint32(74).string(message.example); + } + if (message.multipleOf !== undefined && message.multipleOf !== 0) { + writer.uint32(81).double(message.multipleOf); + } + if (message.maximum !== undefined && message.maximum !== 0) { + writer.uint32(89).double(message.maximum); + } + if (message.exclusiveMaximum !== undefined && message.exclusiveMaximum !== false) { + writer.uint32(96).bool(message.exclusiveMaximum); + } + if (message.minimum !== undefined && message.minimum !== 0) { + writer.uint32(105).double(message.minimum); + } + if (message.exclusiveMinimum !== undefined && message.exclusiveMinimum !== false) { + writer.uint32(112).bool(message.exclusiveMinimum); + } + if (message.maxLength !== undefined && message.maxLength !== 0) { + writer.uint32(120).uint64(message.maxLength); + } + if (message.minLength !== undefined && message.minLength !== 0) { + writer.uint32(128).uint64(message.minLength); + } + if (message.pattern !== undefined && message.pattern !== "") { + writer.uint32(138).string(message.pattern); + } + if (message.maxItems !== undefined && message.maxItems !== 0) { + writer.uint32(160).uint64(message.maxItems); + } + if (message.minItems !== undefined && message.minItems !== 0) { + writer.uint32(168).uint64(message.minItems); + } + if (message.uniqueItems !== undefined && message.uniqueItems !== false) { + writer.uint32(176).bool(message.uniqueItems); + } + if (message.maxProperties !== undefined && message.maxProperties !== 0) { + writer.uint32(192).uint64(message.maxProperties); + } + if (message.minProperties !== undefined && message.minProperties !== 0) { + writer.uint32(200).uint64(message.minProperties); + } + if (message.required !== undefined && message.required.length !== 0) { + for (const v of message.required) { + writer.uint32(210).string(v!); + } + } + if (message.array !== undefined && message.array.length !== 0) { + for (const v of message.array) { + writer.uint32(274).string(v!); + } + } + if (message.type !== undefined && message.type.length !== 0) { + writer.uint32(282).fork(); + for (const v of message.type) { + writer.int32(v); + } + writer.join(); + } + if (message.format !== undefined && message.format !== "") { + writer.uint32(290).string(message.format); + } + if (message.enum !== undefined && message.enum.length !== 0) { + for (const v of message.enum) { + writer.uint32(370).string(v!); + } + } + if (message.fieldConfiguration !== undefined) { + JSONSchema_FieldConfiguration.encode(message.fieldConfiguration, writer.uint32(8010).fork()).join(); + } + globalThis.Object.entries(message.extensions || {}).forEach(([key, value]: [string, any | undefined]) => { + if (value !== undefined) { + JSONSchema_ExtensionsEntry.encode({ key: key as any, value }, writer.uint32(386).fork()).join(); + } + }); + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): JSONSchema { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseJSONSchema(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 3: { + if (tag !== 26) { + break; + } + + message.ref = reader.string(); + continue; + } + case 5: { + if (tag !== 42) { + break; + } + + message.title = reader.string(); + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + message.description = reader.string(); + continue; + } + case 7: { + if (tag !== 58) { + break; + } + + message.default = reader.string(); + continue; + } + case 8: { + if (tag !== 64) { + break; + } + + message.readOnly = reader.bool(); + continue; + } + case 9: { + if (tag !== 74) { + break; + } + + message.example = reader.string(); + continue; + } + case 10: { + if (tag !== 81) { + break; + } + + message.multipleOf = reader.double(); + continue; + } + case 11: { + if (tag !== 89) { + break; + } + + message.maximum = reader.double(); + continue; + } + case 12: { + if (tag !== 96) { + break; + } + + message.exclusiveMaximum = reader.bool(); + continue; + } + case 13: { + if (tag !== 105) { + break; + } + + message.minimum = reader.double(); + continue; + } + case 14: { + if (tag !== 112) { + break; + } + + message.exclusiveMinimum = reader.bool(); + continue; + } + case 15: { + if (tag !== 120) { + break; + } + + message.maxLength = longToNumber(reader.uint64()); + continue; + } + case 16: { + if (tag !== 128) { + break; + } + + message.minLength = longToNumber(reader.uint64()); + continue; + } + case 17: { + if (tag !== 138) { + break; + } + + message.pattern = reader.string(); + continue; + } + case 20: { + if (tag !== 160) { + break; + } + + message.maxItems = longToNumber(reader.uint64()); + continue; + } + case 21: { + if (tag !== 168) { + break; + } + + message.minItems = longToNumber(reader.uint64()); + continue; + } + case 22: { + if (tag !== 176) { + break; + } + + message.uniqueItems = reader.bool(); + continue; + } + case 24: { + if (tag !== 192) { + break; + } + + message.maxProperties = longToNumber(reader.uint64()); + continue; + } + case 25: { + if (tag !== 200) { + break; + } + + message.minProperties = longToNumber(reader.uint64()); + continue; + } + case 26: { + if (tag !== 210) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.required!.push(el); + } + continue; + } + case 34: { + if (tag !== 274) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.array!.push(el); + } + continue; + } + case 35: { + if (tag === 280) { + message.type!.push(reader.int32() as any); + + continue; + } + + if (tag === 282) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.type!.push(reader.int32() as any); + } + + continue; + } + + break; + } + case 36: { + if (tag !== 290) { + break; + } + + message.format = reader.string(); + continue; + } + case 46: { + if (tag !== 370) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.enum!.push(el); + } + continue; + } + case 1001: { + if (tag !== 8010) { + break; + } + + message.fieldConfiguration = JSONSchema_FieldConfiguration.decode(reader, reader.uint32()); + continue; + } + case 48: { + if (tag !== 386) { + break; + } + + const entry48 = JSONSchema_ExtensionsEntry.decode(reader, reader.uint32()); + if (entry48.value !== undefined) { + message.extensions![entry48.key] = entry48.value; + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): JSONSchema { + return { + ref: isSet(object.ref) ? globalThis.String(object.ref) : "", + title: isSet(object.title) ? globalThis.String(object.title) : "", + description: isSet(object.description) ? globalThis.String(object.description) : "", + default: isSet(object.default) ? globalThis.String(object.default) : "", + readOnly: isSet(object.readOnly) + ? globalThis.Boolean(object.readOnly) + : isSet(object.read_only) + ? globalThis.Boolean(object.read_only) + : false, + example: isSet(object.example) ? globalThis.String(object.example) : "", + multipleOf: isSet(object.multipleOf) + ? globalThis.Number(object.multipleOf) + : isSet(object.multiple_of) + ? globalThis.Number(object.multiple_of) + : 0, + maximum: isSet(object.maximum) ? globalThis.Number(object.maximum) : 0, + exclusiveMaximum: isSet(object.exclusiveMaximum) + ? globalThis.Boolean(object.exclusiveMaximum) + : isSet(object.exclusive_maximum) + ? globalThis.Boolean(object.exclusive_maximum) + : false, + minimum: isSet(object.minimum) ? globalThis.Number(object.minimum) : 0, + exclusiveMinimum: isSet(object.exclusiveMinimum) + ? globalThis.Boolean(object.exclusiveMinimum) + : isSet(object.exclusive_minimum) + ? globalThis.Boolean(object.exclusive_minimum) + : false, + maxLength: isSet(object.maxLength) + ? globalThis.Number(object.maxLength) + : isSet(object.max_length) + ? globalThis.Number(object.max_length) + : 0, + minLength: isSet(object.minLength) + ? globalThis.Number(object.minLength) + : isSet(object.min_length) + ? globalThis.Number(object.min_length) + : 0, + pattern: isSet(object.pattern) ? globalThis.String(object.pattern) : "", + maxItems: isSet(object.maxItems) + ? globalThis.Number(object.maxItems) + : isSet(object.max_items) + ? globalThis.Number(object.max_items) + : 0, + minItems: isSet(object.minItems) + ? globalThis.Number(object.minItems) + : isSet(object.min_items) + ? globalThis.Number(object.min_items) + : 0, + uniqueItems: isSet(object.uniqueItems) + ? globalThis.Boolean(object.uniqueItems) + : isSet(object.unique_items) + ? globalThis.Boolean(object.unique_items) + : false, + maxProperties: isSet(object.maxProperties) + ? globalThis.Number(object.maxProperties) + : isSet(object.max_properties) + ? globalThis.Number(object.max_properties) + : 0, + minProperties: isSet(object.minProperties) + ? globalThis.Number(object.minProperties) + : isSet(object.min_properties) + ? globalThis.Number(object.min_properties) + : 0, + required: globalThis.Array.isArray(object?.required) + ? object.required.map((e: any) => globalThis.String(e)) + : [], + array: globalThis.Array.isArray(object?.array) + ? object.array.map((e: any) => globalThis.String(e)) + : [], + type: globalThis.Array.isArray(object?.type) + ? object.type.map((e: any) => jSONSchema_JSONSchemaSimpleTypesFromJSON(e)) + : [], + format: isSet(object.format) ? globalThis.String(object.format) : "", + enum: globalThis.Array.isArray(object?.enum) + ? object.enum.map((e: any) => globalThis.String(e)) + : [], + fieldConfiguration: isSet(object.fieldConfiguration) + ? JSONSchema_FieldConfiguration.fromJSON(object.fieldConfiguration) + : isSet(object.field_configuration) + ? JSONSchema_FieldConfiguration.fromJSON(object.field_configuration) + : undefined, + extensions: isObject(object.extensions) + ? (globalThis.Object.entries(object.extensions) as [string, any][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any]) => { + acc[key] = value as any | undefined; + return acc; + }, + {}, + ) + : {}, + }; + }, + + toJSON(message: JSONSchema): unknown { + const obj: any = {}; + if (message.ref !== undefined && message.ref !== "") { + obj.ref = message.ref; + } + if (message.title !== undefined && message.title !== "") { + obj.title = message.title; + } + if (message.description !== undefined && message.description !== "") { + obj.description = message.description; + } + if (message.default !== undefined && message.default !== "") { + obj.default = message.default; + } + if (message.readOnly !== undefined && message.readOnly !== false) { + obj.readOnly = message.readOnly; + } + if (message.example !== undefined && message.example !== "") { + obj.example = message.example; + } + if (message.multipleOf !== undefined && message.multipleOf !== 0) { + obj.multipleOf = message.multipleOf; + } + if (message.maximum !== undefined && message.maximum !== 0) { + obj.maximum = message.maximum; + } + if (message.exclusiveMaximum !== undefined && message.exclusiveMaximum !== false) { + obj.exclusiveMaximum = message.exclusiveMaximum; + } + if (message.minimum !== undefined && message.minimum !== 0) { + obj.minimum = message.minimum; + } + if (message.exclusiveMinimum !== undefined && message.exclusiveMinimum !== false) { + obj.exclusiveMinimum = message.exclusiveMinimum; + } + if (message.maxLength !== undefined && message.maxLength !== 0) { + obj.maxLength = Math.round(message.maxLength); + } + if (message.minLength !== undefined && message.minLength !== 0) { + obj.minLength = Math.round(message.minLength); + } + if (message.pattern !== undefined && message.pattern !== "") { + obj.pattern = message.pattern; + } + if (message.maxItems !== undefined && message.maxItems !== 0) { + obj.maxItems = Math.round(message.maxItems); + } + if (message.minItems !== undefined && message.minItems !== 0) { + obj.minItems = Math.round(message.minItems); + } + if (message.uniqueItems !== undefined && message.uniqueItems !== false) { + obj.uniqueItems = message.uniqueItems; + } + if (message.maxProperties !== undefined && message.maxProperties !== 0) { + obj.maxProperties = Math.round(message.maxProperties); + } + if (message.minProperties !== undefined && message.minProperties !== 0) { + obj.minProperties = Math.round(message.minProperties); + } + if (message.required?.length) { + obj.required = message.required; + } + if (message.array?.length) { + obj.array = message.array; + } + if (message.type?.length) { + obj.type = message.type.map((e) => jSONSchema_JSONSchemaSimpleTypesToJSON(e)); + } + if (message.format !== undefined && message.format !== "") { + obj.format = message.format; + } + if (message.enum?.length) { + obj.enum = message.enum; + } + if (message.fieldConfiguration !== undefined) { + obj.fieldConfiguration = JSONSchema_FieldConfiguration.toJSON(message.fieldConfiguration); + } + if (message.extensions) { + const entries = globalThis.Object.entries(message.extensions) as [string, any | undefined][]; + if (entries.length > 0) { + obj.extensions = {}; + entries.forEach(([k, v]) => { + obj.extensions[k] = v; + }); + } + } + return obj; + }, + + create(base?: DeepPartial): JSONSchema { + return JSONSchema.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): JSONSchema { + const message = createBaseJSONSchema(); + message.ref = object.ref ?? ""; + message.title = object.title ?? ""; + message.description = object.description ?? ""; + message.default = object.default ?? ""; + message.readOnly = object.readOnly ?? false; + message.example = object.example ?? ""; + message.multipleOf = object.multipleOf ?? 0; + message.maximum = object.maximum ?? 0; + message.exclusiveMaximum = object.exclusiveMaximum ?? false; + message.minimum = object.minimum ?? 0; + message.exclusiveMinimum = object.exclusiveMinimum ?? false; + message.maxLength = object.maxLength ?? 0; + message.minLength = object.minLength ?? 0; + message.pattern = object.pattern ?? ""; + message.maxItems = object.maxItems ?? 0; + message.minItems = object.minItems ?? 0; + message.uniqueItems = object.uniqueItems ?? false; + message.maxProperties = object.maxProperties ?? 0; + message.minProperties = object.minProperties ?? 0; + message.required = object.required?.map((e) => e) || []; + message.array = object.array?.map((e) => e) || []; + message.type = object.type?.map((e) => e) || []; + message.format = object.format ?? ""; + message.enum = object.enum?.map((e) => e) || []; + message.fieldConfiguration = (object.fieldConfiguration !== undefined && object.fieldConfiguration !== null) + ? JSONSchema_FieldConfiguration.fromPartial(object.fieldConfiguration) + : undefined; + message.extensions = (globalThis.Object.entries(object.extensions ?? {}) as [string, any | undefined][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any | undefined]) => { + if (value !== undefined) { + acc[key] = value; + } + return acc; + }, + {}, + ); + return message; + }, +}; + +function createBaseJSONSchema_FieldConfiguration(): JSONSchema_FieldConfiguration { + return { pathParamName: "", deprecated: false }; +} + +export const JSONSchema_FieldConfiguration: MessageFns = { + encode(message: JSONSchema_FieldConfiguration, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.pathParamName !== undefined && message.pathParamName !== "") { + writer.uint32(378).string(message.pathParamName); + } + if (message.deprecated !== undefined && message.deprecated !== false) { + writer.uint32(392).bool(message.deprecated); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): JSONSchema_FieldConfiguration { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseJSONSchema_FieldConfiguration(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 47: { + if (tag !== 378) { + break; + } + + message.pathParamName = reader.string(); + continue; + } + case 49: { + if (tag !== 392) { + break; + } + + message.deprecated = reader.bool(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): JSONSchema_FieldConfiguration { + return { + pathParamName: isSet(object.pathParamName) + ? globalThis.String(object.pathParamName) + : isSet(object.path_param_name) + ? globalThis.String(object.path_param_name) + : "", + deprecated: isSet(object.deprecated) ? globalThis.Boolean(object.deprecated) : false, + }; + }, + + toJSON(message: JSONSchema_FieldConfiguration): unknown { + const obj: any = {}; + if (message.pathParamName !== undefined && message.pathParamName !== "") { + obj.pathParamName = message.pathParamName; + } + if (message.deprecated !== undefined && message.deprecated !== false) { + obj.deprecated = message.deprecated; + } + return obj; + }, + + create(base?: DeepPartial): JSONSchema_FieldConfiguration { + return JSONSchema_FieldConfiguration.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): JSONSchema_FieldConfiguration { + const message = createBaseJSONSchema_FieldConfiguration(); + message.pathParamName = object.pathParamName ?? ""; + message.deprecated = object.deprecated ?? false; + return message; + }, +}; + +function createBaseJSONSchema_ExtensionsEntry(): JSONSchema_ExtensionsEntry { + return { key: "", value: undefined }; +} + +export const JSONSchema_ExtensionsEntry: MessageFns = { + encode(message: JSONSchema_ExtensionsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== undefined) { + Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): JSONSchema_ExtensionsEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseJSONSchema_ExtensionsEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = Value.unwrap(Value.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): JSONSchema_ExtensionsEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object?.value) ? object.value : undefined, + }; + }, + + toJSON(message: JSONSchema_ExtensionsEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== undefined) { + obj.value = message.value; + } + return obj; + }, + + create(base?: DeepPartial): JSONSchema_ExtensionsEntry { + return JSONSchema_ExtensionsEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): JSONSchema_ExtensionsEntry { + const message = createBaseJSONSchema_ExtensionsEntry(); + message.key = object.key ?? ""; + message.value = object.value ?? undefined; + return message; + }, +}; + +function createBaseTag(): Tag { + return { name: "", description: "", externalDocs: undefined, extensions: {} }; +} + +export const Tag: MessageFns = { + encode(message: Tag, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.name !== undefined && message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.description !== undefined && message.description !== "") { + writer.uint32(18).string(message.description); + } + if (message.externalDocs !== undefined) { + ExternalDocumentation.encode(message.externalDocs, writer.uint32(26).fork()).join(); + } + globalThis.Object.entries(message.extensions || {}).forEach(([key, value]: [string, any | undefined]) => { + if (value !== undefined) { + Tag_ExtensionsEntry.encode({ key: key as any, value }, writer.uint32(34).fork()).join(); + } + }); + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Tag { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseTag(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.name = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.description = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.externalDocs = ExternalDocumentation.decode(reader, reader.uint32()); + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + const entry4 = Tag_ExtensionsEntry.decode(reader, reader.uint32()); + if (entry4.value !== undefined) { + message.extensions![entry4.key] = entry4.value; + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Tag { + return { + name: isSet(object.name) ? globalThis.String(object.name) : "", + description: isSet(object.description) ? globalThis.String(object.description) : "", + externalDocs: isSet(object.externalDocs) + ? ExternalDocumentation.fromJSON(object.externalDocs) + : isSet(object.external_docs) + ? ExternalDocumentation.fromJSON(object.external_docs) + : undefined, + extensions: isObject(object.extensions) + ? (globalThis.Object.entries(object.extensions) as [string, any][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any]) => { + acc[key] = value as any | undefined; + return acc; + }, + {}, + ) + : {}, + }; + }, + + toJSON(message: Tag): unknown { + const obj: any = {}; + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.description !== undefined && message.description !== "") { + obj.description = message.description; + } + if (message.externalDocs !== undefined) { + obj.externalDocs = ExternalDocumentation.toJSON(message.externalDocs); + } + if (message.extensions) { + const entries = globalThis.Object.entries(message.extensions) as [string, any | undefined][]; + if (entries.length > 0) { + obj.extensions = {}; + entries.forEach(([k, v]) => { + obj.extensions[k] = v; + }); + } + } + return obj; + }, + + create(base?: DeepPartial): Tag { + return Tag.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Tag { + const message = createBaseTag(); + message.name = object.name ?? ""; + message.description = object.description ?? ""; + message.externalDocs = (object.externalDocs !== undefined && object.externalDocs !== null) + ? ExternalDocumentation.fromPartial(object.externalDocs) + : undefined; + message.extensions = (globalThis.Object.entries(object.extensions ?? {}) as [string, any | undefined][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any | undefined]) => { + if (value !== undefined) { + acc[key] = value; + } + return acc; + }, + {}, + ); + return message; + }, +}; + +function createBaseTag_ExtensionsEntry(): Tag_ExtensionsEntry { + return { key: "", value: undefined }; +} + +export const Tag_ExtensionsEntry: MessageFns = { + encode(message: Tag_ExtensionsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== undefined) { + Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Tag_ExtensionsEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseTag_ExtensionsEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = Value.unwrap(Value.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Tag_ExtensionsEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object?.value) ? object.value : undefined, + }; + }, + + toJSON(message: Tag_ExtensionsEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== undefined) { + obj.value = message.value; + } + return obj; + }, + + create(base?: DeepPartial): Tag_ExtensionsEntry { + return Tag_ExtensionsEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Tag_ExtensionsEntry { + const message = createBaseTag_ExtensionsEntry(); + message.key = object.key ?? ""; + message.value = object.value ?? undefined; + return message; + }, +}; + +function createBaseSecurityDefinitions(): SecurityDefinitions { + return { security: {} }; +} + +export const SecurityDefinitions: MessageFns = { + encode(message: SecurityDefinitions, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + globalThis.Object.entries(message.security || {}).forEach(([key, value]: [string, SecurityScheme]) => { + SecurityDefinitions_SecurityEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).join(); + }); + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): SecurityDefinitions { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSecurityDefinitions(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + const entry1 = SecurityDefinitions_SecurityEntry.decode(reader, reader.uint32()); + if (entry1.value !== undefined) { + message.security![entry1.key] = entry1.value; + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): SecurityDefinitions { + return { + security: isObject(object.security) + ? (globalThis.Object.entries(object.security) as [string, any][]).reduce( + (acc: { [key: string]: SecurityScheme }, [key, value]: [string, any]) => { + acc[key] = SecurityScheme.fromJSON(value); + return acc; + }, + {}, + ) + : {}, + }; + }, + + toJSON(message: SecurityDefinitions): unknown { + const obj: any = {}; + if (message.security) { + const entries = globalThis.Object.entries(message.security) as [string, SecurityScheme][]; + if (entries.length > 0) { + obj.security = {}; + entries.forEach(([k, v]) => { + obj.security[k] = SecurityScheme.toJSON(v); + }); + } + } + return obj; + }, + + create(base?: DeepPartial): SecurityDefinitions { + return SecurityDefinitions.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): SecurityDefinitions { + const message = createBaseSecurityDefinitions(); + message.security = (globalThis.Object.entries(object.security ?? {}) as [string, SecurityScheme][]).reduce( + (acc: { [key: string]: SecurityScheme }, [key, value]: [string, SecurityScheme]) => { + if (value !== undefined) { + acc[key] = SecurityScheme.fromPartial(value); + } + return acc; + }, + {}, + ); + return message; + }, +}; + +function createBaseSecurityDefinitions_SecurityEntry(): SecurityDefinitions_SecurityEntry { + return { key: "", value: undefined }; +} + +export const SecurityDefinitions_SecurityEntry: MessageFns = { + encode(message: SecurityDefinitions_SecurityEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== undefined) { + SecurityScheme.encode(message.value, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): SecurityDefinitions_SecurityEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSecurityDefinitions_SecurityEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = SecurityScheme.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): SecurityDefinitions_SecurityEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object.value) ? SecurityScheme.fromJSON(object.value) : undefined, + }; + }, + + toJSON(message: SecurityDefinitions_SecurityEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== undefined) { + obj.value = SecurityScheme.toJSON(message.value); + } + return obj; + }, + + create(base?: DeepPartial): SecurityDefinitions_SecurityEntry { + return SecurityDefinitions_SecurityEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): SecurityDefinitions_SecurityEntry { + const message = createBaseSecurityDefinitions_SecurityEntry(); + message.key = object.key ?? ""; + message.value = (object.value !== undefined && object.value !== null) + ? SecurityScheme.fromPartial(object.value) + : undefined; + return message; + }, +}; + +function createBaseSecurityScheme(): SecurityScheme { + return { + type: 0, + description: "", + name: "", + in: 0, + flow: 0, + authorizationUrl: "", + tokenUrl: "", + scopes: undefined, + extensions: {}, + }; +} + +export const SecurityScheme: MessageFns = { + encode(message: SecurityScheme, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.type !== undefined && message.type !== 0) { + writer.uint32(8).int32(message.type); + } + if (message.description !== undefined && message.description !== "") { + writer.uint32(18).string(message.description); + } + if (message.name !== undefined && message.name !== "") { + writer.uint32(26).string(message.name); + } + if (message.in !== undefined && message.in !== 0) { + writer.uint32(32).int32(message.in); + } + if (message.flow !== undefined && message.flow !== 0) { + writer.uint32(40).int32(message.flow); + } + if (message.authorizationUrl !== undefined && message.authorizationUrl !== "") { + writer.uint32(50).string(message.authorizationUrl); + } + if (message.tokenUrl !== undefined && message.tokenUrl !== "") { + writer.uint32(58).string(message.tokenUrl); + } + if (message.scopes !== undefined) { + Scopes.encode(message.scopes, writer.uint32(66).fork()).join(); + } + globalThis.Object.entries(message.extensions || {}).forEach(([key, value]: [string, any | undefined]) => { + if (value !== undefined) { + SecurityScheme_ExtensionsEntry.encode({ key: key as any, value }, writer.uint32(74).fork()).join(); + } + }); + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): SecurityScheme { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSecurityScheme(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.type = reader.int32() as any; + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.description = reader.string(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.name = reader.string(); + continue; + } + case 4: { + if (tag !== 32) { + break; + } + + message.in = reader.int32() as any; + continue; + } + case 5: { + if (tag !== 40) { + break; + } + + message.flow = reader.int32() as any; + continue; + } + case 6: { + if (tag !== 50) { + break; + } + + message.authorizationUrl = reader.string(); + continue; + } + case 7: { + if (tag !== 58) { + break; + } + + message.tokenUrl = reader.string(); + continue; + } + case 8: { + if (tag !== 66) { + break; + } + + message.scopes = Scopes.decode(reader, reader.uint32()); + continue; + } + case 9: { + if (tag !== 74) { + break; + } + + const entry9 = SecurityScheme_ExtensionsEntry.decode(reader, reader.uint32()); + if (entry9.value !== undefined) { + message.extensions![entry9.key] = entry9.value; + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): SecurityScheme { + return { + type: isSet(object.type) ? securityScheme_TypeFromJSON(object.type) : 0, + description: isSet(object.description) ? globalThis.String(object.description) : "", + name: isSet(object.name) ? globalThis.String(object.name) : "", + in: isSet(object.in) ? securityScheme_InFromJSON(object.in) : 0, + flow: isSet(object.flow) ? securityScheme_FlowFromJSON(object.flow) : 0, + authorizationUrl: isSet(object.authorizationUrl) + ? globalThis.String(object.authorizationUrl) + : isSet(object.authorization_url) + ? globalThis.String(object.authorization_url) + : "", + tokenUrl: isSet(object.tokenUrl) + ? globalThis.String(object.tokenUrl) + : isSet(object.token_url) + ? globalThis.String(object.token_url) + : "", + scopes: isSet(object.scopes) ? Scopes.fromJSON(object.scopes) : undefined, + extensions: isObject(object.extensions) + ? (globalThis.Object.entries(object.extensions) as [string, any][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any]) => { + acc[key] = value as any | undefined; + return acc; + }, + {}, + ) + : {}, + }; + }, + + toJSON(message: SecurityScheme): unknown { + const obj: any = {}; + if (message.type !== undefined && message.type !== 0) { + obj.type = securityScheme_TypeToJSON(message.type); + } + if (message.description !== undefined && message.description !== "") { + obj.description = message.description; + } + if (message.name !== undefined && message.name !== "") { + obj.name = message.name; + } + if (message.in !== undefined && message.in !== 0) { + obj.in = securityScheme_InToJSON(message.in); + } + if (message.flow !== undefined && message.flow !== 0) { + obj.flow = securityScheme_FlowToJSON(message.flow); + } + if (message.authorizationUrl !== undefined && message.authorizationUrl !== "") { + obj.authorizationUrl = message.authorizationUrl; + } + if (message.tokenUrl !== undefined && message.tokenUrl !== "") { + obj.tokenUrl = message.tokenUrl; + } + if (message.scopes !== undefined) { + obj.scopes = Scopes.toJSON(message.scopes); + } + if (message.extensions) { + const entries = globalThis.Object.entries(message.extensions) as [string, any | undefined][]; + if (entries.length > 0) { + obj.extensions = {}; + entries.forEach(([k, v]) => { + obj.extensions[k] = v; + }); + } + } + return obj; + }, + + create(base?: DeepPartial): SecurityScheme { + return SecurityScheme.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): SecurityScheme { + const message = createBaseSecurityScheme(); + message.type = object.type ?? 0; + message.description = object.description ?? ""; + message.name = object.name ?? ""; + message.in = object.in ?? 0; + message.flow = object.flow ?? 0; + message.authorizationUrl = object.authorizationUrl ?? ""; + message.tokenUrl = object.tokenUrl ?? ""; + message.scopes = (object.scopes !== undefined && object.scopes !== null) + ? Scopes.fromPartial(object.scopes) + : undefined; + message.extensions = (globalThis.Object.entries(object.extensions ?? {}) as [string, any | undefined][]).reduce( + (acc: { [key: string]: any | undefined }, [key, value]: [string, any | undefined]) => { + if (value !== undefined) { + acc[key] = value; + } + return acc; + }, + {}, + ); + return message; + }, +}; + +function createBaseSecurityScheme_ExtensionsEntry(): SecurityScheme_ExtensionsEntry { + return { key: "", value: undefined }; +} + +export const SecurityScheme_ExtensionsEntry: MessageFns = { + encode(message: SecurityScheme_ExtensionsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== undefined) { + Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): SecurityScheme_ExtensionsEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSecurityScheme_ExtensionsEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = Value.unwrap(Value.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): SecurityScheme_ExtensionsEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object?.value) ? object.value : undefined, + }; + }, + + toJSON(message: SecurityScheme_ExtensionsEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== undefined) { + obj.value = message.value; + } + return obj; + }, + + create(base?: DeepPartial): SecurityScheme_ExtensionsEntry { + return SecurityScheme_ExtensionsEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): SecurityScheme_ExtensionsEntry { + const message = createBaseSecurityScheme_ExtensionsEntry(); + message.key = object.key ?? ""; + message.value = object.value ?? undefined; + return message; + }, +}; + +function createBaseSecurityRequirement(): SecurityRequirement { + return { securityRequirement: {} }; +} + +export const SecurityRequirement: MessageFns = { + encode(message: SecurityRequirement, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + globalThis.Object.entries(message.securityRequirement || {}).forEach( + ([key, value]: [string, SecurityRequirement_SecurityRequirementValue]) => { + SecurityRequirement_SecurityRequirementEntry.encode({ key: key as any, value }, writer.uint32(10).fork()) + .join(); + }, + ); + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): SecurityRequirement { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSecurityRequirement(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + const entry1 = SecurityRequirement_SecurityRequirementEntry.decode(reader, reader.uint32()); + if (entry1.value !== undefined) { + message.securityRequirement![entry1.key] = entry1.value; + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): SecurityRequirement { + return { + securityRequirement: isObject(object.securityRequirement) + ? (globalThis.Object.entries(object.securityRequirement) as [string, any][]).reduce( + (acc: { [key: string]: SecurityRequirement_SecurityRequirementValue }, [key, value]: [string, any]) => { + acc[key] = SecurityRequirement_SecurityRequirementValue.fromJSON(value); + return acc; + }, + {}, + ) + : isObject(object.security_requirement) + ? (globalThis.Object.entries(object.security_requirement) as [string, any][]).reduce( + (acc: { [key: string]: SecurityRequirement_SecurityRequirementValue }, [key, value]: [string, any]) => { + acc[key] = SecurityRequirement_SecurityRequirementValue.fromJSON(value); + return acc; + }, + {}, + ) + : {}, + }; + }, + + toJSON(message: SecurityRequirement): unknown { + const obj: any = {}; + if (message.securityRequirement) { + const entries = globalThis.Object.entries(message.securityRequirement) as [ + string, + SecurityRequirement_SecurityRequirementValue, + ][]; + if (entries.length > 0) { + obj.securityRequirement = {}; + entries.forEach(([k, v]) => { + obj.securityRequirement[k] = SecurityRequirement_SecurityRequirementValue.toJSON(v); + }); + } + } + return obj; + }, + + create(base?: DeepPartial): SecurityRequirement { + return SecurityRequirement.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): SecurityRequirement { + const message = createBaseSecurityRequirement(); + message.securityRequirement = + (globalThis.Object.entries(object.securityRequirement ?? {}) as [ + string, + SecurityRequirement_SecurityRequirementValue, + ][]).reduce( + ( + acc: { [key: string]: SecurityRequirement_SecurityRequirementValue }, + [key, value]: [string, SecurityRequirement_SecurityRequirementValue], + ) => { + if (value !== undefined) { + acc[key] = SecurityRequirement_SecurityRequirementValue.fromPartial(value); + } + return acc; + }, + {}, + ); + return message; + }, +}; + +function createBaseSecurityRequirement_SecurityRequirementValue(): SecurityRequirement_SecurityRequirementValue { + return { scope: [] }; +} + +export const SecurityRequirement_SecurityRequirementValue: MessageFns = { + encode( + message: SecurityRequirement_SecurityRequirementValue, + writer: BinaryWriter = new BinaryWriter(), + ): BinaryWriter { + if (message.scope !== undefined && message.scope.length !== 0) { + for (const v of message.scope) { + writer.uint32(10).string(v!); + } + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): SecurityRequirement_SecurityRequirementValue { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSecurityRequirement_SecurityRequirementValue(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + const el = reader.string(); + if (el !== undefined) { + message.scope!.push(el); + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): SecurityRequirement_SecurityRequirementValue { + return { scope: globalThis.Array.isArray(object?.scope) ? object.scope.map((e: any) => globalThis.String(e)) : [] }; + }, + + toJSON(message: SecurityRequirement_SecurityRequirementValue): unknown { + const obj: any = {}; + if (message.scope?.length) { + obj.scope = message.scope; + } + return obj; + }, + + create( + base?: DeepPartial, + ): SecurityRequirement_SecurityRequirementValue { + return SecurityRequirement_SecurityRequirementValue.fromPartial(base ?? {}); + }, + fromPartial( + object: DeepPartial, + ): SecurityRequirement_SecurityRequirementValue { + const message = createBaseSecurityRequirement_SecurityRequirementValue(); + message.scope = object.scope?.map((e) => e) || []; + return message; + }, +}; + +function createBaseSecurityRequirement_SecurityRequirementEntry(): SecurityRequirement_SecurityRequirementEntry { + return { key: "", value: undefined }; +} + +export const SecurityRequirement_SecurityRequirementEntry: MessageFns = { + encode( + message: SecurityRequirement_SecurityRequirementEntry, + writer: BinaryWriter = new BinaryWriter(), + ): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== undefined) { + SecurityRequirement_SecurityRequirementValue.encode(message.value, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): SecurityRequirement_SecurityRequirementEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseSecurityRequirement_SecurityRequirementEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = SecurityRequirement_SecurityRequirementValue.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): SecurityRequirement_SecurityRequirementEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object.value) ? SecurityRequirement_SecurityRequirementValue.fromJSON(object.value) : undefined, + }; + }, + + toJSON(message: SecurityRequirement_SecurityRequirementEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== undefined) { + obj.value = SecurityRequirement_SecurityRequirementValue.toJSON(message.value); + } + return obj; + }, + + create( + base?: DeepPartial, + ): SecurityRequirement_SecurityRequirementEntry { + return SecurityRequirement_SecurityRequirementEntry.fromPartial(base ?? {}); + }, + fromPartial( + object: DeepPartial, + ): SecurityRequirement_SecurityRequirementEntry { + const message = createBaseSecurityRequirement_SecurityRequirementEntry(); + message.key = object.key ?? ""; + message.value = (object.value !== undefined && object.value !== null) + ? SecurityRequirement_SecurityRequirementValue.fromPartial(object.value) + : undefined; + return message; + }, +}; + +function createBaseScopes(): Scopes { + return { scope: {} }; +} + +export const Scopes: MessageFns = { + encode(message: Scopes, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + globalThis.Object.entries(message.scope || {}).forEach(([key, value]: [string, string]) => { + Scopes_ScopeEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).join(); + }); + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Scopes { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseScopes(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + const entry1 = Scopes_ScopeEntry.decode(reader, reader.uint32()); + if (entry1.value !== undefined) { + message.scope![entry1.key] = entry1.value; + } + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Scopes { + return { + scope: isObject(object.scope) + ? (globalThis.Object.entries(object.scope) as [string, any][]).reduce( + (acc: { [key: string]: string }, [key, value]: [string, any]) => { + acc[key] = globalThis.String(value); + return acc; + }, + {}, + ) + : {}, + }; + }, + + toJSON(message: Scopes): unknown { + const obj: any = {}; + if (message.scope) { + const entries = globalThis.Object.entries(message.scope) as [string, string][]; + if (entries.length > 0) { + obj.scope = {}; + entries.forEach(([k, v]) => { + obj.scope[k] = v; + }); + } + } + return obj; + }, + + create(base?: DeepPartial): Scopes { + return Scopes.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Scopes { + const message = createBaseScopes(); + message.scope = (globalThis.Object.entries(object.scope ?? {}) as [string, string][]).reduce( + (acc: { [key: string]: string }, [key, value]: [string, string]) => { + if (value !== undefined) { + acc[key] = globalThis.String(value); + } + return acc; + }, + {}, + ); + return message; + }, +}; + +function createBaseScopes_ScopeEntry(): Scopes_ScopeEntry { + return { key: "", value: "" }; +} + +export const Scopes_ScopeEntry: MessageFns = { + encode(message: Scopes_ScopeEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.key !== "") { + writer.uint32(10).string(message.key); + } + if (message.value !== "") { + writer.uint32(18).string(message.value); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): Scopes_ScopeEntry { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + const end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseScopes_ScopeEntry(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.key = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.value = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): Scopes_ScopeEntry { + return { + key: isSet(object.key) ? globalThis.String(object.key) : "", + value: isSet(object.value) ? globalThis.String(object.value) : "", + }; + }, + + toJSON(message: Scopes_ScopeEntry): unknown { + const obj: any = {}; + if (message.key !== "") { + obj.key = message.key; + } + if (message.value !== "") { + obj.value = message.value; + } + return obj; + }, + + create(base?: DeepPartial): Scopes_ScopeEntry { + return Scopes_ScopeEntry.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): Scopes_ScopeEntry { + const message = createBaseScopes_ScopeEntry(); + message.key = object.key ?? ""; + message.value = object.value ?? ""; + return message; + }, +}; + +type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined; + +export type DeepPartial = T extends Builtin ? T + : T extends globalThis.Array ? globalThis.Array> + : T extends ReadonlyArray ? ReadonlyArray> + : T extends {} ? { [K in keyof T]?: DeepPartial } + : Partial; + +function longToNumber(int64: { toString(): string }): number { + const num = globalThis.Number(int64.toString()); + if (num > globalThis.Number.MAX_SAFE_INTEGER) { + throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER"); + } + if (num < globalThis.Number.MIN_SAFE_INTEGER) { + throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER"); + } + return num; +} + +function isObject(value: any): boolean { + return typeof value === "object" && value !== null; +} + +function isSet(value: any): boolean { + return value !== null && value !== undefined; +} + +export interface MessageFns { + encode(message: T, writer?: BinaryWriter): BinaryWriter; + decode(input: BinaryReader | Uint8Array, length?: number): T; + fromJSON(object: any): T; + toJSON(message: T): unknown; + create(base?: DeepPartial): T; + fromPartial(object: DeepPartial): T; +}