diff --git a/frontend/.eslintrc.cjs b/frontend/.eslintrc.cjs
index a4b92ac..f9539de 100644
--- a/frontend/.eslintrc.cjs
+++ b/frontend/.eslintrc.cjs
@@ -5,4 +5,5 @@ module.exports = {
'no-console': 'off',
'max-len': ['error', { ignoreStrings: true, code: 120 }],
},
+ ignorePatterns: ['src/proto-gen/*'],
};
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 5351475..5acfeb6 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -14,10 +14,13 @@
"@massalabs/prettier-config-as": "^0.0.2",
"@massalabs/react-ui-kit": "^0.0.5-dev",
"@massalabs/wallet-provider": "^2.0.1-dev",
+ "@protobuf-ts/grpcweb-transport": "^2.9.4",
+ "@protobuf-ts/runtime-rpc": "^2.9.4",
"axios": "^1.7.2",
"dot-object": "^2.1.5",
"eslint-plugin-html": "^8.1.1",
"eslint-plugin-import": "^2.29.1",
+ "google-protobuf": "^3.21.4",
"husky": "^9.0.11",
"lodash": "^4.17.21",
"react": "^18.2.0",
@@ -258,17 +261,19 @@
}
},
"node_modules/@babel/helper-string-parser": {
- "version": "7.24.1",
- "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.24.1.tgz",
- "integrity": "sha512-2ofRCjnnA9y+wk8b9IAREroeUP02KHp431N2mhKniy2yKIDKpbrHv9eXwm8cBeWQYcJmzv5qKCu65P47eCF7CQ==",
+ "version": "7.25.9",
+ "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.9.tgz",
+ "integrity": "sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==",
+ "license": "MIT",
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/helper-validator-identifier": {
- "version": "7.24.5",
- "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.24.5.tgz",
- "integrity": "sha512-3q93SSKX2TWCG30M2G2kwaKeTYgEUp5Snjuj8qm729SObL6nbtUldAi37qbxkD5gg3xnBio+f9nqpSepGZMvxA==",
+ "version": "7.25.9",
+ "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz",
+ "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==",
+ "license": "MIT",
"engines": {
"node": ">=6.9.0"
}
@@ -309,9 +314,13 @@
}
},
"node_modules/@babel/parser": {
- "version": "7.24.5",
- "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.24.5.tgz",
- "integrity": "sha512-EOv5IK8arwh3LI47dz1b0tKUb/1uhHAnHJOrjgtQMIpu1uXd9mlFrJg9IUgGUgZ41Ch0K8REPTYpO7B76b4vJg==",
+ "version": "7.26.3",
+ "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.26.3.tgz",
+ "integrity": "sha512-WJ/CvmY8Mea8iDXo6a7RK2wbmJITT5fN3BEkRuFlxVyNx8jOKIIhmC4fSkTcPcf8JyavbBwIe6OpiCOBXt/IcA==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/types": "^7.26.3"
+ },
"bin": {
"parser": "bin/babel-parser.js"
},
@@ -383,13 +392,13 @@
}
},
"node_modules/@babel/types": {
- "version": "7.24.5",
- "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.24.5.tgz",
- "integrity": "sha512-6mQNsaLeXTw0nxYUYu+NSa4Hx4BlF1x1x8/PMFbiR+GBSr+2DkECc69b8hgy2frEodNcvPffeH8YfWd3LI6jhQ==",
+ "version": "7.26.3",
+ "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.3.tgz",
+ "integrity": "sha512-vN5p+1kl59GVKMvTHt55NzzmYVxprfJD+ql7U9NFIfKCBkYE55LYtS+WtPlaYOyzydrKI8Nezd+aZextrd+FMA==",
+ "license": "MIT",
"dependencies": {
- "@babel/helper-string-parser": "^7.24.1",
- "@babel/helper-validator-identifier": "^7.24.5",
- "to-fast-properties": "^2.0.0"
+ "@babel/helper-string-parser": "^7.25.9",
+ "@babel/helper-validator-identifier": "^7.25.9"
},
"engines": {
"node": ">=6.9.0"
@@ -992,9 +1001,10 @@
}
},
"node_modules/@jridgewell/sourcemap-codec": {
- "version": "1.4.15",
- "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz",
- "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg=="
+ "version": "1.5.0",
+ "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
+ "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
+ "license": "MIT"
},
"node_modules/@jridgewell/trace-mapping": {
"version": "0.3.25",
@@ -1954,6 +1964,31 @@
"node": ">=14"
}
},
+ "node_modules/@protobuf-ts/grpcweb-transport": {
+ "version": "2.9.4",
+ "resolved": "https://registry.npmjs.org/@protobuf-ts/grpcweb-transport/-/grpcweb-transport-2.9.4.tgz",
+ "integrity": "sha512-6aQgwPTgX6FkqWqmNts3uk8T/C5coJoH7U87zgaZY/Wo2EVa9SId5bXTM8uo4WR+CN8j9W4c9ij1yG13Hc3xUw==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@protobuf-ts/runtime": "^2.9.4",
+ "@protobuf-ts/runtime-rpc": "^2.9.4"
+ }
+ },
+ "node_modules/@protobuf-ts/runtime": {
+ "version": "2.9.4",
+ "resolved": "https://registry.npmjs.org/@protobuf-ts/runtime/-/runtime-2.9.4.tgz",
+ "integrity": "sha512-vHRFWtJJB/SiogWDF0ypoKfRIZ41Kq+G9cEFj6Qm1eQaAhJ1LDFvgZ7Ja4tb3iLOQhz0PaoPnnOijF1qmEqTxg==",
+ "license": "(Apache-2.0 AND BSD-3-Clause)"
+ },
+ "node_modules/@protobuf-ts/runtime-rpc": {
+ "version": "2.9.4",
+ "resolved": "https://registry.npmjs.org/@protobuf-ts/runtime-rpc/-/runtime-rpc-2.9.4.tgz",
+ "integrity": "sha512-y9L9JgnZxXFqH5vD4d7j9duWvIJ7AShyBRoNKJGhu9Q27qIbchfzli66H9RvrQNIFk5ER7z1Twe059WZGqERcA==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@protobuf-ts/runtime": "^2.9.4"
+ }
+ },
"node_modules/@rollup/pluginutils": {
"version": "5.1.0",
"resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.1.0.tgz",
@@ -2800,9 +2835,10 @@
}
},
"node_modules/acorn": {
- "version": "8.11.3",
- "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.3.tgz",
- "integrity": "sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==",
+ "version": "8.14.0",
+ "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz",
+ "integrity": "sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==",
+ "license": "MIT",
"bin": {
"acorn": "bin/acorn"
},
@@ -3665,11 +3701,12 @@
}
},
"node_modules/debug": {
- "version": "4.3.4",
- "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
- "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==",
+ "version": "4.4.0",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
+ "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+ "license": "MIT",
"dependencies": {
- "ms": "2.1.2"
+ "ms": "^2.1.3"
},
"engines": {
"node": ">=6.0"
@@ -4922,6 +4959,12 @@
"csstype": "^3.0.10"
}
},
+ "node_modules/google-protobuf": {
+ "version": "3.21.4",
+ "resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.21.4.tgz",
+ "integrity": "sha512-MnG7N936zcKTco4Jd2PX2U96Kf9PxygAPKBug+74LHzmHXmceN16MmRcdgZv+DGef/S9YvQAfRsNCn4cjf9yyQ==",
+ "license": "(BSD-3-Clause AND Apache-2.0)"
+ },
"node_modules/gopd": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz",
@@ -5738,9 +5781,10 @@
}
},
"node_modules/ms": {
- "version": "2.1.2",
- "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
- "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
+ "version": "2.1.3",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+ "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+ "license": "MIT"
},
"node_modules/mz": {
"version": "2.7.0",
@@ -7006,14 +7050,6 @@
"node": ">=0.8"
}
},
- "node_modules/to-fast-properties": {
- "version": "2.0.0",
- "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz",
- "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==",
- "engines": {
- "node": ">=4"
- }
- },
"node_modules/to-regex-range": {
"version": "5.0.1",
"resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
diff --git a/frontend/package.json b/frontend/package.json
index d17a380..5ef311d 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -22,10 +22,13 @@
"@massalabs/prettier-config-as": "^0.0.2",
"@massalabs/react-ui-kit": "^0.0.5-dev",
"@massalabs/wallet-provider": "^2.0.1-dev",
+ "@protobuf-ts/grpcweb-transport": "^2.9.4",
+ "@protobuf-ts/runtime-rpc": "^2.9.4",
"axios": "^1.7.2",
"dot-object": "^2.1.5",
"eslint-plugin-html": "^8.1.1",
"eslint-plugin-import": "^2.29.1",
+ "google-protobuf": "^3.21.4",
"husky": "^9.0.11",
"lodash": "^4.17.21",
"react": "^18.2.0",
diff --git a/frontend/src/components/MNSManagement.tsx b/frontend/src/components/MNSManagement.tsx
index 9cae970..34c4e1d 100644
--- a/frontend/src/components/MNSManagement.tsx
+++ b/frontend/src/components/MNSManagement.tsx
@@ -13,7 +13,7 @@ export function MNSManagement(props: MNSManagementProps) {
const { massaClient, connectedAccount, currentProvider, chainId } =
useAccountStore();
const {
- list,
+ domainsList,
listSpinning,
getUserEntryList,
dnsAlloc,
@@ -28,7 +28,7 @@ export function MNSManagement(props: MNSManagementProps) {
useEffect(() => {
if (!connectedAccount || !massaClient || listSpinning || !chainId) return;
getUserEntryList({ address: connectedAccount.address() });
- }, [connectedAccount, massaClient, chainId]);
+ }, [connectedAccount, massaClient, chainId, listSpinning, getUserEntryList]);
return (
{!connected ? (
@@ -44,7 +44,7 @@ export function MNSManagement(props: MNSManagementProps) {
deleteDnsEntry={deleteDnsEntry}
changeTargetAddressDnsEntry={changeTargetAddressDnsEntry}
changeOwnershipDnsEntry={changeOwnershipDnsEntry}
- list={list}
+ list={domainsList}
listSpinning={listSpinning}
/>
diff --git a/frontend/src/proto-gen/google/api/http.ts b/frontend/src/proto-gen/google/api/http.ts
new file mode 100644
index 0000000..9e6b5a8
--- /dev/null
+++ b/frontend/src/proto-gen/google/api/http.ts
@@ -0,0 +1,852 @@
+// @generated by protobuf-ts 2.9.1 with parameter generate_dependencies
+// @generated from protobuf file "google/api/http.proto" (package "google.api", syntax proto3)
+// tslint:disable
+//
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
+import type { IBinaryWriter } from '@protobuf-ts/runtime';
+import { WireType } from '@protobuf-ts/runtime';
+import type { BinaryReadOptions } from '@protobuf-ts/runtime';
+import type { IBinaryReader } from '@protobuf-ts/runtime';
+import { UnknownFieldHandler } from '@protobuf-ts/runtime';
+import type { PartialMessage } from '@protobuf-ts/runtime';
+import { reflectionMergePartial } from '@protobuf-ts/runtime';
+import { MESSAGE_TYPE } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+/**
+ * Defines the HTTP configuration for an API service. It contains a list of
+ * [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method
+ * to one or more HTTP REST API methods.
+ *
+ * @generated from protobuf message google.api.Http
+ */
+export interface Http {
+ /**
+ * A list of HTTP configuration rules that apply to individual API methods.
+ *
+ * **NOTE:** All service configuration rules follow "last one wins" order.
+ *
+ * @generated from protobuf field: repeated google.api.HttpRule rules = 1;
+ */
+ rules: HttpRule[];
+ /**
+ * When set to true, URL path parameters will be fully URI-decoded except in
+ * cases of single segment matches in reserved expansion, where "%2F" will be
+ * left encoded.
+ *
+ * The default behavior is to not decode RFC 6570 reserved characters in multi
+ * segment matches.
+ *
+ * @generated from protobuf field: bool fully_decode_reserved_expansion = 2;
+ */
+ fullyDecodeReservedExpansion: boolean;
+}
+/**
+ * # gRPC Transcoding
+ *
+ * gRPC Transcoding is a feature for mapping between a gRPC method and one or
+ * more HTTP REST endpoints. It allows developers to build a single API service
+ * that supports both gRPC APIs and REST APIs. Many systems, including [Google
+ * APIs](https://github.com/googleapis/googleapis),
+ * [Cloud Endpoints](https://cloud.google.com/endpoints), [gRPC
+ * Gateway](https://github.com/grpc-ecosystem/grpc-gateway),
+ * and [Envoy](https://github.com/envoyproxy/envoy) proxy support this feature
+ * and use it for large scale production services.
+ *
+ * `HttpRule` defines the schema of the gRPC/REST mapping. The mapping specifies
+ * how different portions of the gRPC request message are mapped to the URL
+ * path, URL query parameters, and HTTP request body. It also controls how the
+ * gRPC response message is mapped to the HTTP response body. `HttpRule` is
+ * typically specified as an `google.api.http` annotation on the gRPC method.
+ *
+ * Each mapping specifies a URL path template and an HTTP method. The path
+ * template may refer to one or more fields in the gRPC request message, as long
+ * as each field is a non-repeated field with a primitive (non-message) type.
+ * The path template controls how fields of the request message are mapped to
+ * the URL path.
+ *
+ * Example:
+ *
+ * service Messaging {
+ * rpc GetMessage(GetMessageRequest) returns (Message) {
+ * option (google.api.http) = {
+ * get: "/v1/{name=messages/*}"
+ * };
+ * }
+ * }
+ * message GetMessageRequest {
+ * string name = 1; // Mapped to URL path.
+ * }
+ * message Message {
+ * string text = 1; // The resource content.
+ * }
+ *
+ * This enables an HTTP REST to gRPC mapping as below:
+ *
+ * HTTP | gRPC
+ * -----|-----
+ * `GET /v1/messages/123456` | `GetMessage(name: "messages/123456")`
+ *
+ * Any fields in the request message which are not bound by the path template
+ * automatically become HTTP query parameters if there is no HTTP request body.
+ * For example:
+ *
+ * service Messaging {
+ * rpc GetMessage(GetMessageRequest) returns (Message) {
+ * option (google.api.http) = {
+ * get:"/v1/messages/{message_id}"
+ * };
+ * }
+ * }
+ * message GetMessageRequest {
+ * message SubMessage {
+ * string subfield = 1;
+ * }
+ * string message_id = 1; // Mapped to URL path.
+ * int64 revision = 2; // Mapped to URL query parameter `revision`.
+ * SubMessage sub = 3; // Mapped to URL query parameter `sub.subfield`.
+ * }
+ *
+ * This enables a HTTP JSON to RPC mapping as below:
+ *
+ * HTTP | gRPC
+ * -----|-----
+ * `GET /v1/messages/123456?revision=2&sub.subfield=foo` |
+ * `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield:
+ * "foo"))`
+ *
+ * Note that fields which are mapped to URL query parameters must have a
+ * primitive type or a repeated primitive type or a non-repeated message type.
+ * In the case of a repeated type, the parameter can be repeated in the URL
+ * as `...?param=A¶m=B`. In the case of a message type, each field of the
+ * message is mapped to a separate parameter, such as
+ * `...?foo.a=A&foo.b=B&foo.c=C`.
+ *
+ * For HTTP methods that allow a request body, the `body` field
+ * specifies the mapping. Consider a REST update method on the
+ * message resource collection:
+ *
+ * service Messaging {
+ * rpc UpdateMessage(UpdateMessageRequest) returns (Message) {
+ * option (google.api.http) = {
+ * patch: "/v1/messages/{message_id}"
+ * body: "message"
+ * };
+ * }
+ * }
+ * message UpdateMessageRequest {
+ * string message_id = 1; // mapped to the URL
+ * Message message = 2; // mapped to the body
+ * }
+ *
+ * The following HTTP JSON to RPC mapping is enabled, where the
+ * representation of the JSON in the request body is determined by
+ * protos JSON encoding:
+ *
+ * HTTP | gRPC
+ * -----|-----
+ * `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id:
+ * "123456" message { text: "Hi!" })`
+ *
+ * The special name `*` can be used in the body mapping to define that
+ * every field not bound by the path template should be mapped to the
+ * request body. This enables the following alternative definition of
+ * the update method:
+ *
+ * service Messaging {
+ * rpc UpdateMessage(Message) returns (Message) {
+ * option (google.api.http) = {
+ * patch: "/v1/messages/{message_id}"
+ * body: "*"
+ * };
+ * }
+ * }
+ * message Message {
+ * string message_id = 1;
+ * string text = 2;
+ * }
+ *
+ *
+ * The following HTTP JSON to RPC mapping is enabled:
+ *
+ * HTTP | gRPC
+ * -----|-----
+ * `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id:
+ * "123456" text: "Hi!")`
+ *
+ * Note that when using `*` in the body mapping, it is not possible to
+ * have HTTP parameters, as all fields not bound by the path end in
+ * the body. This makes this option more rarely used in practice when
+ * defining REST APIs. The commons 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 commons use case "{var}" does not capture the leading "/"
+ * character. For consistency, all path variables must share the same behavior.
+ *
+ * Repeated message fields must not be mapped to URL query parameters, because
+ * no client library can support such complicated mapping.
+ *
+ * If an API needs to use a JSON array for request or response body, it can map
+ * the request or response body to a repeated field. However, some gRPC
+ * Transcoding implementations may not support this feature.
+ *
+ * @generated from protobuf message google.api.HttpRule
+ */
+export interface HttpRule {
+ /**
+ * Selects a method to which this rule applies.
+ *
+ * Refer to [selector][google.api.DocumentationRule.selector] for syntax
+ * details.
+ *
+ * @generated from protobuf field: string selector = 1;
+ */
+ selector: string;
+ /**
+ * @generated from protobuf oneof: pattern
+ */
+ pattern:
+ | {
+ oneofKind: 'get';
+ /**
+ * Maps to HTTP GET. Used for listing and getting information about
+ * resources.
+ *
+ * @generated from protobuf field: string get = 2;
+ */
+ get: string;
+ }
+ | {
+ oneofKind: 'put';
+ /**
+ * Maps to HTTP PUT. Used for replacing a resource.
+ *
+ * @generated from protobuf field: string put = 3;
+ */
+ put: string;
+ }
+ | {
+ oneofKind: 'post';
+ /**
+ * Maps to HTTP POST. Used for creating a resource or performing an action.
+ *
+ * @generated from protobuf field: string post = 4;
+ */
+ post: string;
+ }
+ | {
+ oneofKind: 'delete';
+ /**
+ * Maps to HTTP DELETE. Used for deleting a resource.
+ *
+ * @generated from protobuf field: string delete = 5;
+ */
+ delete: string;
+ }
+ | {
+ oneofKind: 'patch';
+ /**
+ * Maps to HTTP PATCH. Used for updating a resource.
+ *
+ * @generated from protobuf field: string patch = 6;
+ */
+ patch: string;
+ }
+ | {
+ oneofKind: 'custom';
+ /**
+ * The custom pattern is used for specifying an HTTP method that is not
+ * included in the `pattern` field, such as HEAD, or "*" to leave the
+ * HTTP method unspecified for this rule. The wild-card rule is useful
+ * for services that provide content to Web (HTML) clients.
+ *
+ * @generated from protobuf field: google.api.CustomHttpPattern custom = 8;
+ */
+ custom: CustomHttpPattern;
+ }
+ | {
+ oneofKind: undefined;
+ };
+ /**
+ * The name of the request field whose value is mapped to the HTTP request
+ * body, or `*` for mapping all request fields not captured by the path
+ * pattern to the HTTP body, or omitted for not having any HTTP request body.
+ *
+ * NOTE: the referred field must be present at the top-level of the request
+ * message type.
+ *
+ * @generated from protobuf field: string body = 7;
+ */
+ body: string;
+ /**
+ * Optional. The name of the response field whose value is mapped to the HTTP
+ * response body. When omitted, the entire response message will be used
+ * as the HTTP response body.
+ *
+ * NOTE: The referred field must be present at the top-level of the response
+ * message type.
+ *
+ * @generated from protobuf field: string response_body = 12;
+ */
+ responseBody: string;
+ /**
+ * Additional HTTP bindings for the selector. Nested bindings must
+ * not contain an `additional_bindings` field themselves (that is,
+ * the nesting may only be one level deep).
+ *
+ * @generated from protobuf field: repeated google.api.HttpRule additional_bindings = 11;
+ */
+ additionalBindings: HttpRule[];
+}
+/**
+ * A custom pattern is used for defining custom HTTP verb.
+ *
+ * @generated from protobuf message google.api.CustomHttpPattern
+ */
+export interface CustomHttpPattern {
+ /**
+ * The name of this custom HTTP verb.
+ *
+ * @generated from protobuf field: string kind = 1;
+ */
+ kind: string;
+ /**
+ * The path matched by this custom verb.
+ *
+ * @generated from protobuf field: string path = 2;
+ */
+ path: string;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class Http$Type extends MessageType {
+ constructor() {
+ super('google.api.Http', [
+ {
+ no: 1,
+ name: 'rules',
+ kind: 'message',
+ repeat: 1 /* RepeatType.PACKED*/,
+ T: () => HttpRule,
+ },
+ {
+ no: 2,
+ name: 'fully_decode_reserved_expansion',
+ kind: 'scalar',
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): Http {
+ const message = { rules: [], fullyDecodeReservedExpansion: false };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined) reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: Http,
+ ): Http {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* repeated google.api.HttpRule rules */ 1:
+ message.rules.push(
+ HttpRule.internalBinaryRead(reader, reader.uint32(), options),
+ );
+ break;
+ case /* bool fully_decode_reserved_expansion */ 2:
+ message.fullyDecodeReservedExpansion = reader.bool();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: Http,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* repeated google.api.HttpRule rules = 1; */
+ for (let i = 0; i < message.rules.length; i++)
+ HttpRule.internalBinaryWrite(
+ message.rules[i],
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* bool fully_decode_reserved_expansion = 2; */
+ if (message.fullyDecodeReservedExpansion !== false)
+ writer.tag(2, WireType.Varint).bool(message.fullyDecodeReservedExpansion);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.api.Http
+ */
+export const Http = new Http$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class HttpRule$Type extends MessageType {
+ constructor() {
+ super('google.api.HttpRule', [
+ { no: 1, name: 'selector', kind: 'scalar', T: 9 /* ScalarType.STRING*/ },
+ {
+ no: 2,
+ name: 'get',
+ kind: 'scalar',
+ oneof: 'pattern',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 3,
+ name: 'put',
+ kind: 'scalar',
+ oneof: 'pattern',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 4,
+ name: 'post',
+ kind: 'scalar',
+ oneof: 'pattern',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 5,
+ name: 'delete',
+ kind: 'scalar',
+ oneof: 'pattern',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 6,
+ name: 'patch',
+ kind: 'scalar',
+ oneof: 'pattern',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 8,
+ name: 'custom',
+ kind: 'message',
+ oneof: 'pattern',
+ T: () => CustomHttpPattern,
+ },
+ { no: 7, name: 'body', kind: 'scalar', T: 9 /* ScalarType.STRING*/ },
+ {
+ no: 12,
+ name: 'response_body',
+ kind: 'scalar',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 11,
+ name: 'additional_bindings',
+ kind: 'message',
+ repeat: 1 /* RepeatType.PACKED*/,
+ T: () => HttpRule,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): HttpRule {
+ const message = {
+ selector: '',
+ pattern: { oneofKind: undefined },
+ body: '',
+ responseBody: '',
+ additionalBindings: [],
+ };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: HttpRule,
+ ): HttpRule {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* string selector */ 1:
+ message.selector = reader.string();
+ break;
+ case /* string get */ 2:
+ message.pattern = {
+ oneofKind: 'get',
+ get: reader.string(),
+ };
+ break;
+ case /* string put */ 3:
+ message.pattern = {
+ oneofKind: 'put',
+ put: reader.string(),
+ };
+ break;
+ case /* string post */ 4:
+ message.pattern = {
+ oneofKind: 'post',
+ post: reader.string(),
+ };
+ break;
+ case /* string delete */ 5:
+ message.pattern = {
+ oneofKind: 'delete',
+ delete: reader.string(),
+ };
+ break;
+ case /* string patch */ 6:
+ message.pattern = {
+ oneofKind: 'patch',
+ patch: reader.string(),
+ };
+ break;
+ case /* google.api.CustomHttpPattern custom */ 8:
+ message.pattern = {
+ oneofKind: 'custom',
+ custom: CustomHttpPattern.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.pattern as any).custom,
+ ),
+ };
+ break;
+ case /* string body */ 7:
+ message.body = reader.string();
+ break;
+ case /* string response_body */ 12:
+ message.responseBody = reader.string();
+ break;
+ case /* repeated google.api.HttpRule additional_bindings */ 11:
+ message.additionalBindings.push(
+ HttpRule.internalBinaryRead(reader, reader.uint32(), options),
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: HttpRule,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* string selector = 1; */
+ if (message.selector !== '')
+ writer.tag(1, WireType.LengthDelimited).string(message.selector);
+ /* string get = 2; */
+ if (message.pattern.oneofKind === 'get')
+ writer.tag(2, WireType.LengthDelimited).string(message.pattern.get);
+ /* string put = 3; */
+ if (message.pattern.oneofKind === 'put')
+ writer.tag(3, WireType.LengthDelimited).string(message.pattern.put);
+ /* string post = 4; */
+ if (message.pattern.oneofKind === 'post')
+ writer.tag(4, WireType.LengthDelimited).string(message.pattern.post);
+ /* string delete = 5; */
+ if (message.pattern.oneofKind === 'delete')
+ writer.tag(5, WireType.LengthDelimited).string(message.pattern.delete);
+ /* string patch = 6; */
+ if (message.pattern.oneofKind === 'patch')
+ writer.tag(6, WireType.LengthDelimited).string(message.pattern.patch);
+ /* google.api.CustomHttpPattern custom = 8; */
+ if (message.pattern.oneofKind === 'custom')
+ CustomHttpPattern.internalBinaryWrite(
+ message.pattern.custom,
+ writer.tag(8, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* string body = 7; */
+ if (message.body !== '')
+ writer.tag(7, WireType.LengthDelimited).string(message.body);
+ /* string response_body = 12; */
+ if (message.responseBody !== '')
+ writer.tag(12, WireType.LengthDelimited).string(message.responseBody);
+ /* repeated google.api.HttpRule additional_bindings = 11; */
+ for (let i = 0; i < message.additionalBindings.length; i++)
+ HttpRule.internalBinaryWrite(
+ message.additionalBindings[i],
+ writer.tag(11, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.api.HttpRule
+ */
+export const HttpRule = new HttpRule$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CustomHttpPattern$Type extends MessageType {
+ constructor() {
+ super('google.api.CustomHttpPattern', [
+ { no: 1, name: 'kind', kind: 'scalar', T: 9 /* ScalarType.STRING*/ },
+ { no: 2, name: 'path', kind: 'scalar', T: 9 /* ScalarType.STRING*/ },
+ ]);
+ }
+ create(value?: PartialMessage): CustomHttpPattern {
+ const message = { kind: '', path: '' };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CustomHttpPattern,
+ ): CustomHttpPattern {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* string kind */ 1:
+ message.kind = reader.string();
+ break;
+ case /* string path */ 2:
+ message.path = reader.string();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CustomHttpPattern,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* string kind = 1; */
+ if (message.kind !== '')
+ writer.tag(1, WireType.LengthDelimited).string(message.kind);
+ /* string path = 2; */
+ if (message.path !== '')
+ writer.tag(2, WireType.LengthDelimited).string(message.path);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.api.CustomHttpPattern
+ */
+export const CustomHttpPattern = new CustomHttpPattern$Type();
diff --git a/frontend/src/proto-gen/google/protobuf/descriptor.ts b/frontend/src/proto-gen/google/protobuf/descriptor.ts
new file mode 100644
index 0000000..5a2d6be
--- /dev/null
+++ b/frontend/src/proto-gen/google/protobuf/descriptor.ts
@@ -0,0 +1,5526 @@
+// @generated by protobuf-ts 2.9.1 with parameter generate_dependencies
+// @generated from protobuf file "google/protobuf/descriptor.proto" (package "google.protobuf", syntax proto2)
+// tslint:disable
+//
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+//
+// Author: kenton@google.com (Kenton Varda)
+// Based on original Protocol Buffers design by
+// Sanjay Ghemawat, Jeff Dean, and others.
+//
+// The messages in this file describe the definitions found in .proto files.
+// A valid .proto file can be translated directly to a FileDescriptorProto
+// without any other information (e.g. without reading its imports).
+//
+import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
+import type { IBinaryWriter } from '@protobuf-ts/runtime';
+import { WireType } from '@protobuf-ts/runtime';
+import type { BinaryReadOptions } from '@protobuf-ts/runtime';
+import type { IBinaryReader } from '@protobuf-ts/runtime';
+import { UnknownFieldHandler } from '@protobuf-ts/runtime';
+import type { PartialMessage } from '@protobuf-ts/runtime';
+import { reflectionMergePartial } from '@protobuf-ts/runtime';
+import { MESSAGE_TYPE } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+/**
+ * The protocol compiler can output a FileDescriptorSet containing the .proto
+ * files it parses.
+ *
+ * @generated from protobuf message google.protobuf.FileDescriptorSet
+ */
+export interface FileDescriptorSet {
+ /**
+ * @generated from protobuf field: repeated google.protobuf.FileDescriptorProto file = 1;
+ */
+ file: FileDescriptorProto[];
+}
+/**
+ * Describes a complete .proto file.
+ *
+ * @generated from protobuf message google.protobuf.FileDescriptorProto
+ */
+export interface FileDescriptorProto {
+ /**
+ * @generated from protobuf field: optional string name = 1;
+ */
+ name?: string; // file name, relative to root of source tree
+ /**
+ * @generated from protobuf field: optional string package = 2;
+ */
+ package?: string; // e.g. "foo", "foo.bar", etc.
+ /**
+ * Names of files imported by this file.
+ *
+ * @generated from protobuf field: repeated string dependency = 3;
+ */
+ dependency: string[];
+ /**
+ * Indexes of the public imported files in the dependency list above.
+ *
+ * @generated from protobuf field: repeated int32 public_dependency = 10;
+ */
+ publicDependency: number[];
+ /**
+ * Indexes of the weak imported files in the dependency list.
+ * For Google-internal migration only. Do not use.
+ *
+ * @generated from protobuf field: repeated int32 weak_dependency = 11;
+ */
+ weakDependency: number[];
+ /**
+ * All top-level definitions in this file.
+ *
+ * @generated from protobuf field: repeated google.protobuf.DescriptorProto message_type = 4;
+ */
+ messageType: DescriptorProto[];
+ /**
+ * @generated from protobuf field: repeated google.protobuf.EnumDescriptorProto enum_type = 5;
+ */
+ enumType: EnumDescriptorProto[];
+ /**
+ * @generated from protobuf field: repeated google.protobuf.ServiceDescriptorProto service = 6;
+ */
+ service: ServiceDescriptorProto[];
+ /**
+ * @generated from protobuf field: repeated google.protobuf.FieldDescriptorProto extension = 7;
+ */
+ extension: FieldDescriptorProto[];
+ /**
+ * @generated from protobuf field: optional google.protobuf.FileOptions options = 8;
+ */
+ options?: FileOptions;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional google.protobuf.SourceCodeInfo source_code_info = 9;
+ */
+ sourceCodeInfo?: SourceCodeInfo;
+ /**
+ * The syntax of the proto file.
+ * The supported values are "proto2", "proto3", and "editions".
+ *
+ * If `edition` is present, this value must be "editions".
+ *
+ * @generated from protobuf field: optional string syntax = 12;
+ */
+ syntax?: string;
+ /**
+ * The edition of the proto file, which is an opaque string.
+ *
+ * @generated from protobuf field: optional string edition = 13;
+ */
+ edition?: string;
+}
+/**
+ * Describes a message type.
+ *
+ * @generated from protobuf message google.protobuf.DescriptorProto
+ */
+export interface DescriptorProto {
+ /**
+ * @generated from protobuf field: optional string name = 1;
+ */
+ name?: string;
+ /**
+ * @generated from protobuf field: repeated google.protobuf.FieldDescriptorProto field = 2;
+ */
+ field: FieldDescriptorProto[];
+ /**
+ * @generated from protobuf field: repeated google.protobuf.FieldDescriptorProto extension = 6;
+ */
+ extension: FieldDescriptorProto[];
+ /**
+ * @generated from protobuf field: repeated google.protobuf.DescriptorProto nested_type = 3;
+ */
+ nestedType: DescriptorProto[];
+ /**
+ * @generated from protobuf field: repeated google.protobuf.EnumDescriptorProto enum_type = 4;
+ */
+ enumType: EnumDescriptorProto[];
+ /**
+ * @generated from protobuf field: repeated google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
+ */
+ extensionRange: DescriptorProto_ExtensionRange[];
+ /**
+ * @generated from protobuf field: repeated google.protobuf.OneofDescriptorProto oneof_decl = 8;
+ */
+ oneofDecl: OneofDescriptorProto[];
+ /**
+ * @generated from protobuf field: optional google.protobuf.MessageOptions options = 7;
+ */
+ options?: MessageOptions;
+ /**
+ * @generated from protobuf field: repeated google.protobuf.DescriptorProto.ReservedRange reserved_range = 9;
+ */
+ reservedRange: DescriptorProto_ReservedRange[];
+ /**
+ * Reserved field names, which may not be used by fields in the same message.
+ * A given name may only be reserved once.
+ *
+ * @generated from protobuf field: repeated string reserved_name = 10;
+ */
+ reservedName: string[];
+}
+/**
+ * @generated from protobuf message google.protobuf.DescriptorProto.ExtensionRange
+ */
+export interface DescriptorProto_ExtensionRange {
+ /**
+ * @generated from protobuf field: optional int32 start = 1;
+ */
+ start?: number; // Inclusive.
+ /**
+ * @generated from protobuf field: optional int32 end = 2;
+ */
+ end?: number; // Exclusive.
+ /**
+ * @generated from protobuf field: optional google.protobuf.ExtensionRangeOptions options = 3;
+ */
+ options?: ExtensionRangeOptions;
+}
+/**
+ * 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.
+ *
+ * @generated from protobuf message google.protobuf.DescriptorProto.ReservedRange
+ */
+export interface DescriptorProto_ReservedRange {
+ /**
+ * @generated from protobuf field: optional int32 start = 1;
+ */
+ start?: number; // Inclusive.
+ /**
+ * @generated from protobuf field: optional int32 end = 2;
+ */
+ end?: number; // Exclusive.
+}
+/**
+ * @generated from protobuf message google.protobuf.ExtensionRangeOptions
+ */
+export interface ExtensionRangeOptions {
+ /**
+ * The parser stores options it doesn't recognize here. See above.
+ *
+ * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999;
+ */
+ uninterpretedOption: UninterpretedOption[];
+}
+/**
+ * Describes a field within a message.
+ *
+ * @generated from protobuf message google.protobuf.FieldDescriptorProto
+ */
+export interface FieldDescriptorProto {
+ /**
+ * @generated from protobuf field: optional string name = 1;
+ */
+ name?: string;
+ /**
+ * @generated from protobuf field: optional int32 number = 3;
+ */
+ number?: number;
+ /**
+ * @generated from protobuf field: optional google.protobuf.FieldDescriptorProto.Label label = 4;
+ */
+ label?: FieldDescriptorProto_Label;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional google.protobuf.FieldDescriptorProto.Type type = 5;
+ */
+ type?: FieldDescriptorProto_Type;
+ /**
+ * 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).
+ *
+ * @generated from protobuf field: optional string type_name = 6;
+ */
+ typeName?: string;
+ /**
+ * For extensions, this is the name of the type being extended. It is
+ * resolved in the same manner as type_name.
+ *
+ * @generated from protobuf field: optional string extendee = 2;
+ */
+ extendee?: string;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional string default_value = 7;
+ */
+ defaultValue?: string;
+ /**
+ * If set, gives the index of a oneof in the containing type's oneof_decl
+ * list. This field is a member of that oneof.
+ *
+ * @generated from protobuf field: optional int32 oneof_index = 9;
+ */
+ oneofIndex?: number;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional string json_name = 10;
+ */
+ jsonName?: string;
+ /**
+ * @generated from protobuf field: optional google.protobuf.FieldOptions options = 8;
+ */
+ options?: FieldOptions;
+ /**
+ * 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 be 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`.
+ *
+ * @generated from protobuf field: optional bool proto3_optional = 17;
+ */
+ proto3Optional?: boolean;
+}
+/**
+ * @generated from protobuf enum google.protobuf.FieldDescriptorProto.Type
+ */
+export enum FieldDescriptorProto_Type {
+ /**
+ * @generated synthetic value - protobuf-ts requires all enums to have a 0 value
+ */
+ UNSPECIFIED$ = 0,
+ /**
+ * 0 is reserved for errors.
+ * Order is weird for historical reasons.
+ *
+ * @generated from protobuf enum value: TYPE_DOUBLE = 1;
+ */
+ DOUBLE = 1,
+ /**
+ * @generated from protobuf enum value: TYPE_FLOAT = 2;
+ */
+ FLOAT = 2,
+ /**
+ * Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if
+ * negative values are likely.
+ *
+ * @generated from protobuf enum value: TYPE_INT64 = 3;
+ */
+ INT64 = 3,
+ /**
+ * @generated from protobuf enum value: TYPE_UINT64 = 4;
+ */
+ UINT64 = 4,
+ /**
+ * Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if
+ * negative values are likely.
+ *
+ * @generated from protobuf enum value: TYPE_INT32 = 5;
+ */
+ INT32 = 5,
+ /**
+ * @generated from protobuf enum value: TYPE_FIXED64 = 6;
+ */
+ FIXED64 = 6,
+ /**
+ * @generated from protobuf enum value: TYPE_FIXED32 = 7;
+ */
+ FIXED32 = 7,
+ /**
+ * @generated from protobuf enum value: TYPE_BOOL = 8;
+ */
+ BOOL = 8,
+ /**
+ * @generated from protobuf enum value: TYPE_STRING = 9;
+ */
+ STRING = 9,
+ /**
+ * Tag-delimited aggregate.
+ * Group type is deprecated and not supported in proto3. However, Proto3
+ * implementations should still be able to parse the group wire format and
+ * treat group fields as unknown fields.
+ *
+ * @generated from protobuf enum value: TYPE_GROUP = 10;
+ */
+ GROUP = 10,
+ /**
+ * Length-delimited aggregate.
+ *
+ * @generated from protobuf enum value: TYPE_MESSAGE = 11;
+ */
+ MESSAGE = 11,
+ /**
+ * New in version 2.
+ *
+ * @generated from protobuf enum value: TYPE_BYTES = 12;
+ */
+ BYTES = 12,
+ /**
+ * @generated from protobuf enum value: TYPE_UINT32 = 13;
+ */
+ UINT32 = 13,
+ /**
+ * @generated from protobuf enum value: TYPE_ENUM = 14;
+ */
+ ENUM = 14,
+ /**
+ * @generated from protobuf enum value: TYPE_SFIXED32 = 15;
+ */
+ SFIXED32 = 15,
+ /**
+ * @generated from protobuf enum value: TYPE_SFIXED64 = 16;
+ */
+ SFIXED64 = 16,
+ /**
+ * Uses ZigZag encoding.
+ *
+ * @generated from protobuf enum value: TYPE_SINT32 = 17;
+ */
+ SINT32 = 17,
+ /**
+ * Uses ZigZag encoding.
+ *
+ * @generated from protobuf enum value: TYPE_SINT64 = 18;
+ */
+ SINT64 = 18,
+}
+/**
+ * @generated from protobuf enum google.protobuf.FieldDescriptorProto.Label
+ */
+export enum FieldDescriptorProto_Label {
+ /**
+ * @generated synthetic value - protobuf-ts requires all enums to have a 0 value
+ */
+ UNSPECIFIED$ = 0,
+ /**
+ * 0 is reserved for errors
+ *
+ * @generated from protobuf enum value: LABEL_OPTIONAL = 1;
+ */
+ OPTIONAL = 1,
+ /**
+ * @generated from protobuf enum value: LABEL_REQUIRED = 2;
+ */
+ REQUIRED = 2,
+ /**
+ * @generated from protobuf enum value: LABEL_REPEATED = 3;
+ */
+ REPEATED = 3,
+}
+/**
+ * Describes a oneof.
+ *
+ * @generated from protobuf message google.protobuf.OneofDescriptorProto
+ */
+export interface OneofDescriptorProto {
+ /**
+ * @generated from protobuf field: optional string name = 1;
+ */
+ name?: string;
+ /**
+ * @generated from protobuf field: optional google.protobuf.OneofOptions options = 2;
+ */
+ options?: OneofOptions;
+}
+/**
+ * Describes an enum type.
+ *
+ * @generated from protobuf message google.protobuf.EnumDescriptorProto
+ */
+export interface EnumDescriptorProto {
+ /**
+ * @generated from protobuf field: optional string name = 1;
+ */
+ name?: string;
+ /**
+ * @generated from protobuf field: repeated google.protobuf.EnumValueDescriptorProto value = 2;
+ */
+ value: EnumValueDescriptorProto[];
+ /**
+ * @generated from protobuf field: optional google.protobuf.EnumOptions options = 3;
+ */
+ options?: EnumOptions;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: repeated google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4;
+ */
+ reservedRange: EnumDescriptorProto_EnumReservedRange[];
+ /**
+ * Reserved enum value names, which may not be reused. A given name may only
+ * be reserved once.
+ *
+ * @generated from protobuf field: repeated string reserved_name = 5;
+ */
+ reservedName: string[];
+}
+/**
+ * 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.
+ *
+ * @generated from protobuf message google.protobuf.EnumDescriptorProto.EnumReservedRange
+ */
+export interface EnumDescriptorProto_EnumReservedRange {
+ /**
+ * @generated from protobuf field: optional int32 start = 1;
+ */
+ start?: number; // Inclusive.
+ /**
+ * @generated from protobuf field: optional int32 end = 2;
+ */
+ end?: number; // Inclusive.
+}
+/**
+ * Describes a value within an enum.
+ *
+ * @generated from protobuf message google.protobuf.EnumValueDescriptorProto
+ */
+export interface EnumValueDescriptorProto {
+ /**
+ * @generated from protobuf field: optional string name = 1;
+ */
+ name?: string;
+ /**
+ * @generated from protobuf field: optional int32 number = 2;
+ */
+ number?: number;
+ /**
+ * @generated from protobuf field: optional google.protobuf.EnumValueOptions options = 3;
+ */
+ options?: EnumValueOptions;
+}
+/**
+ * Describes a service.
+ *
+ * @generated from protobuf message google.protobuf.ServiceDescriptorProto
+ */
+export interface ServiceDescriptorProto {
+ /**
+ * @generated from protobuf field: optional string name = 1;
+ */
+ name?: string;
+ /**
+ * @generated from protobuf field: repeated google.protobuf.MethodDescriptorProto method = 2;
+ */
+ method: MethodDescriptorProto[];
+ /**
+ * @generated from protobuf field: optional google.protobuf.ServiceOptions options = 3;
+ */
+ options?: ServiceOptions;
+}
+/**
+ * Describes a method of a service.
+ *
+ * @generated from protobuf message google.protobuf.MethodDescriptorProto
+ */
+export interface MethodDescriptorProto {
+ /**
+ * @generated from protobuf field: optional string name = 1;
+ */
+ name?: string;
+ /**
+ * Input and output type names. These are resolved in the same way as
+ * FieldDescriptorProto.type_name, but must refer to a message type.
+ *
+ * @generated from protobuf field: optional string input_type = 2;
+ */
+ inputType?: string;
+ /**
+ * @generated from protobuf field: optional string output_type = 3;
+ */
+ outputType?: string;
+ /**
+ * @generated from protobuf field: optional google.protobuf.MethodOptions options = 4;
+ */
+ options?: MethodOptions;
+ /**
+ * Identifies if client streams multiple client messages
+ *
+ * @generated from protobuf field: optional bool client_streaming = 5;
+ */
+ clientStreaming?: boolean;
+ /**
+ * Identifies if server streams multiple server messages
+ *
+ * @generated from protobuf field: optional bool server_streaming = 6;
+ */
+ serverStreaming?: boolean;
+}
+// ===================================================================
+// Options
+
+// Each of the definitions above may have "options" attached. These are
+// just annotations which may cause code to be generated slightly differently
+// or may contain hints for code that manipulates protocol messages.
+//
+// Clients may define custom options as extensions of the *Options messages.
+// These extensions may not yet be known at parsing time, so the parser cannot
+// store the values in them. Instead it stores them in a field in the *Options
+// message called uninterpreted_option. This field must have the same name
+// across all *Options messages. We then use this field to populate the
+// extensions when we build a descriptor, at which point all protos have been
+// parsed and so all extensions are known.
+//
+// Extension numbers for custom options may be chosen as follows:
+// * For options which will only be used within a single application or
+// organization, or for experimental options, use field numbers 50000
+// through 99999. It is up to you to ensure that you do not use the
+// same number for multiple options.
+// * For options which will be published and used publicly by multiple
+// independent entities, e-mail protobuf-global-extension-registry@google.com
+// to reserve extension numbers. Simply provide your project name (e.g.
+// Objective-C plugin) and your project website (if available) -- there's no
+// need to explain how you intend to use them. Usually you only need one
+// extension number. You can declare multiple options with only one extension
+// number by putting them in a sub-message. See the Custom Options section of
+// the docs for examples:
+// https://developers.google.com/protocol-buffers/docs/proto#options
+// If this turns out to be popular, a web service will be set up
+// to automatically assign option numbers.
+
+/**
+ * @generated from protobuf message google.protobuf.FileOptions
+ */
+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.
+ *
+ * @generated from protobuf field: optional string java_package = 1;
+ */
+ javaPackage?: string;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional string java_outer_classname = 8;
+ */
+ javaOuterClassname?: string;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional bool java_multiple_files = 10;
+ */
+ javaMultipleFiles?: boolean;
+ /**
+ * This option does nothing.
+ *
+ * @deprecated
+ * @generated from protobuf field: optional bool java_generate_equals_and_hash = 20 [deprecated = true];
+ */
+ javaGenerateEqualsAndHash?: boolean;
+ /**
+ * If set true, then the Java2 code generator will generate code that
+ * throws an exception whenever an attempt is made to assign a non-UTF-8
+ * byte sequence to a string field.
+ * Message reflection will do the same.
+ * However, an extension field still accepts non-UTF-8 byte sequences.
+ * This option has no effect on when used with the lite runtime.
+ *
+ * @generated from protobuf field: optional bool java_string_check_utf8 = 27;
+ */
+ javaStringCheckUtf8?: boolean;
+ /**
+ * @generated from protobuf field: optional google.protobuf.FileOptions.OptimizeMode optimize_for = 9;
+ */
+ optimizeFor?: FileOptions_OptimizeMode;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional string go_package = 11;
+ */
+ goPackage?: string;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional bool cc_generic_services = 16;
+ */
+ ccGenericServices?: boolean;
+ /**
+ * @generated from protobuf field: optional bool java_generic_services = 17;
+ */
+ javaGenericServices?: boolean;
+ /**
+ * @generated from protobuf field: optional bool py_generic_services = 18;
+ */
+ pyGenericServices?: boolean;
+ /**
+ * @generated from protobuf field: optional bool php_generic_services = 42;
+ */
+ phpGenericServices?: boolean;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional bool deprecated = 23;
+ */
+ deprecated?: boolean;
+ /**
+ * Enables the use of arenas for the proto messages in this file. This applies
+ * only to generated classes for C++.
+ *
+ * @generated from protobuf field: optional bool cc_enable_arenas = 31;
+ */
+ ccEnableArenas?: boolean;
+ /**
+ * Sets the objective c class prefix which is prepended to all objective c
+ * generated classes from this .proto. There is no default.
+ *
+ * @generated from protobuf field: optional string objc_class_prefix = 36;
+ */
+ objcClassPrefix?: string;
+ /**
+ * Namespace for generated classes; defaults to the package.
+ *
+ * @generated from protobuf field: optional string csharp_namespace = 37;
+ */
+ csharpNamespace?: string;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional string swift_prefix = 39;
+ */
+ swiftPrefix?: string;
+ /**
+ * Sets the php class prefix which is prepended to all php generated classes
+ * from this .proto. Default is empty.
+ *
+ * @generated from protobuf field: optional string php_class_prefix = 40;
+ */
+ phpClassPrefix?: string;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional string php_namespace = 41;
+ */
+ phpNamespace?: string;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional string php_metadata_namespace = 44;
+ */
+ phpMetadataNamespace?: string;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional string ruby_package = 45;
+ */
+ rubyPackage?: string;
+ /**
+ * The parser stores options it doesn't recognize here.
+ * See the documentation for the "Options" section above.
+ *
+ * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999;
+ */
+ uninterpretedOption: UninterpretedOption[];
+}
+/**
+ * Generated classes can be optimized for speed or code size.
+ *
+ * @generated from protobuf enum google.protobuf.FileOptions.OptimizeMode
+ */
+export enum FileOptions_OptimizeMode {
+ /**
+ * @generated synthetic value - protobuf-ts requires all enums to have a 0 value
+ */
+ UNSPECIFIED$ = 0,
+ /**
+ * Generate complete code for parsing, serialization,
+ *
+ * @generated from protobuf enum value: SPEED = 1;
+ */
+ SPEED = 1,
+ /**
+ * etc.
+ *
+ * Use ReflectionOps to implement these methods.
+ *
+ * @generated from protobuf enum value: CODE_SIZE = 2;
+ */
+ CODE_SIZE = 2,
+ /**
+ * Generate code using MessageLite and the lite runtime.
+ *
+ * @generated from protobuf enum value: LITE_RUNTIME = 3;
+ */
+ LITE_RUNTIME = 3,
+}
+/**
+ * @generated from protobuf message google.protobuf.MessageOptions
+ */
+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.
+ *
+ * @generated from protobuf field: optional bool message_set_wire_format = 1;
+ */
+ messageSetWireFormat?: boolean;
+ /**
+ * 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".
+ *
+ * @generated from protobuf field: optional bool no_standard_descriptor_accessor = 2;
+ */
+ noStandardDescriptorAccessor?: boolean;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional bool deprecated = 3;
+ */
+ deprecated?: boolean;
+ /**
+ * 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.
+ *
+ * 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.
+ *
+ * @generated from protobuf field: optional bool map_entry = 7;
+ */
+ mapEntry?: boolean;
+ /**
+ * 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(b/261750190) This is legacy behavior we plan to remove once downstream
+ * teams have had time to migrate.
+ *
+ * @deprecated
+ * @generated from protobuf field: optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true];
+ */
+ deprecatedLegacyJsonFieldConflicts?: boolean;
+ /**
+ * The parser stores options it doesn't recognize here. See above.
+ *
+ * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999;
+ */
+ uninterpretedOption: UninterpretedOption[];
+}
+/**
+ * @generated from protobuf message google.protobuf.FieldOptions
+ */
+export interface FieldOptions {
+ /**
+ * 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 not yet implemented in the open source
+ * release -- sorry, we'll try to include it in a future version!
+ *
+ * @generated from protobuf field: optional google.protobuf.FieldOptions.CType ctype = 1;
+ */
+ ctype?: FieldOptions_CType;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional bool packed = 2;
+ */
+ packed?: boolean;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional google.protobuf.FieldOptions.JSType jstype = 6;
+ */
+ jstype?: FieldOptions_JSType;
+ /**
+ * 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 implementations may choose not to check required fields within
+ * a lazy sub-message. That is, calling IsInitialized() on the outer message
+ * may return true even if the inner message has missing required fields.
+ * This is necessary because otherwise the inner message would have to be
+ * parsed in order to perform the check, defeating the purpose of lazy
+ * parsing. An implementation which chooses not to check required fields
+ * must be consistent about it. That is, for any particular sub-message, the
+ * implementation must either *always* check its required fields, or *never*
+ * check its required fields, regardless of whether or not the message has
+ * been parsed.
+ *
+ * As of May 2022, lazy verifies the contents of the byte stream during
+ * parsing. An invalid byte stream will cause the overall parsing to fail.
+ *
+ * @generated from protobuf field: optional bool lazy = 5;
+ */
+ lazy?: boolean;
+ /**
+ * unverified_lazy does no correctness checks on the byte stream. This should
+ * only be used where lazy with verification is prohibitive for performance
+ * reasons.
+ *
+ * @generated from protobuf field: optional bool unverified_lazy = 15;
+ */
+ unverifiedLazy?: boolean;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional bool deprecated = 3;
+ */
+ deprecated?: boolean;
+ /**
+ * For Google-internal migration only. Do not use.
+ *
+ * @generated from protobuf field: optional bool weak = 10;
+ */
+ weak?: boolean;
+ /**
+ * Indicate that the field value should not be printed out when using debug
+ * formats, e.g. when the field contains sensitive credentials.
+ *
+ * @generated from protobuf field: optional bool debug_redact = 16;
+ */
+ debugRedact?: boolean;
+ /**
+ * @generated from protobuf field: optional google.protobuf.FieldOptions.OptionRetention retention = 17;
+ */
+ retention?: FieldOptions_OptionRetention;
+ /**
+ * @generated from protobuf field: optional google.protobuf.FieldOptions.OptionTargetType target = 18;
+ */
+ target?: FieldOptions_OptionTargetType;
+ /**
+ * The parser stores options it doesn't recognize here. See above.
+ *
+ * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999;
+ */
+ uninterpretedOption: UninterpretedOption[];
+}
+/**
+ * @generated from protobuf enum google.protobuf.FieldOptions.CType
+ */
+export enum FieldOptions_CType {
+ /**
+ * Default mode.
+ *
+ * @generated from protobuf enum value: STRING = 0;
+ */
+ STRING = 0,
+ /**
+ * @generated from protobuf enum value: CORD = 1;
+ */
+ CORD = 1,
+ /**
+ * @generated from protobuf enum value: STRING_PIECE = 2;
+ */
+ STRING_PIECE = 2,
+}
+/**
+ * @generated from protobuf enum google.protobuf.FieldOptions.JSType
+ */
+export enum FieldOptions_JSType {
+ /**
+ * Use the default type.
+ *
+ * @generated from protobuf enum value: JS_NORMAL = 0;
+ */
+ JS_NORMAL = 0,
+ /**
+ * Use JavaScript strings.
+ *
+ * @generated from protobuf enum value: JS_STRING = 1;
+ */
+ JS_STRING = 1,
+ /**
+ * Use JavaScript numbers.
+ *
+ * @generated from protobuf enum value: JS_NUMBER = 2;
+ */
+ JS_NUMBER = 2,
+}
+/**
+ * If set to RETENTION_SOURCE, the option will be omitted from the binary.
+ * Note: as of January 2023, support for this is in progress and does not yet
+ * have an effect (b/264593489).
+ *
+ * @generated from protobuf enum google.protobuf.FieldOptions.OptionRetention
+ */
+export enum FieldOptions_OptionRetention {
+ /**
+ * @generated from protobuf enum value: RETENTION_UNKNOWN = 0;
+ */
+ RETENTION_UNKNOWN = 0,
+ /**
+ * @generated from protobuf enum value: RETENTION_RUNTIME = 1;
+ */
+ RETENTION_RUNTIME = 1,
+ /**
+ * @generated from protobuf enum value: RETENTION_SOURCE = 2;
+ */
+ RETENTION_SOURCE = 2,
+}
+/**
+ * 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. Note: as of January 2023, support for this is
+ * in progress and does not yet have an effect (b/264593489).
+ *
+ * @generated from protobuf enum google.protobuf.FieldOptions.OptionTargetType
+ */
+export enum FieldOptions_OptionTargetType {
+ /**
+ * @generated from protobuf enum value: TARGET_TYPE_UNKNOWN = 0;
+ */
+ TARGET_TYPE_UNKNOWN = 0,
+ /**
+ * @generated from protobuf enum value: TARGET_TYPE_FILE = 1;
+ */
+ TARGET_TYPE_FILE = 1,
+ /**
+ * @generated from protobuf enum value: TARGET_TYPE_EXTENSION_RANGE = 2;
+ */
+ TARGET_TYPE_EXTENSION_RANGE = 2,
+ /**
+ * @generated from protobuf enum value: TARGET_TYPE_MESSAGE = 3;
+ */
+ TARGET_TYPE_MESSAGE = 3,
+ /**
+ * @generated from protobuf enum value: TARGET_TYPE_FIELD = 4;
+ */
+ TARGET_TYPE_FIELD = 4,
+ /**
+ * @generated from protobuf enum value: TARGET_TYPE_ONEOF = 5;
+ */
+ TARGET_TYPE_ONEOF = 5,
+ /**
+ * @generated from protobuf enum value: TARGET_TYPE_ENUM = 6;
+ */
+ TARGET_TYPE_ENUM = 6,
+ /**
+ * @generated from protobuf enum value: TARGET_TYPE_ENUM_ENTRY = 7;
+ */
+ TARGET_TYPE_ENUM_ENTRY = 7,
+ /**
+ * @generated from protobuf enum value: TARGET_TYPE_SERVICE = 8;
+ */
+ TARGET_TYPE_SERVICE = 8,
+ /**
+ * @generated from protobuf enum value: TARGET_TYPE_METHOD = 9;
+ */
+ TARGET_TYPE_METHOD = 9,
+}
+/**
+ * @generated from protobuf message google.protobuf.OneofOptions
+ */
+export interface OneofOptions {
+ /**
+ * The parser stores options it doesn't recognize here. See above.
+ *
+ * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999;
+ */
+ uninterpretedOption: UninterpretedOption[];
+}
+/**
+ * @generated from protobuf message google.protobuf.EnumOptions
+ */
+export interface EnumOptions {
+ /**
+ * Set this option to true to allow mapping different tag names to the same
+ * value.
+ *
+ * @generated from protobuf field: optional bool allow_alias = 2;
+ */
+ allowAlias?: boolean;
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional bool deprecated = 3;
+ */
+ deprecated?: boolean;
+ /**
+ * 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(b/261750190) Remove this legacy behavior once downstream teams have
+ * had time to migrate.
+ *
+ * @deprecated
+ * @generated from protobuf field: optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true];
+ */
+ deprecatedLegacyJsonFieldConflicts?: boolean;
+ /**
+ * The parser stores options it doesn't recognize here. See above.
+ *
+ * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999;
+ */
+ uninterpretedOption: UninterpretedOption[];
+}
+/**
+ * @generated from protobuf message google.protobuf.EnumValueOptions
+ */
+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.
+ *
+ * @generated from protobuf field: optional bool deprecated = 1;
+ */
+ deprecated?: boolean;
+ /**
+ * The parser stores options it doesn't recognize here. See above.
+ *
+ * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999;
+ */
+ uninterpretedOption: UninterpretedOption[];
+}
+/**
+ * @generated from protobuf message google.protobuf.ServiceOptions
+ */
+export interface ServiceOptions {
+ // Note: Field numbers 1 through 32 are reserved for Google's internal RPC
+ // framework. We apologize for hoarding these numbers to ourselves, but
+ // we were already using them long before we decided to release Protocol
+ // Buffers.
+
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional bool deprecated = 33;
+ */
+ deprecated?: boolean;
+ /**
+ * The parser stores options it doesn't recognize here. See above.
+ *
+ * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999;
+ */
+ uninterpretedOption: UninterpretedOption[];
+}
+/**
+ * @generated from protobuf message google.protobuf.MethodOptions
+ */
+export interface MethodOptions {
+ // Note: Field numbers 1 through 32 are reserved for Google's internal RPC
+ // framework. We apologize for hoarding these numbers to ourselves, but
+ // we were already using them long before we decided to release Protocol
+ // Buffers.
+
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional bool deprecated = 33;
+ */
+ deprecated?: boolean;
+ /**
+ * @generated from protobuf field: optional google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34;
+ */
+ idempotencyLevel?: MethodOptions_IdempotencyLevel;
+ /**
+ * The parser stores options it doesn't recognize here. See above.
+ *
+ * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999;
+ */
+ uninterpretedOption: UninterpretedOption[];
+}
+/**
+ * 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.
+ *
+ * @generated from protobuf enum google.protobuf.MethodOptions.IdempotencyLevel
+ */
+export enum MethodOptions_IdempotencyLevel {
+ /**
+ * @generated from protobuf enum value: IDEMPOTENCY_UNKNOWN = 0;
+ */
+ IDEMPOTENCY_UNKNOWN = 0,
+ /**
+ * implies idempotent
+ *
+ * @generated from protobuf enum value: NO_SIDE_EFFECTS = 1;
+ */
+ NO_SIDE_EFFECTS = 1,
+ /**
+ * idempotent, but may have side effects
+ *
+ * @generated from protobuf enum value: IDEMPOTENT = 2;
+ */
+ IDEMPOTENT = 2,
+}
+/**
+ * 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.
+ *
+ * @generated from protobuf message google.protobuf.UninterpretedOption
+ */
+export interface UninterpretedOption {
+ /**
+ * @generated from protobuf field: repeated google.protobuf.UninterpretedOption.NamePart name = 2;
+ */
+ name: UninterpretedOption_NamePart[];
+ /**
+ * The value of the uninterpreted option, in whatever type the tokenizer
+ * identified it as during parsing. Exactly one of these should be set.
+ *
+ * @generated from protobuf field: optional string identifier_value = 3;
+ */
+ identifierValue?: string;
+ /**
+ * @generated from protobuf field: optional uint64 positive_int_value = 4;
+ */
+ positiveIntValue?: bigint;
+ /**
+ * @generated from protobuf field: optional int64 negative_int_value = 5;
+ */
+ negativeIntValue?: bigint;
+ /**
+ * @generated from protobuf field: optional double double_value = 6;
+ */
+ doubleValue?: number;
+ /**
+ * @generated from protobuf field: optional bytes string_value = 7;
+ */
+ stringValue?: Uint8Array;
+ /**
+ * @generated from protobuf field: optional string aggregate_value = 8;
+ */
+ aggregateValue?: string;
+}
+/**
+ * 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".
+ *
+ * @generated from protobuf message google.protobuf.UninterpretedOption.NamePart
+ */
+export interface UninterpretedOption_NamePart {
+ /**
+ * @generated from protobuf field: string name_part = 1;
+ */
+ namePart: string;
+ /**
+ * @generated from protobuf field: bool is_extension = 2;
+ */
+ isExtension: boolean;
+}
+// ===================================================================
+// Optional source code info
+
+/**
+ * Encapsulates information about the original source file from which a
+ * FileDescriptorProto was generated.
+ *
+ * @generated from protobuf message google.protobuf.SourceCodeInfo
+ */
+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.
+ *
+ * @generated from protobuf field: repeated google.protobuf.SourceCodeInfo.Location location = 1;
+ */
+ location: SourceCodeInfo_Location[];
+}
+/**
+ * @generated from protobuf message google.protobuf.SourceCodeInfo.Location
+ */
+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 occurs.
+ * 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).
+ *
+ * @generated from protobuf field: repeated int32 path = 1 [packed = true];
+ */
+ path: number[];
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: repeated int32 span = 2 [packed = true];
+ */
+ span: number[];
+ /**
+ * 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.
+ *
+ * @generated from protobuf field: optional string leading_comments = 3;
+ */
+ leadingComments?: string;
+ /**
+ * @generated from protobuf field: optional string trailing_comments = 4;
+ */
+ trailingComments?: string;
+ /**
+ * @generated from protobuf field: repeated string leading_detached_comments = 6;
+ */
+ leadingDetachedComments: string[];
+}
+/**
+ * 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.
+ *
+ * @generated from protobuf message google.protobuf.GeneratedCodeInfo
+ */
+export interface GeneratedCodeInfo {
+ /**
+ * An Annotation connects some span of text in generated code to an element
+ * of its generating .proto file.
+ *
+ * @generated from protobuf field: repeated google.protobuf.GeneratedCodeInfo.Annotation annotation = 1;
+ */
+ annotation: GeneratedCodeInfo_Annotation[];
+}
+/**
+ * @generated from protobuf message google.protobuf.GeneratedCodeInfo.Annotation
+ */
+export interface GeneratedCodeInfo_Annotation {
+ /**
+ * Identifies the element in the original source .proto file. This field
+ * is formatted the same as SourceCodeInfo.Location.path.
+ *
+ * @generated from protobuf field: repeated int32 path = 1 [packed = true];
+ */
+ path: number[];
+ /**
+ * Identifies the filesystem path to the original source .proto.
+ *
+ * @generated from protobuf field: optional string source_file = 2;
+ */
+ sourceFile?: string;
+ /**
+ * Identifies the starting offset in bytes in the generated code
+ * that relates to the identified object.
+ *
+ * @generated from protobuf field: optional int32 begin = 3;
+ */
+ begin?: number;
+ /**
+ * 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).
+ *
+ * @generated from protobuf field: optional int32 end = 4;
+ */
+ end?: number;
+ /**
+ * @generated from protobuf field: optional google.protobuf.GeneratedCodeInfo.Annotation.Semantic semantic = 5;
+ */
+ semantic?: GeneratedCodeInfo_Annotation_Semantic;
+}
+/**
+ * Represents the identified object's effect on the element in the original
+ * .proto file.
+ *
+ * @generated from protobuf enum google.protobuf.GeneratedCodeInfo.Annotation.Semantic
+ */
+export enum GeneratedCodeInfo_Annotation_Semantic {
+ /**
+ * There is no effect or the effect is indescribable.
+ *
+ * @generated from protobuf enum value: NONE = 0;
+ */
+ NONE = 0,
+ /**
+ * The element is set or otherwise mutated.
+ *
+ * @generated from protobuf enum value: SET = 1;
+ */
+ SET = 1,
+ /**
+ * An alias to the element is returned.
+ *
+ * @generated from protobuf enum value: ALIAS = 2;
+ */
+ ALIAS = 2,
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class FileDescriptorSet$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.FileDescriptorSet', [
+ {
+ no: 1,
+ name: 'file',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => FileDescriptorProto,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): FileDescriptorSet {
+ const message = { file: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: FileDescriptorSet,
+ ): FileDescriptorSet {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* repeated google.protobuf.FileDescriptorProto file */ 1:
+ message.file.push(
+ FileDescriptorProto.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: FileDescriptorSet,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* repeated google.protobuf.FileDescriptorProto file = 1; */
+ for (let i = 0; i < message.file.length; i++)
+ FileDescriptorProto.internalBinaryWrite(
+ message.file[i],
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.FileDescriptorSet
+ */
+export const FileDescriptorSet = new FileDescriptorSet$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class FileDescriptorProto$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.FileDescriptorProto', [
+ {
+ no: 1,
+ name: 'name',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 2,
+ name: 'package',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 3,
+ name: 'dependency',
+ kind: 'scalar',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 10,
+ name: 'public_dependency',
+ kind: 'scalar',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ {
+ no: 11,
+ name: 'weak_dependency',
+ kind: 'scalar',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ {
+ no: 4,
+ name: 'message_type',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => DescriptorProto,
+ },
+ {
+ no: 5,
+ name: 'enum_type',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => EnumDescriptorProto,
+ },
+ {
+ no: 6,
+ name: 'service',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => ServiceDescriptorProto,
+ },
+ {
+ no: 7,
+ name: 'extension',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => FieldDescriptorProto,
+ },
+ { no: 8, name: 'options', kind: 'message', T: () => FileOptions },
+ {
+ no: 9,
+ name: 'source_code_info',
+ kind: 'message',
+ T: () => SourceCodeInfo,
+ },
+ {
+ no: 12,
+ name: 'syntax',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 13,
+ name: 'edition',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): FileDescriptorProto {
+ const message = {
+ dependency: [],
+ publicDependency: [],
+ weakDependency: [],
+ messageType: [],
+ enumType: [],
+ service: [],
+ extension: [],
+ };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: FileDescriptorProto,
+ ): FileDescriptorProto {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional string name */ 1:
+ message.name = reader.string();
+ break;
+ case /* optional string package */ 2:
+ message.package = reader.string();
+ break;
+ case /* repeated string dependency */ 3:
+ message.dependency.push(reader.string());
+ break;
+ case /* repeated int32 public_dependency */ 10:
+ if (wireType === WireType.LengthDelimited)
+ for (let e = reader.int32() + reader.pos; reader.pos < e; )
+ message.publicDependency.push(reader.int32());
+ else message.publicDependency.push(reader.int32());
+ break;
+ case /* repeated int32 weak_dependency */ 11:
+ if (wireType === WireType.LengthDelimited)
+ for (let e = reader.int32() + reader.pos; reader.pos < e; )
+ message.weakDependency.push(reader.int32());
+ else message.weakDependency.push(reader.int32());
+ break;
+ case /* repeated google.protobuf.DescriptorProto message_type */ 4:
+ message.messageType.push(
+ DescriptorProto.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* repeated google.protobuf.EnumDescriptorProto enum_type */ 5:
+ message.enumType.push(
+ EnumDescriptorProto.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* repeated google.protobuf.ServiceDescriptorProto service */ 6:
+ message.service.push(
+ ServiceDescriptorProto.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* repeated google.protobuf.FieldDescriptorProto extension */ 7:
+ message.extension.push(
+ FieldDescriptorProto.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* optional google.protobuf.FileOptions options */ 8:
+ message.options = FileOptions.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.options,
+ );
+ break;
+ case /* optional google.protobuf.SourceCodeInfo source_code_info */ 9:
+ message.sourceCodeInfo = SourceCodeInfo.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.sourceCodeInfo,
+ );
+ break;
+ case /* optional string syntax */ 12:
+ message.syntax = reader.string();
+ break;
+ case /* optional string edition */ 13:
+ message.edition = reader.string();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: FileDescriptorProto,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional string name = 1; */
+ if (message.name !== undefined)
+ writer.tag(1, WireType.LengthDelimited).string(message.name);
+ /* optional string package = 2; */
+ if (message.package !== undefined)
+ writer.tag(2, WireType.LengthDelimited).string(message.package);
+ /* repeated string dependency = 3; */
+ for (let i = 0; i < message.dependency.length; i++)
+ writer.tag(3, WireType.LengthDelimited).string(message.dependency[i]);
+ /* repeated int32 public_dependency = 10; */
+ for (let i = 0; i < message.publicDependency.length; i++)
+ writer.tag(10, WireType.Varint).int32(message.publicDependency[i]);
+ /* repeated int32 weak_dependency = 11; */
+ for (let i = 0; i < message.weakDependency.length; i++)
+ writer.tag(11, WireType.Varint).int32(message.weakDependency[i]);
+ /* repeated google.protobuf.DescriptorProto message_type = 4; */
+ for (let i = 0; i < message.messageType.length; i++)
+ DescriptorProto.internalBinaryWrite(
+ message.messageType[i],
+ writer.tag(4, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* repeated google.protobuf.EnumDescriptorProto enum_type = 5; */
+ for (let i = 0; i < message.enumType.length; i++)
+ EnumDescriptorProto.internalBinaryWrite(
+ message.enumType[i],
+ writer.tag(5, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* repeated google.protobuf.ServiceDescriptorProto service = 6; */
+ for (let i = 0; i < message.service.length; i++)
+ ServiceDescriptorProto.internalBinaryWrite(
+ message.service[i],
+ writer.tag(6, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* repeated google.protobuf.FieldDescriptorProto extension = 7; */
+ for (let i = 0; i < message.extension.length; i++)
+ FieldDescriptorProto.internalBinaryWrite(
+ message.extension[i],
+ writer.tag(7, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* optional google.protobuf.FileOptions options = 8; */
+ if (message.options)
+ FileOptions.internalBinaryWrite(
+ message.options,
+ writer.tag(8, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* optional google.protobuf.SourceCodeInfo source_code_info = 9; */
+ if (message.sourceCodeInfo)
+ SourceCodeInfo.internalBinaryWrite(
+ message.sourceCodeInfo,
+ writer.tag(9, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* optional string syntax = 12; */
+ if (message.syntax !== undefined)
+ writer.tag(12, WireType.LengthDelimited).string(message.syntax);
+ /* optional string edition = 13; */
+ if (message.edition !== undefined)
+ writer.tag(13, WireType.LengthDelimited).string(message.edition);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.FileDescriptorProto
+ */
+export const FileDescriptorProto = new FileDescriptorProto$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DescriptorProto$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.DescriptorProto', [
+ {
+ no: 1,
+ name: 'name',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 2,
+ name: 'field',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => FieldDescriptorProto,
+ },
+ {
+ no: 6,
+ name: 'extension',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => FieldDescriptorProto,
+ },
+ {
+ no: 3,
+ name: 'nested_type',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => DescriptorProto,
+ },
+ {
+ no: 4,
+ name: 'enum_type',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => EnumDescriptorProto,
+ },
+ {
+ no: 5,
+ name: 'extension_range',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => DescriptorProto_ExtensionRange,
+ },
+ {
+ no: 8,
+ name: 'oneof_decl',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => OneofDescriptorProto,
+ },
+ { no: 7, name: 'options', kind: 'message', T: () => MessageOptions },
+ {
+ no: 9,
+ name: 'reserved_range',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => DescriptorProto_ReservedRange,
+ },
+ {
+ no: 10,
+ name: 'reserved_name',
+ kind: 'scalar',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): DescriptorProto {
+ const message = {
+ field: [],
+ extension: [],
+ nestedType: [],
+ enumType: [],
+ extensionRange: [],
+ oneofDecl: [],
+ reservedRange: [],
+ reservedName: [],
+ };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: DescriptorProto,
+ ): DescriptorProto {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional string name */ 1:
+ message.name = reader.string();
+ break;
+ case /* repeated google.protobuf.FieldDescriptorProto field */ 2:
+ message.field.push(
+ FieldDescriptorProto.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* repeated google.protobuf.FieldDescriptorProto extension */ 6:
+ message.extension.push(
+ FieldDescriptorProto.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* repeated google.protobuf.DescriptorProto nested_type */ 3:
+ message.nestedType.push(
+ DescriptorProto.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* repeated google.protobuf.EnumDescriptorProto enum_type */ 4:
+ message.enumType.push(
+ EnumDescriptorProto.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* repeated google.protobuf.DescriptorProto.ExtensionRange extension_range */ 5:
+ message.extensionRange.push(
+ DescriptorProto_ExtensionRange.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* repeated google.protobuf.OneofDescriptorProto oneof_decl */ 8:
+ message.oneofDecl.push(
+ OneofDescriptorProto.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* optional google.protobuf.MessageOptions options */ 7:
+ message.options = MessageOptions.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.options,
+ );
+ break;
+ case /* repeated google.protobuf.DescriptorProto.ReservedRange reserved_range */ 9:
+ message.reservedRange.push(
+ DescriptorProto_ReservedRange.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* repeated string reserved_name */ 10:
+ message.reservedName.push(reader.string());
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: DescriptorProto,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional string name = 1; */
+ if (message.name !== undefined)
+ writer.tag(1, WireType.LengthDelimited).string(message.name);
+ /* repeated google.protobuf.FieldDescriptorProto field = 2; */
+ for (let i = 0; i < message.field.length; i++)
+ FieldDescriptorProto.internalBinaryWrite(
+ message.field[i],
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* repeated google.protobuf.FieldDescriptorProto extension = 6; */
+ for (let i = 0; i < message.extension.length; i++)
+ FieldDescriptorProto.internalBinaryWrite(
+ message.extension[i],
+ writer.tag(6, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* repeated google.protobuf.DescriptorProto nested_type = 3; */
+ for (let i = 0; i < message.nestedType.length; i++)
+ DescriptorProto.internalBinaryWrite(
+ message.nestedType[i],
+ writer.tag(3, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* repeated google.protobuf.EnumDescriptorProto enum_type = 4; */
+ for (let i = 0; i < message.enumType.length; i++)
+ EnumDescriptorProto.internalBinaryWrite(
+ message.enumType[i],
+ writer.tag(4, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* repeated google.protobuf.DescriptorProto.ExtensionRange extension_range = 5; */
+ for (let i = 0; i < message.extensionRange.length; i++)
+ DescriptorProto_ExtensionRange.internalBinaryWrite(
+ message.extensionRange[i],
+ writer.tag(5, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* repeated google.protobuf.OneofDescriptorProto oneof_decl = 8; */
+ for (let i = 0; i < message.oneofDecl.length; i++)
+ OneofDescriptorProto.internalBinaryWrite(
+ message.oneofDecl[i],
+ writer.tag(8, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* optional google.protobuf.MessageOptions options = 7; */
+ if (message.options)
+ MessageOptions.internalBinaryWrite(
+ message.options,
+ writer.tag(7, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* repeated google.protobuf.DescriptorProto.ReservedRange reserved_range = 9; */
+ for (let i = 0; i < message.reservedRange.length; i++)
+ DescriptorProto_ReservedRange.internalBinaryWrite(
+ message.reservedRange[i],
+ writer.tag(9, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* repeated string reserved_name = 10; */
+ for (let i = 0; i < message.reservedName.length; i++)
+ writer.tag(10, WireType.LengthDelimited).string(message.reservedName[i]);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.DescriptorProto
+ */
+export const DescriptorProto = new DescriptorProto$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DescriptorProto_ExtensionRange$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.DescriptorProto.ExtensionRange', [
+ {
+ no: 1,
+ name: 'start',
+ kind: 'scalar',
+ opt: true,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ {
+ no: 2,
+ name: 'end',
+ kind: 'scalar',
+ opt: true,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ {
+ no: 3,
+ name: 'options',
+ kind: 'message',
+ T: () => ExtensionRangeOptions,
+ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): DescriptorProto_ExtensionRange {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(
+ this,
+ message,
+ value,
+ );
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: DescriptorProto_ExtensionRange,
+ ): DescriptorProto_ExtensionRange {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional int32 start */ 1:
+ message.start = reader.int32();
+ break;
+ case /* optional int32 end */ 2:
+ message.end = reader.int32();
+ break;
+ case /* optional google.protobuf.ExtensionRangeOptions options */ 3:
+ message.options = ExtensionRangeOptions.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.options,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: DescriptorProto_ExtensionRange,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional int32 start = 1; */
+ if (message.start !== undefined)
+ writer.tag(1, WireType.Varint).int32(message.start);
+ /* optional int32 end = 2; */
+ if (message.end !== undefined)
+ writer.tag(2, WireType.Varint).int32(message.end);
+ /* optional google.protobuf.ExtensionRangeOptions options = 3; */
+ if (message.options)
+ ExtensionRangeOptions.internalBinaryWrite(
+ message.options,
+ writer.tag(3, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.DescriptorProto.ExtensionRange
+ */
+export const DescriptorProto_ExtensionRange =
+ new DescriptorProto_ExtensionRange$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DescriptorProto_ReservedRange$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.DescriptorProto.ReservedRange', [
+ {
+ no: 1,
+ name: 'start',
+ kind: 'scalar',
+ opt: true,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ {
+ no: 2,
+ name: 'end',
+ kind: 'scalar',
+ opt: true,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): DescriptorProto_ReservedRange {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(
+ this,
+ message,
+ value,
+ );
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: DescriptorProto_ReservedRange,
+ ): DescriptorProto_ReservedRange {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional int32 start */ 1:
+ message.start = reader.int32();
+ break;
+ case /* optional int32 end */ 2:
+ message.end = reader.int32();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: DescriptorProto_ReservedRange,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional int32 start = 1; */
+ if (message.start !== undefined)
+ writer.tag(1, WireType.Varint).int32(message.start);
+ /* optional int32 end = 2; */
+ if (message.end !== undefined)
+ writer.tag(2, WireType.Varint).int32(message.end);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.DescriptorProto.ReservedRange
+ */
+export const DescriptorProto_ReservedRange =
+ new DescriptorProto_ReservedRange$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExtensionRangeOptions$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.ExtensionRangeOptions', [
+ {
+ no: 999,
+ name: 'uninterpreted_option',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => UninterpretedOption,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): ExtensionRangeOptions {
+ const message = { uninterpretedOption: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: ExtensionRangeOptions,
+ ): ExtensionRangeOptions {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999:
+ message.uninterpretedOption.push(
+ UninterpretedOption.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: ExtensionRangeOptions,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */
+ for (let i = 0; i < message.uninterpretedOption.length; i++)
+ UninterpretedOption.internalBinaryWrite(
+ message.uninterpretedOption[i],
+ writer.tag(999, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.ExtensionRangeOptions
+ */
+export const ExtensionRangeOptions = new ExtensionRangeOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class FieldDescriptorProto$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.FieldDescriptorProto', [
+ {
+ no: 1,
+ name: 'name',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 3,
+ name: 'number',
+ kind: 'scalar',
+ opt: true,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ {
+ no: 4,
+ name: 'label',
+ kind: 'enum',
+ opt: true,
+ T: () => [
+ 'google.protobuf.FieldDescriptorProto.Label',
+ FieldDescriptorProto_Label,
+ 'LABEL_',
+ ],
+ },
+ {
+ no: 5,
+ name: 'type',
+ kind: 'enum',
+ opt: true,
+ T: () => [
+ 'google.protobuf.FieldDescriptorProto.Type',
+ FieldDescriptorProto_Type,
+ 'TYPE_',
+ ],
+ },
+ {
+ no: 6,
+ name: 'type_name',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 2,
+ name: 'extendee',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 7,
+ name: 'default_value',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 9,
+ name: 'oneof_index',
+ kind: 'scalar',
+ opt: true,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ {
+ no: 10,
+ name: 'json_name',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ { no: 8, name: 'options', kind: 'message', T: () => FieldOptions },
+ {
+ no: 17,
+ name: 'proto3_optional',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): FieldDescriptorProto {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: FieldDescriptorProto,
+ ): FieldDescriptorProto {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional string name */ 1:
+ message.name = reader.string();
+ break;
+ case /* optional int32 number */ 3:
+ message.number = reader.int32();
+ break;
+ case /* optional google.protobuf.FieldDescriptorProto.Label label */ 4:
+ message.label = reader.int32();
+ break;
+ case /* optional google.protobuf.FieldDescriptorProto.Type type */ 5:
+ message.type = reader.int32();
+ break;
+ case /* optional string type_name */ 6:
+ message.typeName = reader.string();
+ break;
+ case /* optional string extendee */ 2:
+ message.extendee = reader.string();
+ break;
+ case /* optional string default_value */ 7:
+ message.defaultValue = reader.string();
+ break;
+ case /* optional int32 oneof_index */ 9:
+ message.oneofIndex = reader.int32();
+ break;
+ case /* optional string json_name */ 10:
+ message.jsonName = reader.string();
+ break;
+ case /* optional google.protobuf.FieldOptions options */ 8:
+ message.options = FieldOptions.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.options,
+ );
+ break;
+ case /* optional bool proto3_optional */ 17:
+ message.proto3Optional = reader.bool();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: FieldDescriptorProto,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional string name = 1; */
+ if (message.name !== undefined)
+ writer.tag(1, WireType.LengthDelimited).string(message.name);
+ /* optional int32 number = 3; */
+ if (message.number !== undefined)
+ writer.tag(3, WireType.Varint).int32(message.number);
+ /* optional google.protobuf.FieldDescriptorProto.Label label = 4; */
+ if (message.label !== undefined)
+ writer.tag(4, WireType.Varint).int32(message.label);
+ /* optional google.protobuf.FieldDescriptorProto.Type type = 5; */
+ if (message.type !== undefined)
+ writer.tag(5, WireType.Varint).int32(message.type);
+ /* optional string type_name = 6; */
+ if (message.typeName !== undefined)
+ writer.tag(6, WireType.LengthDelimited).string(message.typeName);
+ /* optional string extendee = 2; */
+ if (message.extendee !== undefined)
+ writer.tag(2, WireType.LengthDelimited).string(message.extendee);
+ /* optional string default_value = 7; */
+ if (message.defaultValue !== undefined)
+ writer.tag(7, WireType.LengthDelimited).string(message.defaultValue);
+ /* optional int32 oneof_index = 9; */
+ if (message.oneofIndex !== undefined)
+ writer.tag(9, WireType.Varint).int32(message.oneofIndex);
+ /* optional string json_name = 10; */
+ if (message.jsonName !== undefined)
+ writer.tag(10, WireType.LengthDelimited).string(message.jsonName);
+ /* optional google.protobuf.FieldOptions options = 8; */
+ if (message.options)
+ FieldOptions.internalBinaryWrite(
+ message.options,
+ writer.tag(8, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* optional bool proto3_optional = 17; */
+ if (message.proto3Optional !== undefined)
+ writer.tag(17, WireType.Varint).bool(message.proto3Optional);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.FieldDescriptorProto
+ */
+export const FieldDescriptorProto = new FieldDescriptorProto$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OneofDescriptorProto$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.OneofDescriptorProto', [
+ {
+ no: 1,
+ name: 'name',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ { no: 2, name: 'options', kind: 'message', T: () => OneofOptions },
+ ]);
+ }
+ create(value?: PartialMessage): OneofDescriptorProto {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: OneofDescriptorProto,
+ ): OneofDescriptorProto {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional string name */ 1:
+ message.name = reader.string();
+ break;
+ case /* optional google.protobuf.OneofOptions options */ 2:
+ message.options = OneofOptions.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.options,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: OneofDescriptorProto,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional string name = 1; */
+ if (message.name !== undefined)
+ writer.tag(1, WireType.LengthDelimited).string(message.name);
+ /* optional google.protobuf.OneofOptions options = 2; */
+ if (message.options)
+ OneofOptions.internalBinaryWrite(
+ message.options,
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.OneofDescriptorProto
+ */
+export const OneofDescriptorProto = new OneofDescriptorProto$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EnumDescriptorProto$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.EnumDescriptorProto', [
+ {
+ no: 1,
+ name: 'name',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 2,
+ name: 'value',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => EnumValueDescriptorProto,
+ },
+ { no: 3, name: 'options', kind: 'message', T: () => EnumOptions },
+ {
+ no: 4,
+ name: 'reserved_range',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => EnumDescriptorProto_EnumReservedRange,
+ },
+ {
+ no: 5,
+ name: 'reserved_name',
+ kind: 'scalar',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): EnumDescriptorProto {
+ const message = { value: [], reservedRange: [], reservedName: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: EnumDescriptorProto,
+ ): EnumDescriptorProto {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional string name */ 1:
+ message.name = reader.string();
+ break;
+ case /* repeated google.protobuf.EnumValueDescriptorProto value */ 2:
+ message.value.push(
+ EnumValueDescriptorProto.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* optional google.protobuf.EnumOptions options */ 3:
+ message.options = EnumOptions.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.options,
+ );
+ break;
+ case /* repeated google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range */ 4:
+ message.reservedRange.push(
+ EnumDescriptorProto_EnumReservedRange.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* repeated string reserved_name */ 5:
+ message.reservedName.push(reader.string());
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: EnumDescriptorProto,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional string name = 1; */
+ if (message.name !== undefined)
+ writer.tag(1, WireType.LengthDelimited).string(message.name);
+ /* repeated google.protobuf.EnumValueDescriptorProto value = 2; */
+ for (let i = 0; i < message.value.length; i++)
+ EnumValueDescriptorProto.internalBinaryWrite(
+ message.value[i],
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* optional google.protobuf.EnumOptions options = 3; */
+ if (message.options)
+ EnumOptions.internalBinaryWrite(
+ message.options,
+ writer.tag(3, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* repeated google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4; */
+ for (let i = 0; i < message.reservedRange.length; i++)
+ EnumDescriptorProto_EnumReservedRange.internalBinaryWrite(
+ message.reservedRange[i],
+ writer.tag(4, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* repeated string reserved_name = 5; */
+ for (let i = 0; i < message.reservedName.length; i++)
+ writer.tag(5, WireType.LengthDelimited).string(message.reservedName[i]);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.EnumDescriptorProto
+ */
+export const EnumDescriptorProto = new EnumDescriptorProto$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EnumDescriptorProto_EnumReservedRange$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.EnumDescriptorProto.EnumReservedRange', [
+ {
+ no: 1,
+ name: 'start',
+ kind: 'scalar',
+ opt: true,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ {
+ no: 2,
+ name: 'end',
+ kind: 'scalar',
+ opt: true,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): EnumDescriptorProto_EnumReservedRange {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(
+ this,
+ message,
+ value,
+ );
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: EnumDescriptorProto_EnumReservedRange,
+ ): EnumDescriptorProto_EnumReservedRange {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional int32 start */ 1:
+ message.start = reader.int32();
+ break;
+ case /* optional int32 end */ 2:
+ message.end = reader.int32();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: EnumDescriptorProto_EnumReservedRange,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional int32 start = 1; */
+ if (message.start !== undefined)
+ writer.tag(1, WireType.Varint).int32(message.start);
+ /* optional int32 end = 2; */
+ if (message.end !== undefined)
+ writer.tag(2, WireType.Varint).int32(message.end);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.EnumDescriptorProto.EnumReservedRange
+ */
+export const EnumDescriptorProto_EnumReservedRange =
+ new EnumDescriptorProto_EnumReservedRange$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EnumValueDescriptorProto$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.EnumValueDescriptorProto', [
+ {
+ no: 1,
+ name: 'name',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 2,
+ name: 'number',
+ kind: 'scalar',
+ opt: true,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ { no: 3, name: 'options', kind: 'message', T: () => EnumValueOptions },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): EnumValueDescriptorProto {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: EnumValueDescriptorProto,
+ ): EnumValueDescriptorProto {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional string name */ 1:
+ message.name = reader.string();
+ break;
+ case /* optional int32 number */ 2:
+ message.number = reader.int32();
+ break;
+ case /* optional google.protobuf.EnumValueOptions options */ 3:
+ message.options = EnumValueOptions.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.options,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: EnumValueDescriptorProto,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional string name = 1; */
+ if (message.name !== undefined)
+ writer.tag(1, WireType.LengthDelimited).string(message.name);
+ /* optional int32 number = 2; */
+ if (message.number !== undefined)
+ writer.tag(2, WireType.Varint).int32(message.number);
+ /* optional google.protobuf.EnumValueOptions options = 3; */
+ if (message.options)
+ EnumValueOptions.internalBinaryWrite(
+ message.options,
+ writer.tag(3, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.EnumValueDescriptorProto
+ */
+export const EnumValueDescriptorProto = new EnumValueDescriptorProto$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServiceDescriptorProto$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.ServiceDescriptorProto', [
+ {
+ no: 1,
+ name: 'name',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 2,
+ name: 'method',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => MethodDescriptorProto,
+ },
+ { no: 3, name: 'options', kind: 'message', T: () => ServiceOptions },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): ServiceDescriptorProto {
+ const message = { method: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: ServiceDescriptorProto,
+ ): ServiceDescriptorProto {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional string name */ 1:
+ message.name = reader.string();
+ break;
+ case /* repeated google.protobuf.MethodDescriptorProto method */ 2:
+ message.method.push(
+ MethodDescriptorProto.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* optional google.protobuf.ServiceOptions options */ 3:
+ message.options = ServiceOptions.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.options,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: ServiceDescriptorProto,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional string name = 1; */
+ if (message.name !== undefined)
+ writer.tag(1, WireType.LengthDelimited).string(message.name);
+ /* repeated google.protobuf.MethodDescriptorProto method = 2; */
+ for (let i = 0; i < message.method.length; i++)
+ MethodDescriptorProto.internalBinaryWrite(
+ message.method[i],
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* optional google.protobuf.ServiceOptions options = 3; */
+ if (message.options)
+ ServiceOptions.internalBinaryWrite(
+ message.options,
+ writer.tag(3, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.ServiceDescriptorProto
+ */
+export const ServiceDescriptorProto = new ServiceDescriptorProto$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MethodDescriptorProto$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.MethodDescriptorProto', [
+ {
+ no: 1,
+ name: 'name',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 2,
+ name: 'input_type',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 3,
+ name: 'output_type',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ { no: 4, name: 'options', kind: 'message', T: () => MethodOptions },
+ {
+ no: 5,
+ name: 'client_streaming',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 6,
+ name: 'server_streaming',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): MethodDescriptorProto {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: MethodDescriptorProto,
+ ): MethodDescriptorProto {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional string name */ 1:
+ message.name = reader.string();
+ break;
+ case /* optional string input_type */ 2:
+ message.inputType = reader.string();
+ break;
+ case /* optional string output_type */ 3:
+ message.outputType = reader.string();
+ break;
+ case /* optional google.protobuf.MethodOptions options */ 4:
+ message.options = MethodOptions.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.options,
+ );
+ break;
+ case /* optional bool client_streaming */ 5:
+ message.clientStreaming = reader.bool();
+ break;
+ case /* optional bool server_streaming */ 6:
+ message.serverStreaming = reader.bool();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: MethodDescriptorProto,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional string name = 1; */
+ if (message.name !== undefined)
+ writer.tag(1, WireType.LengthDelimited).string(message.name);
+ /* optional string input_type = 2; */
+ if (message.inputType !== undefined)
+ writer.tag(2, WireType.LengthDelimited).string(message.inputType);
+ /* optional string output_type = 3; */
+ if (message.outputType !== undefined)
+ writer.tag(3, WireType.LengthDelimited).string(message.outputType);
+ /* optional google.protobuf.MethodOptions options = 4; */
+ if (message.options)
+ MethodOptions.internalBinaryWrite(
+ message.options,
+ writer.tag(4, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* optional bool client_streaming = 5; */
+ if (message.clientStreaming !== undefined)
+ writer.tag(5, WireType.Varint).bool(message.clientStreaming);
+ /* optional bool server_streaming = 6; */
+ if (message.serverStreaming !== undefined)
+ writer.tag(6, WireType.Varint).bool(message.serverStreaming);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.MethodDescriptorProto
+ */
+export const MethodDescriptorProto = new MethodDescriptorProto$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class FileOptions$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.FileOptions', [
+ {
+ no: 1,
+ name: 'java_package',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 8,
+ name: 'java_outer_classname',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 10,
+ name: 'java_multiple_files',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 20,
+ name: 'java_generate_equals_and_hash',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 27,
+ name: 'java_string_check_utf8',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 9,
+ name: 'optimize_for',
+ kind: 'enum',
+ opt: true,
+ T: () => [
+ 'google.protobuf.FileOptions.OptimizeMode',
+ FileOptions_OptimizeMode,
+ ],
+ },
+ {
+ no: 11,
+ name: 'go_package',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 16,
+ name: 'cc_generic_services',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 17,
+ name: 'java_generic_services',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 18,
+ name: 'py_generic_services',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 42,
+ name: 'php_generic_services',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 23,
+ name: 'deprecated',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 31,
+ name: 'cc_enable_arenas',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 36,
+ name: 'objc_class_prefix',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 37,
+ name: 'csharp_namespace',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 39,
+ name: 'swift_prefix',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 40,
+ name: 'php_class_prefix',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 41,
+ name: 'php_namespace',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 44,
+ name: 'php_metadata_namespace',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 45,
+ name: 'ruby_package',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 999,
+ name: 'uninterpreted_option',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => UninterpretedOption,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): FileOptions {
+ const message = { uninterpretedOption: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: FileOptions,
+ ): FileOptions {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional string java_package */ 1:
+ message.javaPackage = reader.string();
+ break;
+ case /* optional string java_outer_classname */ 8:
+ message.javaOuterClassname = reader.string();
+ break;
+ case /* optional bool java_multiple_files */ 10:
+ message.javaMultipleFiles = reader.bool();
+ break;
+ case /* optional bool java_generate_equals_and_hash = 20 [deprecated = true];*/ 20:
+ message.javaGenerateEqualsAndHash = reader.bool();
+ break;
+ case /* optional bool java_string_check_utf8 */ 27:
+ message.javaStringCheckUtf8 = reader.bool();
+ break;
+ case /* optional google.protobuf.FileOptions.OptimizeMode optimize_for */ 9:
+ message.optimizeFor = reader.int32();
+ break;
+ case /* optional string go_package */ 11:
+ message.goPackage = reader.string();
+ break;
+ case /* optional bool cc_generic_services */ 16:
+ message.ccGenericServices = reader.bool();
+ break;
+ case /* optional bool java_generic_services */ 17:
+ message.javaGenericServices = reader.bool();
+ break;
+ case /* optional bool py_generic_services */ 18:
+ message.pyGenericServices = reader.bool();
+ break;
+ case /* optional bool php_generic_services */ 42:
+ message.phpGenericServices = reader.bool();
+ break;
+ case /* optional bool deprecated */ 23:
+ message.deprecated = reader.bool();
+ break;
+ case /* optional bool cc_enable_arenas */ 31:
+ message.ccEnableArenas = reader.bool();
+ break;
+ case /* optional string objc_class_prefix */ 36:
+ message.objcClassPrefix = reader.string();
+ break;
+ case /* optional string csharp_namespace */ 37:
+ message.csharpNamespace = reader.string();
+ break;
+ case /* optional string swift_prefix */ 39:
+ message.swiftPrefix = reader.string();
+ break;
+ case /* optional string php_class_prefix */ 40:
+ message.phpClassPrefix = reader.string();
+ break;
+ case /* optional string php_namespace */ 41:
+ message.phpNamespace = reader.string();
+ break;
+ case /* optional string php_metadata_namespace */ 44:
+ message.phpMetadataNamespace = reader.string();
+ break;
+ case /* optional string ruby_package */ 45:
+ message.rubyPackage = reader.string();
+ break;
+ case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999:
+ message.uninterpretedOption.push(
+ UninterpretedOption.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: FileOptions,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional string java_package = 1; */
+ if (message.javaPackage !== undefined)
+ writer.tag(1, WireType.LengthDelimited).string(message.javaPackage);
+ /* optional string java_outer_classname = 8; */
+ if (message.javaOuterClassname !== undefined)
+ writer
+ .tag(8, WireType.LengthDelimited)
+ .string(message.javaOuterClassname);
+ /* optional bool java_multiple_files = 10; */
+ if (message.javaMultipleFiles !== undefined)
+ writer.tag(10, WireType.Varint).bool(message.javaMultipleFiles);
+ /* optional bool java_generate_equals_and_hash = 20 [deprecated = true]; */
+ if (message.javaGenerateEqualsAndHash !== undefined)
+ writer.tag(20, WireType.Varint).bool(message.javaGenerateEqualsAndHash);
+ /* optional bool java_string_check_utf8 = 27; */
+ if (message.javaStringCheckUtf8 !== undefined)
+ writer.tag(27, WireType.Varint).bool(message.javaStringCheckUtf8);
+ /* optional google.protobuf.FileOptions.OptimizeMode optimize_for = 9; */
+ if (message.optimizeFor !== undefined)
+ writer.tag(9, WireType.Varint).int32(message.optimizeFor);
+ /* optional string go_package = 11; */
+ if (message.goPackage !== undefined)
+ writer.tag(11, WireType.LengthDelimited).string(message.goPackage);
+ /* optional bool cc_generic_services = 16; */
+ if (message.ccGenericServices !== undefined)
+ writer.tag(16, WireType.Varint).bool(message.ccGenericServices);
+ /* optional bool java_generic_services = 17; */
+ if (message.javaGenericServices !== undefined)
+ writer.tag(17, WireType.Varint).bool(message.javaGenericServices);
+ /* optional bool py_generic_services = 18; */
+ if (message.pyGenericServices !== undefined)
+ writer.tag(18, WireType.Varint).bool(message.pyGenericServices);
+ /* optional bool php_generic_services = 42; */
+ if (message.phpGenericServices !== undefined)
+ writer.tag(42, WireType.Varint).bool(message.phpGenericServices);
+ /* optional bool deprecated = 23; */
+ if (message.deprecated !== undefined)
+ writer.tag(23, WireType.Varint).bool(message.deprecated);
+ /* optional bool cc_enable_arenas = 31; */
+ if (message.ccEnableArenas !== undefined)
+ writer.tag(31, WireType.Varint).bool(message.ccEnableArenas);
+ /* optional string objc_class_prefix = 36; */
+ if (message.objcClassPrefix !== undefined)
+ writer.tag(36, WireType.LengthDelimited).string(message.objcClassPrefix);
+ /* optional string csharp_namespace = 37; */
+ if (message.csharpNamespace !== undefined)
+ writer.tag(37, WireType.LengthDelimited).string(message.csharpNamespace);
+ /* optional string swift_prefix = 39; */
+ if (message.swiftPrefix !== undefined)
+ writer.tag(39, WireType.LengthDelimited).string(message.swiftPrefix);
+ /* optional string php_class_prefix = 40; */
+ if (message.phpClassPrefix !== undefined)
+ writer.tag(40, WireType.LengthDelimited).string(message.phpClassPrefix);
+ /* optional string php_namespace = 41; */
+ if (message.phpNamespace !== undefined)
+ writer.tag(41, WireType.LengthDelimited).string(message.phpNamespace);
+ /* optional string php_metadata_namespace = 44; */
+ if (message.phpMetadataNamespace !== undefined)
+ writer
+ .tag(44, WireType.LengthDelimited)
+ .string(message.phpMetadataNamespace);
+ /* optional string ruby_package = 45; */
+ if (message.rubyPackage !== undefined)
+ writer.tag(45, WireType.LengthDelimited).string(message.rubyPackage);
+ /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */
+ for (let i = 0; i < message.uninterpretedOption.length; i++)
+ UninterpretedOption.internalBinaryWrite(
+ message.uninterpretedOption[i],
+ writer.tag(999, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.FileOptions
+ */
+export const FileOptions = new FileOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MessageOptions$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.MessageOptions', [
+ {
+ no: 1,
+ name: 'message_set_wire_format',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 2,
+ name: 'no_standard_descriptor_accessor',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 3,
+ name: 'deprecated',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 7,
+ name: 'map_entry',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 11,
+ name: 'deprecated_legacy_json_field_conflicts',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 999,
+ name: 'uninterpreted_option',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => UninterpretedOption,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): MessageOptions {
+ const message = { uninterpretedOption: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: MessageOptions,
+ ): MessageOptions {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional bool message_set_wire_format */ 1:
+ message.messageSetWireFormat = reader.bool();
+ break;
+ case /* optional bool no_standard_descriptor_accessor */ 2:
+ message.noStandardDescriptorAccessor = reader.bool();
+ break;
+ case /* optional bool deprecated */ 3:
+ message.deprecated = reader.bool();
+ break;
+ case /* optional bool map_entry */ 7:
+ message.mapEntry = reader.bool();
+ break;
+ case /* optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true];*/ 11:
+ message.deprecatedLegacyJsonFieldConflicts = reader.bool();
+ break;
+ case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999:
+ message.uninterpretedOption.push(
+ UninterpretedOption.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: MessageOptions,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional bool message_set_wire_format = 1; */
+ if (message.messageSetWireFormat !== undefined)
+ writer.tag(1, WireType.Varint).bool(message.messageSetWireFormat);
+ /* optional bool no_standard_descriptor_accessor = 2; */
+ if (message.noStandardDescriptorAccessor !== undefined)
+ writer.tag(2, WireType.Varint).bool(message.noStandardDescriptorAccessor);
+ /* optional bool deprecated = 3; */
+ if (message.deprecated !== undefined)
+ writer.tag(3, WireType.Varint).bool(message.deprecated);
+ /* optional bool map_entry = 7; */
+ if (message.mapEntry !== undefined)
+ writer.tag(7, WireType.Varint).bool(message.mapEntry);
+ /* optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true]; */
+ if (message.deprecatedLegacyJsonFieldConflicts !== undefined)
+ writer
+ .tag(11, WireType.Varint)
+ .bool(message.deprecatedLegacyJsonFieldConflicts);
+ /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */
+ for (let i = 0; i < message.uninterpretedOption.length; i++)
+ UninterpretedOption.internalBinaryWrite(
+ message.uninterpretedOption[i],
+ writer.tag(999, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.MessageOptions
+ */
+export const MessageOptions = new MessageOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class FieldOptions$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.FieldOptions', [
+ {
+ no: 1,
+ name: 'ctype',
+ kind: 'enum',
+ opt: true,
+ T: () => ['google.protobuf.FieldOptions.CType', FieldOptions_CType],
+ },
+ {
+ no: 2,
+ name: 'packed',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 6,
+ name: 'jstype',
+ kind: 'enum',
+ opt: true,
+ T: () => ['google.protobuf.FieldOptions.JSType', FieldOptions_JSType],
+ },
+ {
+ no: 5,
+ name: 'lazy',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 15,
+ name: 'unverified_lazy',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 3,
+ name: 'deprecated',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 10,
+ name: 'weak',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 16,
+ name: 'debug_redact',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 17,
+ name: 'retention',
+ kind: 'enum',
+ opt: true,
+ T: () => [
+ 'google.protobuf.FieldOptions.OptionRetention',
+ FieldOptions_OptionRetention,
+ ],
+ },
+ {
+ no: 18,
+ name: 'target',
+ kind: 'enum',
+ opt: true,
+ T: () => [
+ 'google.protobuf.FieldOptions.OptionTargetType',
+ FieldOptions_OptionTargetType,
+ ],
+ },
+ {
+ no: 999,
+ name: 'uninterpreted_option',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => UninterpretedOption,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): FieldOptions {
+ const message = { uninterpretedOption: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: FieldOptions,
+ ): FieldOptions {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional google.protobuf.FieldOptions.CType ctype */ 1:
+ message.ctype = reader.int32();
+ break;
+ case /* optional bool packed */ 2:
+ message.packed = reader.bool();
+ break;
+ case /* optional google.protobuf.FieldOptions.JSType jstype */ 6:
+ message.jstype = reader.int32();
+ break;
+ case /* optional bool lazy */ 5:
+ message.lazy = reader.bool();
+ break;
+ case /* optional bool unverified_lazy */ 15:
+ message.unverifiedLazy = reader.bool();
+ break;
+ case /* optional bool deprecated */ 3:
+ message.deprecated = reader.bool();
+ break;
+ case /* optional bool weak */ 10:
+ message.weak = reader.bool();
+ break;
+ case /* optional bool debug_redact */ 16:
+ message.debugRedact = reader.bool();
+ break;
+ case /* optional google.protobuf.FieldOptions.OptionRetention retention */ 17:
+ message.retention = reader.int32();
+ break;
+ case /* optional google.protobuf.FieldOptions.OptionTargetType target */ 18:
+ message.target = reader.int32();
+ break;
+ case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999:
+ message.uninterpretedOption.push(
+ UninterpretedOption.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: FieldOptions,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional google.protobuf.FieldOptions.CType ctype = 1; */
+ if (message.ctype !== undefined)
+ writer.tag(1, WireType.Varint).int32(message.ctype);
+ /* optional bool packed = 2; */
+ if (message.packed !== undefined)
+ writer.tag(2, WireType.Varint).bool(message.packed);
+ /* optional google.protobuf.FieldOptions.JSType jstype = 6; */
+ if (message.jstype !== undefined)
+ writer.tag(6, WireType.Varint).int32(message.jstype);
+ /* optional bool lazy = 5; */
+ if (message.lazy !== undefined)
+ writer.tag(5, WireType.Varint).bool(message.lazy);
+ /* optional bool unverified_lazy = 15; */
+ if (message.unverifiedLazy !== undefined)
+ writer.tag(15, WireType.Varint).bool(message.unverifiedLazy);
+ /* optional bool deprecated = 3; */
+ if (message.deprecated !== undefined)
+ writer.tag(3, WireType.Varint).bool(message.deprecated);
+ /* optional bool weak = 10; */
+ if (message.weak !== undefined)
+ writer.tag(10, WireType.Varint).bool(message.weak);
+ /* optional bool debug_redact = 16; */
+ if (message.debugRedact !== undefined)
+ writer.tag(16, WireType.Varint).bool(message.debugRedact);
+ /* optional google.protobuf.FieldOptions.OptionRetention retention = 17; */
+ if (message.retention !== undefined)
+ writer.tag(17, WireType.Varint).int32(message.retention);
+ /* optional google.protobuf.FieldOptions.OptionTargetType target = 18; */
+ if (message.target !== undefined)
+ writer.tag(18, WireType.Varint).int32(message.target);
+ /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */
+ for (let i = 0; i < message.uninterpretedOption.length; i++)
+ UninterpretedOption.internalBinaryWrite(
+ message.uninterpretedOption[i],
+ writer.tag(999, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.FieldOptions
+ */
+export const FieldOptions = new FieldOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OneofOptions$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.OneofOptions', [
+ {
+ no: 999,
+ name: 'uninterpreted_option',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => UninterpretedOption,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): OneofOptions {
+ const message = { uninterpretedOption: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: OneofOptions,
+ ): OneofOptions {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999:
+ message.uninterpretedOption.push(
+ UninterpretedOption.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: OneofOptions,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */
+ for (let i = 0; i < message.uninterpretedOption.length; i++)
+ UninterpretedOption.internalBinaryWrite(
+ message.uninterpretedOption[i],
+ writer.tag(999, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.OneofOptions
+ */
+export const OneofOptions = new OneofOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EnumOptions$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.EnumOptions', [
+ {
+ no: 2,
+ name: 'allow_alias',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 3,
+ name: 'deprecated',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 6,
+ name: 'deprecated_legacy_json_field_conflicts',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 999,
+ name: 'uninterpreted_option',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => UninterpretedOption,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): EnumOptions {
+ const message = { uninterpretedOption: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: EnumOptions,
+ ): EnumOptions {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional bool allow_alias */ 2:
+ message.allowAlias = reader.bool();
+ break;
+ case /* optional bool deprecated */ 3:
+ message.deprecated = reader.bool();
+ break;
+ case /* optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true];*/ 6:
+ message.deprecatedLegacyJsonFieldConflicts = reader.bool();
+ break;
+ case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999:
+ message.uninterpretedOption.push(
+ UninterpretedOption.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: EnumOptions,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional bool allow_alias = 2; */
+ if (message.allowAlias !== undefined)
+ writer.tag(2, WireType.Varint).bool(message.allowAlias);
+ /* optional bool deprecated = 3; */
+ if (message.deprecated !== undefined)
+ writer.tag(3, WireType.Varint).bool(message.deprecated);
+ /* optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true]; */
+ if (message.deprecatedLegacyJsonFieldConflicts !== undefined)
+ writer
+ .tag(6, WireType.Varint)
+ .bool(message.deprecatedLegacyJsonFieldConflicts);
+ /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */
+ for (let i = 0; i < message.uninterpretedOption.length; i++)
+ UninterpretedOption.internalBinaryWrite(
+ message.uninterpretedOption[i],
+ writer.tag(999, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.EnumOptions
+ */
+export const EnumOptions = new EnumOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EnumValueOptions$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.EnumValueOptions', [
+ {
+ no: 1,
+ name: 'deprecated',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 999,
+ name: 'uninterpreted_option',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => UninterpretedOption,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): EnumValueOptions {
+ const message = { uninterpretedOption: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: EnumValueOptions,
+ ): EnumValueOptions {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional bool deprecated */ 1:
+ message.deprecated = reader.bool();
+ break;
+ case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999:
+ message.uninterpretedOption.push(
+ UninterpretedOption.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: EnumValueOptions,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional bool deprecated = 1; */
+ if (message.deprecated !== undefined)
+ writer.tag(1, WireType.Varint).bool(message.deprecated);
+ /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */
+ for (let i = 0; i < message.uninterpretedOption.length; i++)
+ UninterpretedOption.internalBinaryWrite(
+ message.uninterpretedOption[i],
+ writer.tag(999, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.EnumValueOptions
+ */
+export const EnumValueOptions = new EnumValueOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServiceOptions$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.ServiceOptions', [
+ {
+ no: 33,
+ name: 'deprecated',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 999,
+ name: 'uninterpreted_option',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => UninterpretedOption,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): ServiceOptions {
+ const message = { uninterpretedOption: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: ServiceOptions,
+ ): ServiceOptions {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional bool deprecated */ 33:
+ message.deprecated = reader.bool();
+ break;
+ case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999:
+ message.uninterpretedOption.push(
+ UninterpretedOption.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: ServiceOptions,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional bool deprecated = 33; */
+ if (message.deprecated !== undefined)
+ writer.tag(33, WireType.Varint).bool(message.deprecated);
+ /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */
+ for (let i = 0; i < message.uninterpretedOption.length; i++)
+ UninterpretedOption.internalBinaryWrite(
+ message.uninterpretedOption[i],
+ writer.tag(999, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.ServiceOptions
+ */
+export const ServiceOptions = new ServiceOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MethodOptions$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.MethodOptions', [
+ {
+ no: 33,
+ name: 'deprecated',
+ kind: 'scalar',
+ opt: true,
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ {
+ no: 34,
+ name: 'idempotency_level',
+ kind: 'enum',
+ opt: true,
+ T: () => [
+ 'google.protobuf.MethodOptions.IdempotencyLevel',
+ MethodOptions_IdempotencyLevel,
+ ],
+ },
+ {
+ no: 999,
+ name: 'uninterpreted_option',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => UninterpretedOption,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): MethodOptions {
+ const message = { uninterpretedOption: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: MethodOptions,
+ ): MethodOptions {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* optional bool deprecated */ 33:
+ message.deprecated = reader.bool();
+ break;
+ case /* optional google.protobuf.MethodOptions.IdempotencyLevel idempotency_level */ 34:
+ message.idempotencyLevel = reader.int32();
+ break;
+ case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999:
+ message.uninterpretedOption.push(
+ UninterpretedOption.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: MethodOptions,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* optional bool deprecated = 33; */
+ if (message.deprecated !== undefined)
+ writer.tag(33, WireType.Varint).bool(message.deprecated);
+ /* optional google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34; */
+ if (message.idempotencyLevel !== undefined)
+ writer.tag(34, WireType.Varint).int32(message.idempotencyLevel);
+ /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */
+ for (let i = 0; i < message.uninterpretedOption.length; i++)
+ UninterpretedOption.internalBinaryWrite(
+ message.uninterpretedOption[i],
+ writer.tag(999, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.MethodOptions
+ */
+export const MethodOptions = new MethodOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UninterpretedOption$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.UninterpretedOption', [
+ {
+ no: 2,
+ name: 'name',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => UninterpretedOption_NamePart,
+ },
+ {
+ no: 3,
+ name: 'identifier_value',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 4,
+ name: 'positive_int_value',
+ kind: 'scalar',
+ opt: true,
+ T: 4 /* ScalarType.UINT64*/,
+ L: 0 /* LongType.BIGINT*/,
+ },
+ {
+ no: 5,
+ name: 'negative_int_value',
+ kind: 'scalar',
+ opt: true,
+ T: 3 /* ScalarType.INT64*/,
+ L: 0 /* LongType.BIGINT*/,
+ },
+ {
+ no: 6,
+ name: 'double_value',
+ kind: 'scalar',
+ opt: true,
+ T: 1 /* ScalarType.DOUBLE*/,
+ },
+ {
+ no: 7,
+ name: 'string_value',
+ kind: 'scalar',
+ opt: true,
+ T: 12 /* ScalarType.BYTES*/,
+ },
+ {
+ no: 8,
+ name: 'aggregate_value',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): UninterpretedOption {
+ const message = { name: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: UninterpretedOption,
+ ): UninterpretedOption {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* repeated google.protobuf.UninterpretedOption.NamePart name */ 2:
+ message.name.push(
+ UninterpretedOption_NamePart.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ case /* optional string identifier_value */ 3:
+ message.identifierValue = reader.string();
+ break;
+ case /* optional uint64 positive_int_value */ 4:
+ message.positiveIntValue = reader.uint64().toBigInt();
+ break;
+ case /* optional int64 negative_int_value */ 5:
+ message.negativeIntValue = reader.int64().toBigInt();
+ break;
+ case /* optional double double_value */ 6:
+ message.doubleValue = reader.double();
+ break;
+ case /* optional bytes string_value */ 7:
+ message.stringValue = reader.bytes();
+ break;
+ case /* optional string aggregate_value */ 8:
+ message.aggregateValue = reader.string();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: UninterpretedOption,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* repeated google.protobuf.UninterpretedOption.NamePart name = 2; */
+ for (let i = 0; i < message.name.length; i++)
+ UninterpretedOption_NamePart.internalBinaryWrite(
+ message.name[i],
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* optional string identifier_value = 3; */
+ if (message.identifierValue !== undefined)
+ writer.tag(3, WireType.LengthDelimited).string(message.identifierValue);
+ /* optional uint64 positive_int_value = 4; */
+ if (message.positiveIntValue !== undefined)
+ writer.tag(4, WireType.Varint).uint64(message.positiveIntValue);
+ /* optional int64 negative_int_value = 5; */
+ if (message.negativeIntValue !== undefined)
+ writer.tag(5, WireType.Varint).int64(message.negativeIntValue);
+ /* optional double double_value = 6; */
+ if (message.doubleValue !== undefined)
+ writer.tag(6, WireType.Bit64).double(message.doubleValue);
+ /* optional bytes string_value = 7; */
+ if (message.stringValue !== undefined)
+ writer.tag(7, WireType.LengthDelimited).bytes(message.stringValue);
+ /* optional string aggregate_value = 8; */
+ if (message.aggregateValue !== undefined)
+ writer.tag(8, WireType.LengthDelimited).string(message.aggregateValue);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.UninterpretedOption
+ */
+export const UninterpretedOption = new UninterpretedOption$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UninterpretedOption_NamePart$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.UninterpretedOption.NamePart', [
+ { no: 1, name: 'name_part', kind: 'scalar', T: 9 /* ScalarType.STRING*/ },
+ {
+ no: 2,
+ name: 'is_extension',
+ kind: 'scalar',
+ T: 8 /* ScalarType.BOOL*/,
+ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): UninterpretedOption_NamePart {
+ const message = { namePart: '', isExtension: false };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(
+ this,
+ message,
+ value,
+ );
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: UninterpretedOption_NamePart,
+ ): UninterpretedOption_NamePart {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* string name_part */ 1:
+ message.namePart = reader.string();
+ break;
+ case /* bool is_extension */ 2:
+ message.isExtension = reader.bool();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: UninterpretedOption_NamePart,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* string name_part = 1; */
+ if (message.namePart !== '')
+ writer.tag(1, WireType.LengthDelimited).string(message.namePart);
+ /* bool is_extension = 2; */
+ if (message.isExtension !== false)
+ writer.tag(2, WireType.Varint).bool(message.isExtension);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.UninterpretedOption.NamePart
+ */
+export const UninterpretedOption_NamePart =
+ new UninterpretedOption_NamePart$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SourceCodeInfo$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.SourceCodeInfo', [
+ {
+ no: 1,
+ name: 'location',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => SourceCodeInfo_Location,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): SourceCodeInfo {
+ const message = { location: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: SourceCodeInfo,
+ ): SourceCodeInfo {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* repeated google.protobuf.SourceCodeInfo.Location location */ 1:
+ message.location.push(
+ SourceCodeInfo_Location.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: SourceCodeInfo,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* repeated google.protobuf.SourceCodeInfo.Location location = 1; */
+ for (let i = 0; i < message.location.length; i++)
+ SourceCodeInfo_Location.internalBinaryWrite(
+ message.location[i],
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.SourceCodeInfo
+ */
+export const SourceCodeInfo = new SourceCodeInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SourceCodeInfo_Location$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.SourceCodeInfo.Location', [
+ {
+ no: 1,
+ name: 'path',
+ kind: 'scalar',
+ repeat: 1 /* RepeatType.PACKED*/,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ {
+ no: 2,
+ name: 'span',
+ kind: 'scalar',
+ repeat: 1 /* RepeatType.PACKED*/,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ {
+ no: 3,
+ name: 'leading_comments',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 4,
+ name: 'trailing_comments',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 6,
+ name: 'leading_detached_comments',
+ kind: 'scalar',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): SourceCodeInfo_Location {
+ const message = { path: [], span: [], leadingDetachedComments: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: SourceCodeInfo_Location,
+ ): SourceCodeInfo_Location {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* repeated int32 path = 1 [packed = true];*/ 1:
+ if (wireType === WireType.LengthDelimited)
+ for (let e = reader.int32() + reader.pos; reader.pos < e; )
+ message.path.push(reader.int32());
+ else message.path.push(reader.int32());
+ break;
+ case /* repeated int32 span = 2 [packed = true];*/ 2:
+ if (wireType === WireType.LengthDelimited)
+ for (let e = reader.int32() + reader.pos; reader.pos < e; )
+ message.span.push(reader.int32());
+ else message.span.push(reader.int32());
+ break;
+ case /* optional string leading_comments */ 3:
+ message.leadingComments = reader.string();
+ break;
+ case /* optional string trailing_comments */ 4:
+ message.trailingComments = reader.string();
+ break;
+ case /* repeated string leading_detached_comments */ 6:
+ message.leadingDetachedComments.push(reader.string());
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: SourceCodeInfo_Location,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* repeated int32 path = 1 [packed = true]; */
+ if (message.path.length) {
+ writer.tag(1, WireType.LengthDelimited).fork();
+ for (let i = 0; i < message.path.length; i++)
+ writer.int32(message.path[i]);
+ writer.join();
+ }
+ /* repeated int32 span = 2 [packed = true]; */
+ if (message.span.length) {
+ writer.tag(2, WireType.LengthDelimited).fork();
+ for (let i = 0; i < message.span.length; i++)
+ writer.int32(message.span[i]);
+ writer.join();
+ }
+ /* optional string leading_comments = 3; */
+ if (message.leadingComments !== undefined)
+ writer.tag(3, WireType.LengthDelimited).string(message.leadingComments);
+ /* optional string trailing_comments = 4; */
+ if (message.trailingComments !== undefined)
+ writer.tag(4, WireType.LengthDelimited).string(message.trailingComments);
+ /* repeated string leading_detached_comments = 6; */
+ for (let i = 0; i < message.leadingDetachedComments.length; i++)
+ writer
+ .tag(6, WireType.LengthDelimited)
+ .string(message.leadingDetachedComments[i]);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.SourceCodeInfo.Location
+ */
+export const SourceCodeInfo_Location = new SourceCodeInfo_Location$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GeneratedCodeInfo$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.GeneratedCodeInfo', [
+ {
+ no: 1,
+ name: 'annotation',
+ kind: 'message',
+ repeat: 2 /* RepeatType.UNPACKED*/,
+ T: () => GeneratedCodeInfo_Annotation,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): GeneratedCodeInfo {
+ const message = { annotation: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: GeneratedCodeInfo,
+ ): GeneratedCodeInfo {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* repeated google.protobuf.GeneratedCodeInfo.Annotation annotation */ 1:
+ message.annotation.push(
+ GeneratedCodeInfo_Annotation.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ ),
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: GeneratedCodeInfo,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* repeated google.protobuf.GeneratedCodeInfo.Annotation annotation = 1; */
+ for (let i = 0; i < message.annotation.length; i++)
+ GeneratedCodeInfo_Annotation.internalBinaryWrite(
+ message.annotation[i],
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.GeneratedCodeInfo
+ */
+export const GeneratedCodeInfo = new GeneratedCodeInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GeneratedCodeInfo_Annotation$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.GeneratedCodeInfo.Annotation', [
+ {
+ no: 1,
+ name: 'path',
+ kind: 'scalar',
+ repeat: 1 /* RepeatType.PACKED*/,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ {
+ no: 2,
+ name: 'source_file',
+ kind: 'scalar',
+ opt: true,
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 3,
+ name: 'begin',
+ kind: 'scalar',
+ opt: true,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ {
+ no: 4,
+ name: 'end',
+ kind: 'scalar',
+ opt: true,
+ T: 5 /* ScalarType.INT32*/,
+ },
+ {
+ no: 5,
+ name: 'semantic',
+ kind: 'enum',
+ opt: true,
+ T: () => [
+ 'google.protobuf.GeneratedCodeInfo.Annotation.Semantic',
+ GeneratedCodeInfo_Annotation_Semantic,
+ ],
+ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): GeneratedCodeInfo_Annotation {
+ const message = { path: [] };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(
+ this,
+ message,
+ value,
+ );
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: GeneratedCodeInfo_Annotation,
+ ): GeneratedCodeInfo_Annotation {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* repeated int32 path = 1 [packed = true];*/ 1:
+ if (wireType === WireType.LengthDelimited)
+ for (let e = reader.int32() + reader.pos; reader.pos < e; )
+ message.path.push(reader.int32());
+ else message.path.push(reader.int32());
+ break;
+ case /* optional string source_file */ 2:
+ message.sourceFile = reader.string();
+ break;
+ case /* optional int32 begin */ 3:
+ message.begin = reader.int32();
+ break;
+ case /* optional int32 end */ 4:
+ message.end = reader.int32();
+ break;
+ case /* optional google.protobuf.GeneratedCodeInfo.Annotation.Semantic semantic */ 5:
+ message.semantic = reader.int32();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: GeneratedCodeInfo_Annotation,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* repeated int32 path = 1 [packed = true]; */
+ if (message.path.length) {
+ writer.tag(1, WireType.LengthDelimited).fork();
+ for (let i = 0; i < message.path.length; i++)
+ writer.int32(message.path[i]);
+ writer.join();
+ }
+ /* optional string source_file = 2; */
+ if (message.sourceFile !== undefined)
+ writer.tag(2, WireType.LengthDelimited).string(message.sourceFile);
+ /* optional int32 begin = 3; */
+ if (message.begin !== undefined)
+ writer.tag(3, WireType.Varint).int32(message.begin);
+ /* optional int32 end = 4; */
+ if (message.end !== undefined)
+ writer.tag(4, WireType.Varint).int32(message.end);
+ /* optional google.protobuf.GeneratedCodeInfo.Annotation.Semantic semantic = 5; */
+ if (message.semantic !== undefined)
+ writer.tag(5, WireType.Varint).int32(message.semantic);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.GeneratedCodeInfo.Annotation
+ */
+export const GeneratedCodeInfo_Annotation =
+ new GeneratedCodeInfo_Annotation$Type();
diff --git a/frontend/src/proto-gen/google/protobuf/wrappers.ts b/frontend/src/proto-gen/google/protobuf/wrappers.ts
new file mode 100644
index 0000000..f37473a
--- /dev/null
+++ b/frontend/src/proto-gen/google/protobuf/wrappers.ts
@@ -0,0 +1,1086 @@
+// @generated by protobuf-ts 2.9.1 with parameter generate_dependencies
+// @generated from protobuf file "google/protobuf/wrappers.proto" (package "google.protobuf", syntax proto3)
+// tslint:disable
+//
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Wrappers for primitive (non-message) types. These types are useful
+// for embedding primitives in the `google.protobuf.Any` type and for places
+// where we need to distinguish between the absence of a primitive
+// typed field and its default value.
+//
+// These wrappers have no meaningful use within repeated fields as they lack
+// the ability to detect presence on individual elements.
+// These wrappers have no meaningful use within a map or a oneof since
+// individual entries of a map or fields of a oneof can already detect presence.
+//
+// @ts-nocheck
+
+import { ScalarType } from '@protobuf-ts/runtime';
+import { LongType } from '@protobuf-ts/runtime';
+import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
+import type { IBinaryWriter } from '@protobuf-ts/runtime';
+import { WireType } from '@protobuf-ts/runtime';
+import type { BinaryReadOptions } from '@protobuf-ts/runtime';
+import type { IBinaryReader } from '@protobuf-ts/runtime';
+import { UnknownFieldHandler } from '@protobuf-ts/runtime';
+import type { PartialMessage } from '@protobuf-ts/runtime';
+import { reflectionMergePartial } from '@protobuf-ts/runtime';
+import { MESSAGE_TYPE } from '@protobuf-ts/runtime';
+import type { JsonValue } from '@protobuf-ts/runtime';
+import type { JsonReadOptions } from '@protobuf-ts/runtime';
+import type { JsonWriteOptions } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+/**
+ * Wrapper message for `double`.
+ *
+ * The JSON representation for `DoubleValue` is JSON number.
+ *
+ * @generated from protobuf message google.protobuf.DoubleValue
+ */
+export interface DoubleValue {
+ /**
+ * The double value.
+ *
+ * @generated from protobuf field: double value = 1;
+ */
+ value: number;
+}
+/**
+ * Wrapper message for `float`.
+ *
+ * The JSON representation for `FloatValue` is JSON number.
+ *
+ * @generated from protobuf message google.protobuf.FloatValue
+ */
+export interface FloatValue {
+ /**
+ * The float value.
+ *
+ * @generated from protobuf field: float value = 1;
+ */
+ value: number;
+}
+/**
+ * Wrapper message for `int64`.
+ *
+ * The JSON representation for `Int64Value` is JSON string.
+ *
+ * @generated from protobuf message google.protobuf.Int64Value
+ */
+export interface Int64Value {
+ /**
+ * The int64 value.
+ *
+ * @generated from protobuf field: int64 value = 1;
+ */
+ value: bigint;
+}
+/**
+ * Wrapper message for `uint64`.
+ *
+ * The JSON representation for `UInt64Value` is JSON string.
+ *
+ * @generated from protobuf message google.protobuf.UInt64Value
+ */
+export interface UInt64Value {
+ /**
+ * The uint64 value.
+ *
+ * @generated from protobuf field: uint64 value = 1;
+ */
+ value: bigint;
+}
+/**
+ * Wrapper message for `int32`.
+ *
+ * The JSON representation for `Int32Value` is JSON number.
+ *
+ * @generated from protobuf message google.protobuf.Int32Value
+ */
+export interface Int32Value {
+ /**
+ * The int32 value.
+ *
+ * @generated from protobuf field: int32 value = 1;
+ */
+ value: number;
+}
+/**
+ * Wrapper message for `uint32`.
+ *
+ * The JSON representation for `UInt32Value` is JSON number.
+ *
+ * @generated from protobuf message google.protobuf.UInt32Value
+ */
+export interface UInt32Value {
+ /**
+ * The uint32 value.
+ *
+ * @generated from protobuf field: uint32 value = 1;
+ */
+ value: number;
+}
+/**
+ * Wrapper message for `bool`.
+ *
+ * The JSON representation for `BoolValue` is JSON `true` and `false`.
+ *
+ * @generated from protobuf message google.protobuf.BoolValue
+ */
+export interface BoolValue {
+ /**
+ * The bool value.
+ *
+ * @generated from protobuf field: bool value = 1;
+ */
+ value: boolean;
+}
+/**
+ * Wrapper message for `string`.
+ *
+ * The JSON representation for `StringValue` is JSON string.
+ *
+ * @generated from protobuf message google.protobuf.StringValue
+ */
+export interface StringValue {
+ /**
+ * The string value.
+ *
+ * @generated from protobuf field: string value = 1;
+ */
+ value: string;
+}
+/**
+ * Wrapper message for `bytes`.
+ *
+ * The JSON representation for `BytesValue` is JSON string.
+ *
+ * @generated from protobuf message google.protobuf.BytesValue
+ */
+export interface BytesValue {
+ /**
+ * The bytes value.
+ *
+ * @generated from protobuf field: bytes value = 1;
+ */
+ value: Uint8Array;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class DoubleValue$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.DoubleValue', [
+ { no: 1, name: 'value', kind: 'scalar', T: 1 /* ScalarType.DOUBLE*/ },
+ ]);
+ }
+ /**
+ * Encode `DoubleValue` to JSON number.
+ */
+ internalJsonWrite(
+ message: DoubleValue,
+ options: JsonWriteOptions,
+ ): JsonValue {
+ return this.refJsonWriter.scalar(2, message.value, 'value', false, true);
+ }
+ /**
+ * Decode `DoubleValue` from JSON number.
+ */
+ internalJsonRead(
+ json: JsonValue,
+ options: JsonReadOptions,
+ target?: DoubleValue,
+ ): DoubleValue {
+ if (!target) target = this.create();
+ target.value = this.refJsonReader.scalar(
+ json,
+ 1,
+ undefined,
+ 'value',
+ ) as number;
+ return target;
+ }
+ create(value?: PartialMessage): DoubleValue {
+ const message = { value: 0 };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: DoubleValue,
+ ): DoubleValue {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* double value */ 1:
+ message.value = reader.double();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: DoubleValue,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* double value = 1; */
+ if (message.value !== 0)
+ writer.tag(1, WireType.Bit64).double(message.value);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.DoubleValue
+ */
+export const DoubleValue = new DoubleValue$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class FloatValue$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.FloatValue', [
+ { no: 1, name: 'value', kind: 'scalar', T: 2 /* ScalarType.FLOAT*/ },
+ ]);
+ }
+ /**
+ * Encode `FloatValue` to JSON number.
+ */
+ internalJsonWrite(message: FloatValue, options: JsonWriteOptions): JsonValue {
+ return this.refJsonWriter.scalar(1, message.value, 'value', false, true);
+ }
+ /**
+ * Decode `FloatValue` from JSON number.
+ */
+ internalJsonRead(
+ json: JsonValue,
+ options: JsonReadOptions,
+ target?: FloatValue,
+ ): FloatValue {
+ if (!target) target = this.create();
+ target.value = this.refJsonReader.scalar(
+ json,
+ 1,
+ undefined,
+ 'value',
+ ) as number;
+ return target;
+ }
+ create(value?: PartialMessage): FloatValue {
+ const message = { value: 0 };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: FloatValue,
+ ): FloatValue {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* float value */ 1:
+ message.value = reader.float();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: FloatValue,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* float value = 1; */
+ if (message.value !== 0) writer.tag(1, WireType.Bit32).float(message.value);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.FloatValue
+ */
+export const FloatValue = new FloatValue$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Int64Value$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.Int64Value', [
+ {
+ no: 1,
+ name: 'value',
+ kind: 'scalar',
+ T: 3 /* ScalarType.INT64*/,
+ L: 0 /* LongType.BIGINT*/,
+ },
+ ]);
+ }
+ /**
+ * Encode `Int64Value` to JSON string.
+ */
+ internalJsonWrite(message: Int64Value, options: JsonWriteOptions): JsonValue {
+ return this.refJsonWriter.scalar(
+ ScalarType.INT64,
+ message.value,
+ 'value',
+ false,
+ true,
+ );
+ }
+ /**
+ * Decode `Int64Value` from JSON string.
+ */
+ internalJsonRead(
+ json: JsonValue,
+ options: JsonReadOptions,
+ target?: Int64Value,
+ ): Int64Value {
+ if (!target) target = this.create();
+ target.value = this.refJsonReader.scalar(
+ json,
+ ScalarType.INT64,
+ LongType.BIGINT,
+ 'value',
+ ) as any;
+ return target;
+ }
+ create(value?: PartialMessage): Int64Value {
+ const message = { value: 0n };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: Int64Value,
+ ): Int64Value {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* int64 value */ 1:
+ message.value = reader.int64().toBigInt();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: Int64Value,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* int64 value = 1; */
+ if (message.value !== 0n)
+ writer.tag(1, WireType.Varint).int64(message.value);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Int64Value
+ */
+export const Int64Value = new Int64Value$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UInt64Value$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.UInt64Value', [
+ {
+ no: 1,
+ name: 'value',
+ kind: 'scalar',
+ T: 4 /* ScalarType.UINT64*/,
+ L: 0 /* LongType.BIGINT*/,
+ },
+ ]);
+ }
+ /**
+ * Encode `UInt64Value` to JSON string.
+ */
+ internalJsonWrite(
+ message: UInt64Value,
+ options: JsonWriteOptions,
+ ): JsonValue {
+ return this.refJsonWriter.scalar(
+ ScalarType.UINT64,
+ message.value,
+ 'value',
+ false,
+ true,
+ );
+ }
+ /**
+ * Decode `UInt64Value` from JSON string.
+ */
+ internalJsonRead(
+ json: JsonValue,
+ options: JsonReadOptions,
+ target?: UInt64Value,
+ ): UInt64Value {
+ if (!target) target = this.create();
+ target.value = this.refJsonReader.scalar(
+ json,
+ ScalarType.UINT64,
+ LongType.BIGINT,
+ 'value',
+ ) as any;
+ return target;
+ }
+ create(value?: PartialMessage): UInt64Value {
+ const message = { value: 0n };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: UInt64Value,
+ ): UInt64Value {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* uint64 value */ 1:
+ message.value = reader.uint64().toBigInt();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: UInt64Value,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* uint64 value = 1; */
+ if (message.value !== 0n)
+ writer.tag(1, WireType.Varint).uint64(message.value);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.UInt64Value
+ */
+export const UInt64Value = new UInt64Value$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Int32Value$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.Int32Value', [
+ { no: 1, name: 'value', kind: 'scalar', T: 5 /* ScalarType.INT32*/ },
+ ]);
+ }
+ /**
+ * Encode `Int32Value` to JSON string.
+ */
+ internalJsonWrite(message: Int32Value, options: JsonWriteOptions): JsonValue {
+ return this.refJsonWriter.scalar(5, message.value, 'value', false, true);
+ }
+ /**
+ * Decode `Int32Value` from JSON string.
+ */
+ internalJsonRead(
+ json: JsonValue,
+ options: JsonReadOptions,
+ target?: Int32Value,
+ ): Int32Value {
+ if (!target) target = this.create();
+ target.value = this.refJsonReader.scalar(
+ json,
+ 5,
+ undefined,
+ 'value',
+ ) as number;
+ return target;
+ }
+ create(value?: PartialMessage): Int32Value {
+ const message = { value: 0 };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: Int32Value,
+ ): Int32Value {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* int32 value */ 1:
+ message.value = reader.int32();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: Int32Value,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* int32 value = 1; */
+ if (message.value !== 0)
+ writer.tag(1, WireType.Varint).int32(message.value);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Int32Value
+ */
+export const Int32Value = new Int32Value$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UInt32Value$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.UInt32Value', [
+ { no: 1, name: 'value', kind: 'scalar', T: 13 /* ScalarType.UINT32*/ },
+ ]);
+ }
+ /**
+ * Encode `UInt32Value` to JSON string.
+ */
+ internalJsonWrite(
+ message: UInt32Value,
+ options: JsonWriteOptions,
+ ): JsonValue {
+ return this.refJsonWriter.scalar(13, message.value, 'value', false, true);
+ }
+ /**
+ * Decode `UInt32Value` from JSON string.
+ */
+ internalJsonRead(
+ json: JsonValue,
+ options: JsonReadOptions,
+ target?: UInt32Value,
+ ): UInt32Value {
+ if (!target) target = this.create();
+ target.value = this.refJsonReader.scalar(
+ json,
+ 13,
+ undefined,
+ 'value',
+ ) as number;
+ return target;
+ }
+ create(value?: PartialMessage): UInt32Value {
+ const message = { value: 0 };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: UInt32Value,
+ ): UInt32Value {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* uint32 value */ 1:
+ message.value = reader.uint32();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: UInt32Value,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* uint32 value = 1; */
+ if (message.value !== 0)
+ writer.tag(1, WireType.Varint).uint32(message.value);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.UInt32Value
+ */
+export const UInt32Value = new UInt32Value$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class BoolValue$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.BoolValue', [
+ { no: 1, name: 'value', kind: 'scalar', T: 8 /* ScalarType.BOOL*/ },
+ ]);
+ }
+ /**
+ * Encode `BoolValue` to JSON bool.
+ */
+ internalJsonWrite(message: BoolValue, options: JsonWriteOptions): JsonValue {
+ return message.value;
+ }
+ /**
+ * Decode `BoolValue` from JSON bool.
+ */
+ internalJsonRead(
+ json: JsonValue,
+ options: JsonReadOptions,
+ target?: BoolValue,
+ ): BoolValue {
+ if (!target) target = this.create();
+ target.value = this.refJsonReader.scalar(
+ json,
+ 8,
+ undefined,
+ 'value',
+ ) as boolean;
+ return target;
+ }
+ create(value?: PartialMessage): BoolValue {
+ const message = { value: false };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: BoolValue,
+ ): BoolValue {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* bool value */ 1:
+ message.value = reader.bool();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: BoolValue,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* bool value = 1; */
+ if (message.value !== false)
+ writer.tag(1, WireType.Varint).bool(message.value);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.BoolValue
+ */
+export const BoolValue = new BoolValue$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StringValue$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.StringValue', [
+ { no: 1, name: 'value', kind: 'scalar', T: 9 /* ScalarType.STRING*/ },
+ ]);
+ }
+ /**
+ * Encode `StringValue` to JSON string.
+ */
+ internalJsonWrite(
+ message: StringValue,
+ options: JsonWriteOptions,
+ ): JsonValue {
+ return message.value;
+ }
+ /**
+ * Decode `StringValue` from JSON string.
+ */
+ internalJsonRead(
+ json: JsonValue,
+ options: JsonReadOptions,
+ target?: StringValue,
+ ): StringValue {
+ if (!target) target = this.create();
+ target.value = this.refJsonReader.scalar(
+ json,
+ 9,
+ undefined,
+ 'value',
+ ) as string;
+ return target;
+ }
+ create(value?: PartialMessage): StringValue {
+ const message = { value: '' };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: StringValue,
+ ): StringValue {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* string value */ 1:
+ message.value = reader.string();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: StringValue,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* string value = 1; */
+ if (message.value !== '')
+ writer.tag(1, WireType.LengthDelimited).string(message.value);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.StringValue
+ */
+export const StringValue = new StringValue$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class BytesValue$Type extends MessageType {
+ constructor() {
+ super('google.protobuf.BytesValue', [
+ { no: 1, name: 'value', kind: 'scalar', T: 12 /* ScalarType.BYTES*/ },
+ ]);
+ }
+ /**
+ * Encode `BytesValue` to JSON string.
+ */
+ internalJsonWrite(message: BytesValue, options: JsonWriteOptions): JsonValue {
+ return this.refJsonWriter.scalar(12, message.value, 'value', false, true);
+ }
+ /**
+ * Decode `BytesValue` from JSON string.
+ */
+ internalJsonRead(
+ json: JsonValue,
+ options: JsonReadOptions,
+ target?: BytesValue,
+ ): BytesValue {
+ if (!target) target = this.create();
+ target.value = this.refJsonReader.scalar(
+ json,
+ 12,
+ undefined,
+ 'value',
+ ) as Uint8Array;
+ return target;
+ }
+ create(value?: PartialMessage): BytesValue {
+ const message = { value: new Uint8Array(0) };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: BytesValue,
+ ): BytesValue {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* bytes value */ 1:
+ message.value = reader.bytes();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: BytesValue,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* bytes value = 1; */
+ if (message.value.length)
+ writer.tag(1, WireType.LengthDelimited).bytes(message.value);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.BytesValue
+ */
+export const BytesValue = new BytesValue$Type();
diff --git a/frontend/src/proto-gen/massa/abi/v1/abi.ts b/frontend/src/proto-gen/massa/abi/v1/abi.ts
new file mode 100644
index 0000000..1f65f0c
--- /dev/null
+++ b/frontend/src/proto-gen/massa/abi/v1/abi.ts
@@ -0,0 +1,14173 @@
+// @generated by protobuf-ts 2.9.1 with parameter generate_dependencies
+// @generated from protobuf file "massa/abi/v1/abi.proto" (package "massa.abi.v1", syntax proto3)
+// tslint:disable
+//
+// Copyright (c) 2023 MASSA LABS
+//
+import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
+import type { IBinaryWriter } from '@protobuf-ts/runtime';
+import { WireType } from '@protobuf-ts/runtime';
+import type { BinaryReadOptions } from '@protobuf-ts/runtime';
+import type { IBinaryReader } from '@protobuf-ts/runtime';
+import { UnknownFieldHandler } from '@protobuf-ts/runtime';
+import type { PartialMessage } from '@protobuf-ts/runtime';
+import { reflectionMergePartial } from '@protobuf-ts/runtime';
+import { MESSAGE_TYPE } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+import { AddressCategory } from '../../model/v1/address';
+import { Slot } from '../../model/v1/slot';
+import { BytesValue } from '../../../google/protobuf/wrappers';
+import { ComparisonResult } from '../../model/v1/commons';
+import { NativeTime } from '../../model/v1/time';
+import { StringValue } from '../../../google/protobuf/wrappers';
+import { NativeAmount } from '../../model/v1/amount';
+/**
+ * Error message used in abi Response
+ *
+ * @generated from protobuf message massa.abi.v1.Error
+ */
+export interface Error {
+ /**
+ * a string representing the error
+ *
+ * @generated from protobuf field: string message = 1;
+ */
+ message: string;
+}
+/**
+ * Create SC request
+ *
+ * @generated from protobuf message massa.abi.v1.CreateScRequest
+ */
+export interface CreateScRequest {
+ /**
+ * Bytecode is the compiled code of the smart contract
+ *
+ * @generated from protobuf field: bytes bytecode = 1;
+ */
+ bytecode: Uint8Array;
+}
+/**
+ * Create SC result
+ *
+ * @generated from protobuf message massa.abi.v1.CreateScResult
+ */
+export interface CreateScResult {
+ /**
+ * Address of the just created smart contract
+ *
+ * @generated from protobuf field: string sc_address = 1;
+ */
+ scAddress: string;
+}
+/**
+ * Call SC request
+ *
+ * @generated from protobuf message massa.abi.v1.CallRequest
+ */
+export interface CallRequest {
+ /**
+ * Address of the smart contract to call
+ *
+ * @generated from protobuf field: string target_sc_address = 1;
+ */
+ targetScAddress: string;
+ /**
+ * Function to call in the targeted smart contract
+ *
+ * @generated from protobuf field: string target_function_name = 2;
+ */
+ targetFunctionName: string;
+ /**
+ * Argument to the function serialized in a byte array.
+ *
+ * @generated from protobuf field: bytes function_arg = 3;
+ */
+ functionArg: Uint8Array;
+ /**
+ * call_coins is the amount of coins to pay for the call
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount call_coins = 4;
+ */
+ callCoins?: NativeAmount;
+}
+/**
+ * Call SC response
+ *
+ * @generated from protobuf message massa.abi.v1.CallResponse
+ */
+export interface CallResponse {
+ /**
+ * Return_data is the return value of the function
+ *
+ * @generated from protobuf field: bytes data = 1;
+ */
+ data: Uint8Array;
+}
+/**
+ * Local execution request
+ *
+ * @generated from protobuf message massa.abi.v1.LocalExecutionRequest
+ */
+export interface LocalExecutionRequest {
+ /**
+ * Bytecode is the compiled code of the smart contract
+ *
+ * @generated from protobuf field: bytes bytecode = 1;
+ */
+ bytecode: Uint8Array;
+ /**
+ * Function to call in the targeted smart contract
+ *
+ * @generated from protobuf field: string target_function_name = 2;
+ */
+ targetFunctionName: string;
+ /**
+ * Argument to the function serialized in a byte array.
+ *
+ * @generated from protobuf field: bytes function_arg = 3;
+ */
+ functionArg: Uint8Array;
+}
+/**
+ * Local call response
+ *
+ * @generated from protobuf message massa.abi.v1.LocalExecutionResponse
+ */
+export interface LocalExecutionResponse {
+ /**
+ * Return_data is the return value of the function
+ *
+ * @generated from protobuf field: bytes data = 1;
+ */
+ data: Uint8Array;
+}
+/**
+ * Generate event request
+ *
+ * @generated from protobuf message massa.abi.v1.GenerateEventRequest
+ */
+export interface GenerateEventRequest {
+ /**
+ * Event
+ *
+ * @generated from protobuf field: bytes event = 1;
+ */
+ event: Uint8Array;
+}
+/**
+ * Generate event resulst
+ *
+ * @generated from protobuf message massa.abi.v1.GenerateEventResult
+ */
+export interface GenerateEventResult {}
+/**
+ * Transfer coins request
+ *
+ * @generated from protobuf message massa.abi.v1.TransferCoinsRequest
+ */
+export interface TransferCoinsRequest {
+ /**
+ * The address of the recipient
+ *
+ * @generated from protobuf field: string target_address = 1;
+ */
+ targetAddress: string;
+ /**
+ * The amount of coins to transfer
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount amount_to_transfer = 2;
+ */
+ amountToTransfer?: NativeAmount;
+ /**
+ * The address of the sender, if none, use current address
+ *
+ * @generated from protobuf field: optional google.protobuf.StringValue sender_address = 3;
+ */
+ senderAddress?: StringValue;
+}
+/**
+ * Transfer coin result
+ *
+ * @generated from protobuf message massa.abi.v1.TransferCoinsResult
+ */
+export interface TransferCoinsResult {}
+/**
+ * Function exists request
+ *
+ * @generated from protobuf message massa.abi.v1.FunctionExistsRequest
+ */
+export interface FunctionExistsRequest {
+ /**
+ * Address of the smart contract to call
+ *
+ * @generated from protobuf field: string target_sc_address = 1;
+ */
+ targetScAddress: string;
+ /**
+ * The name of the function to check the existance of
+ *
+ * @generated from protobuf field: string function_name = 2;
+ */
+ functionName: string;
+}
+/**
+ * Function exists result
+ *
+ * @generated from protobuf message massa.abi.v1.FunctionExistsResult
+ */
+export interface FunctionExistsResult {
+ /**
+ * Exists is true if the function exists
+ *
+ * @generated from protobuf field: bool exists = 1;
+ */
+ exists: boolean;
+}
+// Message returned in case of success of an ABI call.
+// See the documentation of the specific result for the meaning of the fields.
+// Call RespResult because Result will conflict with the Result type in Rust
+// data MUST have the same name as they type in Rust they are converted to type
+
+/**
+ * Tips to check for completeness exec:
+ * `rg message | rg "\{" | rg "Result" | wc -l`
+ * the given count should be equal to the number of messages in RespResult + 1
+ * the +1 comes from ResResult itself which is counted above
+ *
+ * @generated from protobuf message massa.abi.v1.RespResult
+ */
+export interface RespResult {
+ /**
+ * @generated from protobuf oneof: res
+ */
+ res:
+ | {
+ oneofKind: 'addNativeAmountResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.AddNativeAmountResult add_native_amount_result = 1;
+ */
+ addNativeAmountResult: AddNativeAmountResult;
+ }
+ | {
+ oneofKind: 'addressFromPubKeyResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.AddressFromPubKeyResult address_from_pub_key_result = 2;
+ */
+ addressFromPubKeyResult: AddressFromPubKeyResult;
+ }
+ | {
+ oneofKind: 'appendDsValueResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.AppendDsValueResult append_ds_value_result = 3;
+ */
+ appendDsValueResult: AppendDsValueResult;
+ }
+ | {
+ oneofKind: 'base58CheckToBytesResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.Base58CheckToBytesResult base58_check_to_bytes_result = 4;
+ */
+ base58CheckToBytesResult: Base58CheckToBytesResult;
+ }
+ | {
+ oneofKind: 'bytesToBase58CheckResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.BytesToBase58CheckResult bytes_to_base58_check_result = 5;
+ */
+ bytesToBase58CheckResult: BytesToBase58CheckResult;
+ }
+ | {
+ oneofKind: 'callerHasWriteAccessResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.CallerHasWriteAccessResult caller_has_write_access_result = 6;
+ */
+ callerHasWriteAccessResult: CallerHasWriteAccessResult;
+ }
+ | {
+ oneofKind: 'checkAddressResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.CheckAddressResult check_address_result = 7;
+ */
+ checkAddressResult: CheckAddressResult;
+ }
+ | {
+ oneofKind: 'checkNativeAmountResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.CheckNativeAmountResult check_native_amount_result = 8;
+ */
+ checkNativeAmountResult: CheckNativeAmountResult;
+ }
+ | {
+ oneofKind: 'checkPubKeyResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.CheckPubKeyResult check_pub_key_result = 9;
+ */
+ checkPubKeyResult: CheckPubKeyResult;
+ }
+ | {
+ oneofKind: 'checkSigResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.CheckSigResult check_sig_result = 10;
+ */
+ checkSigResult: CheckSigResult;
+ }
+ | {
+ oneofKind: 'checkedAddNativeTimeResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.CheckedAddNativeTimeResult checked_add_native_time_result = 11;
+ */
+ checkedAddNativeTimeResult: CheckedAddNativeTimeResult;
+ }
+ | {
+ oneofKind: 'checkedDivRemNativeTimeResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.CheckedDivRemNativeTimeResult checked_div_rem_native_time_result = 12;
+ */
+ checkedDivRemNativeTimeResult: CheckedDivRemNativeTimeResult;
+ }
+ | {
+ oneofKind: 'checkedScalarDivRemNativeTimeResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.CheckedScalarDivRemNativeTimeResult checked_scalar_div_rem_native_time_result = 13;
+ */
+ checkedScalarDivRemNativeTimeResult: CheckedScalarDivRemNativeTimeResult;
+ }
+ | {
+ oneofKind: 'checkedScalarMulNativeTimeResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.CheckedScalarMulNativeTimeResult checked_scalar_mul_native_time_result = 14;
+ */
+ checkedScalarMulNativeTimeResult: CheckedScalarMulNativeTimeResult;
+ }
+ | {
+ oneofKind: 'checkedSubNativeTimeResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.CheckedSubNativeTimeResult checked_sub_native_time_result = 15;
+ */
+ checkedSubNativeTimeResult: CheckedSubNativeTimeResult;
+ }
+ | {
+ oneofKind: 'compareAddressResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.CompareAddressResult compare_address_result = 16;
+ */
+ compareAddressResult: CompareAddressResult;
+ }
+ | {
+ oneofKind: 'compareNativeAmountResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.CompareNativeAmountResult compare_native_amount_result = 17;
+ */
+ compareNativeAmountResult: CompareNativeAmountResult;
+ }
+ | {
+ oneofKind: 'compareNativeTimeResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.CompareNativeTimeResult compare_native_time_result = 18;
+ */
+ compareNativeTimeResult: CompareNativeTimeResult;
+ }
+ | {
+ oneofKind: 'comparePubKeyResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.ComparePubKeyResult compare_pub_key_result = 19;
+ */
+ comparePubKeyResult: ComparePubKeyResult;
+ }
+ | {
+ oneofKind: 'createScResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.CreateScResult create_sc_result = 20;
+ */
+ createScResult: CreateScResult;
+ }
+ | {
+ oneofKind: 'deleteDsEntryResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.DeleteDsEntryResult delete_ds_entry_result = 21;
+ */
+ deleteDsEntryResult: DeleteDsEntryResult;
+ }
+ | {
+ oneofKind: 'divRemNativeAmountResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.DivRemNativeAmountResult div_rem_native_amount_result = 22;
+ */
+ divRemNativeAmountResult: DivRemNativeAmountResult;
+ }
+ | {
+ oneofKind: 'dsEntryExistsResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.DsEntryExistsResult ds_entry_exists_result = 23;
+ */
+ dsEntryExistsResult: DsEntryExistsResult;
+ }
+ | {
+ oneofKind: 'functionExistsResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.FunctionExistsResult function_exists_result = 24;
+ */
+ functionExistsResult: FunctionExistsResult;
+ }
+ | {
+ oneofKind: 'generateEventResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GenerateEventResult generate_event_result = 25;
+ */
+ generateEventResult: GenerateEventResult;
+ }
+ | {
+ oneofKind: 'getAddressCategoryResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetAddressCategoryResult get_address_category_result = 26;
+ */
+ getAddressCategoryResult: GetAddressCategoryResult;
+ }
+ | {
+ oneofKind: 'getAddressVersionResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetAddressVersionResult get_address_version_result = 27;
+ */
+ getAddressVersionResult: GetAddressVersionResult;
+ }
+ | {
+ oneofKind: 'getBalanceResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetBalanceResult get_balance_result = 28;
+ */
+ getBalanceResult: GetBalanceResult;
+ }
+ | {
+ oneofKind: 'getBytecodeResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetBytecodeResult get_bytecode_result = 29;
+ */
+ getBytecodeResult: GetBytecodeResult;
+ }
+ | {
+ oneofKind: 'getCallCoinsResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetCallCoinsResult get_call_coins_result = 30;
+ */
+ getCallCoinsResult: GetCallCoinsResult;
+ }
+ | {
+ oneofKind: 'getCallStackResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetCallStackResult get_call_stack_result = 31;
+ */
+ getCallStackResult: GetCallStackResult;
+ }
+ | {
+ oneofKind: 'getCurrentSlotResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetCurrentSlotResult get_current_slot_result = 32;
+ */
+ getCurrentSlotResult: GetCurrentSlotResult;
+ }
+ | {
+ oneofKind: 'getDsKeysResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetDsKeysResult get_ds_keys_result = 33;
+ */
+ getDsKeysResult: GetDsKeysResult;
+ }
+ | {
+ oneofKind: 'getDsValueResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetDsValueResult get_ds_value_result = 34;
+ */
+ getDsValueResult: GetDsValueResult;
+ }
+ | {
+ oneofKind: 'getNativeTimeResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetNativeTimeResult get_native_time_result = 35;
+ */
+ getNativeTimeResult: GetNativeTimeResult;
+ }
+ | {
+ oneofKind: 'getOpDataResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetOpDataResult get_op_data_result = 36;
+ */
+ getOpDataResult: GetOpDataResult;
+ }
+ | {
+ oneofKind: 'getOpKeysResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetOpKeysResult get_op_keys_result = 37;
+ */
+ getOpKeysResult: GetOpKeysResult;
+ }
+ | {
+ oneofKind: 'getOriginOperationIdResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetOriginOperationIdResult get_origin_operation_id_result = 38;
+ */
+ getOriginOperationIdResult: GetOriginOperationIdResult;
+ }
+ | {
+ oneofKind: 'getOwnedAddressesResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetOwnedAddressesResult get_owned_addresses_result = 39;
+ */
+ getOwnedAddressesResult: GetOwnedAddressesResult;
+ }
+ | {
+ oneofKind: 'getPubKeyVersionResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetPubKeyVersionResult get_pub_key_version_result = 40;
+ */
+ getPubKeyVersionResult: GetPubKeyVersionResult;
+ }
+ | {
+ oneofKind: 'getRemainingGasResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetRemainingGasResult get_remaining_gas_result = 41;
+ */
+ getRemainingGasResult: GetRemainingGasResult;
+ }
+ | {
+ oneofKind: 'getSignatureVersionResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.GetSignatureVersionResult get_signature_version_result = 42;
+ */
+ getSignatureVersionResult: GetSignatureVersionResult;
+ }
+ | {
+ oneofKind: 'hashBlake3Result';
+ /**
+ * @generated from protobuf field: massa.abi.v1.HashBlake3Result hash_blake3_result = 43;
+ */
+ hashBlake3Result: HashBlake3Result;
+ }
+ | {
+ oneofKind: 'hashSha256Result';
+ /**
+ * @generated from protobuf field: massa.abi.v1.HashSha256Result hash_sha256_result = 44;
+ */
+ hashSha256Result: HashSha256Result;
+ }
+ | {
+ oneofKind: 'opEntryExistsResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.OpEntryExistsResult op_entry_exists_result = 45;
+ */
+ opEntryExistsResult: OpEntryExistsResult;
+ }
+ | {
+ oneofKind: 'keccak256Result';
+ /**
+ * @generated from protobuf field: massa.abi.v1.Keccak256Result keccak256_result = 46;
+ */
+ keccak256Result: Keccak256Result;
+ }
+ | {
+ oneofKind: 'localExecutionResponse';
+ /**
+ * @generated from protobuf field: massa.abi.v1.LocalExecutionResponse local_execution_response = 47;
+ */
+ localExecutionResponse: LocalExecutionResponse;
+ }
+ | {
+ oneofKind: 'nativeAmountFromStringResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.NativeAmountFromStringResult native_amount_from_string_result = 48;
+ */
+ nativeAmountFromStringResult: NativeAmountFromStringResult;
+ }
+ | {
+ oneofKind: 'nativeAmountToStringResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.NativeAmountToStringResult native_amount_to_string_result = 49;
+ */
+ nativeAmountToStringResult: NativeAmountToStringResult;
+ }
+ | {
+ oneofKind: 'scalarDivRemNativeAmountResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.ScalarDivRemNativeAmountResult scalar_div_rem_native_amount_result = 50;
+ */
+ scalarDivRemNativeAmountResult: ScalarDivRemNativeAmountResult;
+ }
+ | {
+ oneofKind: 'scalarMulNativeAmountResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.ScalarMulNativeAmountResult scalar_mul_native_amount_result = 51;
+ */
+ scalarMulNativeAmountResult: ScalarMulNativeAmountResult;
+ }
+ | {
+ oneofKind: 'sendAsyncMessageResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.SendAsyncMessageResult send_async_message_result = 52;
+ */
+ sendAsyncMessageResult: SendAsyncMessageResult;
+ }
+ | {
+ oneofKind: 'setBytecodeResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.SetBytecodeResult set_bytecode_result = 53;
+ */
+ setBytecodeResult: SetBytecodeResult;
+ }
+ | {
+ oneofKind: 'setDsValueResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.SetDsValueResult set_ds_value_result = 54;
+ */
+ setDsValueResult: SetDsValueResult;
+ }
+ | {
+ oneofKind: 'subNativeAmountResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.SubNativeAmountResult sub_native_amount_result = 55;
+ */
+ subNativeAmountResult: SubNativeAmountResult;
+ }
+ | {
+ oneofKind: 'transferCoinsResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.TransferCoinsResult transfer_coins_result = 56;
+ */
+ transferCoinsResult: TransferCoinsResult;
+ }
+ | {
+ oneofKind: 'unsafeRandomResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.UnsafeRandomResult unsafe_random_result = 57;
+ */
+ unsafeRandomResult: UnsafeRandomResult;
+ }
+ | {
+ oneofKind: 'evmVerifySigResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.EvmVerifySigResult evm_verify_sig_result = 58;
+ */
+ evmVerifySigResult: EvmVerifySigResult;
+ }
+ | {
+ oneofKind: 'verifySigResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.VerifySigResult verify_sig_result = 59;
+ */
+ verifySigResult: VerifySigResult;
+ }
+ | {
+ oneofKind: 'evmGetAddressFromPubkeyResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.EvmGetAddressFromPubkeyResult evm_get_address_from_pubkey_result = 60;
+ */
+ evmGetAddressFromPubkeyResult: EvmGetAddressFromPubkeyResult;
+ }
+ | {
+ oneofKind: 'evmGetPubkeyFromSignatureResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.EvmGetPubkeyFromSignatureResult evm_get_pubkey_from_signature_result = 61;
+ */
+ evmGetPubkeyFromSignatureResult: EvmGetPubkeyFromSignatureResult;
+ }
+ | {
+ oneofKind: 'isAddressEoaResult';
+ /**
+ * @generated from protobuf field: massa.abi.v1.IsAddressEoaResult is_address_eoa_result = 62;
+ */
+ isAddressEoaResult: IsAddressEoaResult;
+ }
+ | {
+ oneofKind: undefined;
+ };
+}
+/**
+ * Generic message that encapsulate response from ABI calls.
+ *
+ * @generated from protobuf message massa.abi.v1.AbiResponse
+ */
+export interface AbiResponse {
+ /**
+ * @generated from protobuf oneof: resp
+ */
+ resp:
+ | {
+ oneofKind: 'res';
+ /**
+ * variant for success
+ *
+ * @generated from protobuf field: massa.abi.v1.RespResult res = 1;
+ */
+ res: RespResult;
+ }
+ | {
+ oneofKind: 'error';
+ /**
+ * variant for error
+ *
+ * @generated from protobuf field: massa.abi.v1.Error error = 2;
+ */
+ error: Error;
+ }
+ | {
+ oneofKind: undefined;
+ };
+}
+/**
+ * Amount to string request
+ *
+ * @generated from protobuf message massa.abi.v1.NativeAmountToStringRequest
+ */
+export interface NativeAmountToStringRequest {
+ /**
+ * Amount to convert to string
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount to_convert = 1;
+ */
+ toConvert?: NativeAmount;
+}
+/**
+ * Amount to string result
+ *
+ * @generated from protobuf message massa.abi.v1.NativeAmountToStringResult
+ */
+export interface NativeAmountToStringResult {
+ /**
+ * Converted Amount
+ *
+ * @generated from protobuf field: string converted_amount = 1;
+ */
+ convertedAmount: string;
+}
+/**
+ * Amount from string request
+ *
+ * @generated from protobuf message massa.abi.v1.NativeAmountFromStringRequest
+ */
+export interface NativeAmountFromStringRequest {
+ /**
+ * String to convert to Amount
+ *
+ * @generated from protobuf field: string to_convert = 1;
+ */
+ toConvert: string;
+}
+/**
+ * Amount from string result
+ *
+ * @generated from protobuf message massa.abi.v1.NativeAmountFromStringResult
+ */
+export interface NativeAmountFromStringResult {
+ /**
+ * Converted Amount
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount converted_amount = 1;
+ */
+ convertedAmount?: NativeAmount;
+}
+/**
+ * Check address request
+ *
+ * @generated from protobuf message massa.abi.v1.CheckAddressRequest
+ */
+export interface CheckAddressRequest {
+ /**
+ * Address to check
+ *
+ * @generated from protobuf field: string to_check = 1;
+ */
+ toCheck: string;
+}
+/**
+ * Check address result
+ *
+ * @generated from protobuf message massa.abi.v1.CheckAddressResult
+ */
+export interface CheckAddressResult {
+ /**
+ * Is address valid
+ *
+ * @generated from protobuf field: bool is_valid = 1;
+ */
+ isValid: boolean;
+}
+/**
+ * Check PubKey request
+ *
+ * @generated from protobuf message massa.abi.v1.CheckPubKeyRequest
+ */
+export interface CheckPubKeyRequest {
+ /**
+ * PubKey to check
+ *
+ * @generated from protobuf field: string to_check = 1;
+ */
+ toCheck: string;
+}
+/**
+ * Check PubKey result
+ *
+ * @generated from protobuf message massa.abi.v1.CheckPubKeyResult
+ */
+export interface CheckPubKeyResult {
+ /**
+ * Is PubKey valid
+ *
+ * @generated from protobuf field: bool is_valid = 1;
+ */
+ isValid: boolean;
+}
+/**
+ * Check Sig request
+ *
+ * @generated from protobuf message massa.abi.v1.CheckSigRequest
+ */
+export interface CheckSigRequest {
+ /**
+ * Sig to check
+ *
+ * @generated from protobuf field: string to_check = 1;
+ */
+ toCheck: string;
+}
+/**
+ * Check Sig result
+ *
+ * @generated from protobuf message massa.abi.v1.CheckSigResult
+ */
+export interface CheckSigResult {
+ /**
+ * Is Sig valid
+ *
+ * @generated from protobuf field: bool is_valid = 1;
+ */
+ isValid: boolean;
+}
+/**
+ * Check Amount request
+ *
+ * @generated from protobuf message massa.abi.v1.CheckNativeAmountRequest
+ */
+export interface CheckNativeAmountRequest {
+ /**
+ * Amount to check
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount to_check = 1;
+ */
+ toCheck?: NativeAmount;
+}
+/**
+ * Check Amount result
+ *
+ * @generated from protobuf message massa.abi.v1.CheckNativeAmountResult
+ */
+export interface CheckNativeAmountResult {
+ /**
+ * Is Amount valid
+ *
+ * @generated from protobuf field: bool is_valid = 1;
+ */
+ isValid: boolean;
+}
+/**
+ * Amount addition request
+ *
+ * @generated from protobuf message massa.abi.v1.AddNativeAmountRequest
+ */
+export interface AddNativeAmountRequest {
+ /**
+ * First amount to add
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount amount1 = 1;
+ */
+ amount1?: NativeAmount;
+ /**
+ * Second amount to add
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount amount2 = 2;
+ */
+ amount2?: NativeAmount;
+}
+/**
+ * Amount addition result
+ *
+ * @generated from protobuf message massa.abi.v1.AddNativeAmountResult
+ */
+export interface AddNativeAmountResult {
+ /**
+ * Sum of amounts
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount sum = 1;
+ */
+ sum?: NativeAmount;
+}
+/**
+ * Amount subtraction request
+ * try to compute difference = left - right
+ * fails if right > left
+ *
+ * @generated from protobuf message massa.abi.v1.SubNativeAmountRequest
+ */
+export interface SubNativeAmountRequest {
+ /**
+ * First amount to subtract from
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount left = 1;
+ */
+ left?: NativeAmount;
+ /**
+ * Second amount to subtract
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount right = 2;
+ */
+ right?: NativeAmount;
+}
+/**
+ * Amount subtraction result
+ *
+ * @generated from protobuf message massa.abi.v1.SubNativeAmountResult
+ */
+export interface SubNativeAmountResult {
+ /**
+ * Difference of amounts (left - right)
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount difference = 1;
+ */
+ difference?: NativeAmount;
+}
+/**
+ * Amount multiplication request
+ * Try to compute product = amount * coefficient (fail if overflow)
+ *
+ * @generated from protobuf message massa.abi.v1.ScalarMulNativeAmountRequest
+ */
+export interface ScalarMulNativeAmountRequest {
+ /**
+ * Amount to multiply
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount amount = 1;
+ */
+ amount?: NativeAmount;
+ /**
+ * Coefficient to multiply by
+ *
+ * @generated from protobuf field: uint64 coefficient = 2;
+ */
+ coefficient: bigint;
+}
+/**
+ * Amount multiplication result
+ *
+ * @generated from protobuf message massa.abi.v1.ScalarMulNativeAmountResult
+ */
+export interface ScalarMulNativeAmountResult {
+ /**
+ * Product of amount and coefficient
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount product = 1;
+ */
+ product?: NativeAmount;
+}
+/**
+ * Amount division by scalar request
+ * Try to compute quotient = dividend / divisor
+ * Fails if divisor == 0
+ * Fails if underflow
+ *
+ * @generated from protobuf message massa.abi.v1.ScalarDivRemNativeAmountRequest
+ */
+export interface ScalarDivRemNativeAmountRequest {
+ /**
+ * Amount to divide
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount dividend = 1;
+ */
+ dividend?: NativeAmount;
+ /**
+ * Divisor to divide by
+ *
+ * @generated from protobuf field: uint64 divisor = 2;
+ */
+ divisor: bigint;
+}
+/**
+ * Amount division by scalar result
+ *
+ * @generated from protobuf message massa.abi.v1.ScalarDivRemNativeAmountResult
+ */
+export interface ScalarDivRemNativeAmountResult {
+ /**
+ * Quotient of amount and divisor
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount quotient = 1;
+ */
+ quotient?: NativeAmount;
+ /**
+ * Remainder of amount and divisor
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount remainder = 2;
+ */
+ remainder?: NativeAmount;
+}
+/**
+ * Amount division request
+ *
+ * @generated from protobuf message massa.abi.v1.DivRemNativeAmountRequest
+ */
+export interface DivRemNativeAmountRequest {
+ /**
+ * Amount to divide
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount dividend = 1;
+ */
+ dividend?: NativeAmount;
+ /**
+ * Divisor to divide by
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount divisor = 2;
+ */
+ divisor?: NativeAmount;
+}
+/**
+ * Amount division result
+ *
+ * @generated from protobuf message massa.abi.v1.DivRemNativeAmountResult
+ */
+export interface DivRemNativeAmountResult {
+ /**
+ * Quotient of amount and divisor
+ *
+ * @generated from protobuf field: uint64 quotient = 1;
+ */
+ quotient: bigint;
+ /**
+ * Remainder of amount and divisor
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount remainder = 2;
+ */
+ remainder?: NativeAmount;
+}
+/**
+ * Time addition checked request
+ *
+ * @generated from protobuf message massa.abi.v1.CheckedAddNativeTimeRequest
+ */
+export interface CheckedAddNativeTimeRequest {
+ /**
+ * First time to add
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime left = 1;
+ */
+ left?: NativeTime;
+ /**
+ * Second time to add
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime right = 2;
+ */
+ right?: NativeTime;
+}
+/**
+ * Time addition checked result
+ *
+ * @generated from protobuf message massa.abi.v1.CheckedAddNativeTimeResult
+ */
+export interface CheckedAddNativeTimeResult {
+ /**
+ * Sum of times
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime sum = 1;
+ */
+ sum?: NativeTime;
+}
+/**
+ * Time subtraction checked request
+ *
+ * @generated from protobuf message massa.abi.v1.CheckedSubNativeTimeRequest
+ */
+export interface CheckedSubNativeTimeRequest {
+ /**
+ * First time to subtract from
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime left = 1;
+ */
+ left?: NativeTime;
+ /**
+ * Second time to subtract
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime right = 2;
+ */
+ right?: NativeTime;
+}
+/**
+ * Time subtraction checked result
+ *
+ * @generated from protobuf message massa.abi.v1.CheckedSubNativeTimeResult
+ */
+export interface CheckedSubNativeTimeResult {
+ /**
+ * Difference of times (left - right)
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime difference = 1;
+ */
+ difference?: NativeTime;
+}
+/**
+ * Time scalar mult checked request
+ *
+ * @generated from protobuf message massa.abi.v1.CheckedScalarMulNativeTimeRequest
+ */
+export interface CheckedScalarMulNativeTimeRequest {
+ /**
+ * Time to multiply
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime time = 1;
+ */
+ time?: NativeTime;
+ /**
+ * Coefficient to multiply by
+ *
+ * @generated from protobuf field: uint64 coefficient = 2;
+ */
+ coefficient: bigint;
+}
+/**
+ * Time scalar mult checked result
+ *
+ * @generated from protobuf message massa.abi.v1.CheckedScalarMulNativeTimeResult
+ */
+export interface CheckedScalarMulNativeTimeResult {
+ /**
+ * Product of time and coefficient
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime product = 1;
+ */
+ product?: NativeTime;
+}
+/**
+ * Time scalar divrem checked request
+ *
+ * @generated from protobuf message massa.abi.v1.CheckedScalarDivRemNativeTimeRequest
+ */
+export interface CheckedScalarDivRemNativeTimeRequest {
+ /**
+ * Time to divide
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime dividend = 1;
+ */
+ dividend?: NativeTime;
+ /**
+ * Divisor to divide by
+ *
+ * @generated from protobuf field: uint64 divisor = 2;
+ */
+ divisor: bigint;
+}
+/**
+ * Time scalar divrem checked result
+ *
+ * @generated from protobuf message massa.abi.v1.CheckedScalarDivRemNativeTimeResult
+ */
+export interface CheckedScalarDivRemNativeTimeResult {
+ /**
+ * Quotient of time and divisor
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime quotient = 1;
+ */
+ quotient?: NativeTime;
+ /**
+ * Remainder of time and divisor
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime remainder = 2;
+ */
+ remainder?: NativeTime;
+}
+/**
+ * Time division checked request
+ *
+ * @generated from protobuf message massa.abi.v1.CheckedDivRemNativeTimeRequest
+ */
+export interface CheckedDivRemNativeTimeRequest {
+ /**
+ * Time to divide
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime dividend = 1;
+ */
+ dividend?: NativeTime;
+ /**
+ * Divisor to divide by
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime divisor = 2;
+ */
+ divisor?: NativeTime;
+}
+/**
+ * Time division checked result
+ *
+ * @generated from protobuf message massa.abi.v1.CheckedDivRemNativeTimeResult
+ */
+export interface CheckedDivRemNativeTimeResult {
+ /**
+ * Quotient of time and divisor
+ *
+ * @generated from protobuf field: uint64 quotient = 1;
+ */
+ quotient: bigint;
+ /**
+ * Remainder of time and divisor
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime remainder = 2;
+ */
+ remainder?: NativeTime;
+}
+/**
+ * Time comparison request
+ *
+ * @generated from protobuf message massa.abi.v1.CompareNativeTimeRequest
+ */
+export interface CompareNativeTimeRequest {
+ /**
+ * First time to compare
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime left = 1;
+ */
+ left?: NativeTime;
+ /**
+ * Second time to compare
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime right = 2;
+ */
+ right?: NativeTime;
+}
+/**
+ * Time comparison result
+ *
+ * @generated from protobuf message massa.abi.v1.CompareNativeTimeResult
+ */
+export interface CompareNativeTimeResult {
+ /**
+ * Comparison result
+ *
+ * @generated from protobuf field: massa.model.v1.ComparisonResult result = 1;
+ */
+ result: ComparisonResult;
+}
+/**
+ * Compare Address request
+ *
+ * @generated from protobuf message massa.abi.v1.CompareAddressRequest
+ */
+export interface CompareAddressRequest {
+ /**
+ * First address to compare
+ *
+ * @generated from protobuf field: string left = 1;
+ */
+ left: string;
+ /**
+ * Second address to compare
+ *
+ * @generated from protobuf field: string right = 2;
+ */
+ right: string;
+}
+/**
+ * Compare Address result
+ *
+ * @generated from protobuf message massa.abi.v1.CompareAddressResult
+ */
+export interface CompareAddressResult {
+ /**
+ * Comparison result
+ *
+ * @generated from protobuf field: massa.model.v1.ComparisonResult result = 1;
+ */
+ result: ComparisonResult;
+}
+/**
+ * Compare PubKey request
+ *
+ * @generated from protobuf message massa.abi.v1.ComparePubKeyRequest
+ */
+export interface ComparePubKeyRequest {
+ /**
+ * First public key to compare
+ *
+ * @generated from protobuf field: string left = 1;
+ */
+ left: string;
+ /**
+ * Second public key to compare
+ *
+ * @generated from protobuf field: string right = 2;
+ */
+ right: string;
+}
+/**
+ * Compare PubKey result
+ *
+ * @generated from protobuf message massa.abi.v1.ComparePubKeyResult
+ */
+export interface ComparePubKeyResult {
+ /**
+ * Comparison result
+ *
+ * @generated from protobuf field: massa.model.v1.ComparisonResult result = 1;
+ */
+ result: ComparisonResult;
+}
+/**
+ * Verify Sig request
+ *
+ * @generated from protobuf message massa.abi.v1.VerifySigRequest
+ */
+export interface VerifySigRequest {
+ /**
+ * Signature to verify
+ *
+ * @generated from protobuf field: string sig = 1;
+ */
+ sig: string;
+ /**
+ * Message to verify
+ *
+ * @generated from protobuf field: bytes message = 2;
+ */
+ message: Uint8Array;
+ /**
+ * Public key to verify with
+ *
+ * @generated from protobuf field: string pub_key = 3;
+ */
+ pubKey: string;
+}
+/**
+ * Verify Sig result
+ *
+ * @generated from protobuf message massa.abi.v1.VerifySigResult
+ */
+export interface VerifySigResult {
+ /**
+ * Verification result
+ *
+ * @generated from protobuf field: bool is_verified = 1;
+ */
+ isVerified: boolean;
+}
+/**
+ * Compare NativeAmount request
+ *
+ * @generated from protobuf message massa.abi.v1.CompareNativeAmountRequest
+ */
+export interface CompareNativeAmountRequest {
+ /**
+ * First amount to compare
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount left = 1;
+ */
+ left?: NativeAmount;
+ /**
+ * Second amount to compare
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount right = 2;
+ */
+ right?: NativeAmount;
+}
+/**
+ * Compare NativeAmount result
+ *
+ * @generated from protobuf message massa.abi.v1.CompareNativeAmountResult
+ */
+export interface CompareNativeAmountResult {
+ /**
+ * Comparison result
+ *
+ * @generated from protobuf field: massa.model.v1.ComparisonResult result = 1;
+ */
+ result: ComparisonResult;
+}
+/**
+ * Keccak256 hash request
+ *
+ * @generated from protobuf message massa.abi.v1.Keccak256Request
+ */
+export interface Keccak256Request {
+ /**
+ * Data to hash
+ *
+ * @generated from protobuf field: bytes data = 1;
+ */
+ data: Uint8Array;
+}
+/**
+ * Keccak256 hash result
+ *
+ * @generated from protobuf message massa.abi.v1.Keccak256Result
+ */
+export interface Keccak256Result {
+ /**
+ * Hash of data
+ *
+ * @generated from protobuf field: bytes hash = 1;
+ */
+ hash: Uint8Array;
+}
+/**
+ * EVM signature verification request
+ *
+ * @generated from protobuf message massa.abi.v1.EvmVerifySigRequest
+ */
+export interface EvmVerifySigRequest {
+ /**
+ * Signature to verify
+ *
+ * @generated from protobuf field: bytes sig = 1;
+ */
+ sig: Uint8Array;
+ /**
+ * Message to verify
+ *
+ * @generated from protobuf field: bytes message = 2;
+ */
+ message: Uint8Array;
+ /**
+ * Public key to verify with
+ *
+ * @generated from protobuf field: bytes pub_key = 3;
+ */
+ pubKey: Uint8Array;
+}
+/**
+ * EVM signature verification result
+ *
+ * @generated from protobuf message massa.abi.v1.EvmVerifySigResult
+ */
+export interface EvmVerifySigResult {
+ /**
+ * Verification result
+ *
+ * @generated from protobuf field: bool is_verified = 1;
+ */
+ isVerified: boolean;
+}
+/**
+ * EVM get address from public key request
+ *
+ * @generated from protobuf message massa.abi.v1.EvmGetAddressFromPubkeyRequest
+ */
+export interface EvmGetAddressFromPubkeyRequest {
+ /**
+ * Public key to get address from
+ *
+ * @generated from protobuf field: bytes pub_key = 1;
+ */
+ pubKey: Uint8Array;
+}
+/**
+ * EVM get address from public key result
+ *
+ * @generated from protobuf message massa.abi.v1.EvmGetAddressFromPubkeyResult
+ */
+export interface EvmGetAddressFromPubkeyResult {
+ /**
+ * Address
+ *
+ * @generated from protobuf field: bytes address = 1;
+ */
+ address: Uint8Array;
+}
+/**
+ * EVM get public key from signature request
+ *
+ * @generated from protobuf message massa.abi.v1.EvmGetPubkeyFromSignatureRequest
+ */
+export interface EvmGetPubkeyFromSignatureRequest {
+ /**
+ * Signed hash to verify
+ *
+ * @generated from protobuf field: bytes hash = 1;
+ */
+ hash: Uint8Array;
+ /**
+ * Signature to verify
+ *
+ * @generated from protobuf field: bytes sig = 2;
+ */
+ sig: Uint8Array;
+}
+/**
+ * EVM get public key from signature result
+ *
+ * @generated from protobuf message massa.abi.v1.EvmGetPubkeyFromSignatureResult
+ */
+export interface EvmGetPubkeyFromSignatureResult {
+ /**
+ * Public key
+ *
+ * @generated from protobuf field: bytes pub_key = 1;
+ */
+ pubKey: Uint8Array;
+}
+/**
+ * Is address EOA request
+ *
+ * @generated from protobuf message massa.abi.v1.IsAddressEoaRequest
+ */
+export interface IsAddressEoaRequest {
+ /**
+ * Address to check
+ *
+ * @generated from protobuf field: string address = 1;
+ */
+ address: string;
+}
+/**
+ * Is address EOA result
+ *
+ * @generated from protobuf message massa.abi.v1.IsAddressEoaResult
+ */
+export interface IsAddressEoaResult {
+ /**
+ * Is address EOA
+ *
+ * @generated from protobuf field: bool is_eoa = 1;
+ */
+ isEoa: boolean;
+}
+/**
+ * Blake3 hash request
+ *
+ * @generated from protobuf message massa.abi.v1.HashBlake3Request
+ */
+export interface HashBlake3Request {
+ /**
+ * Data to hash
+ *
+ * @generated from protobuf field: bytes data = 1;
+ */
+ data: Uint8Array;
+}
+/**
+ * Blake3 hash result
+ *
+ * @generated from protobuf message massa.abi.v1.HashBlake3Result
+ */
+export interface HashBlake3Result {
+ /**
+ * Hash of data
+ *
+ * @generated from protobuf field: bytes hash = 1;
+ */
+ hash: Uint8Array;
+}
+/**
+ * Get keys request
+ *
+ * @generated from protobuf message massa.abi.v1.GetDsKeysRequest
+ */
+export interface GetDsKeysRequest {
+ /**
+ * keys prefix
+ *
+ * @generated from protobuf field: bytes prefix = 1;
+ */
+ prefix: Uint8Array;
+ /**
+ * Address to get keys for
+ *
+ * @generated from protobuf field: optional google.protobuf.StringValue address = 2;
+ */
+ address?: StringValue;
+}
+/**
+ * Get keys result
+ *
+ * @generated from protobuf message massa.abi.v1.GetDsKeysResult
+ */
+export interface GetDsKeysResult {
+ /**
+ * keys
+ *
+ * @generated from protobuf field: repeated bytes keys = 1;
+ */
+ keys: Uint8Array[];
+}
+/**
+ * Set data store value request
+ *
+ * @generated from protobuf message massa.abi.v1.SetDsValueRequest
+ */
+export interface SetDsValueRequest {
+ /**
+ * key
+ *
+ * @generated from protobuf field: bytes key = 1;
+ */
+ key: Uint8Array;
+ /**
+ * value
+ *
+ * @generated from protobuf field: bytes value = 2;
+ */
+ value: Uint8Array;
+ /**
+ * Address to set data for, if none, use current address
+ *
+ * @generated from protobuf field: optional google.protobuf.StringValue address = 3;
+ */
+ address?: StringValue;
+}
+/**
+ * Set data store value result
+ *
+ * @generated from protobuf message massa.abi.v1.SetDsValueResult
+ */
+export interface SetDsValueResult {}
+/**
+ * Append data request
+ *
+ * @generated from protobuf message massa.abi.v1.AppendDsValueRequest
+ */
+export interface AppendDsValueRequest {
+ /**
+ * key
+ *
+ * @generated from protobuf field: bytes key = 1;
+ */
+ key: Uint8Array;
+ /**
+ * value
+ *
+ * @generated from protobuf field: bytes value = 2;
+ */
+ value: Uint8Array;
+ /**
+ * Address to append data for, if none, use current address
+ *
+ * @generated from protobuf field: optional google.protobuf.StringValue address = 3;
+ */
+ address?: StringValue;
+}
+/**
+ * Append data result
+ *
+ * @generated from protobuf message massa.abi.v1.AppendDsValueResult
+ */
+export interface AppendDsValueResult {}
+/**
+ * Get data request
+ *
+ * @generated from protobuf message massa.abi.v1.GetDsValueRequest
+ */
+export interface GetDsValueRequest {
+ /**
+ * key
+ *
+ * @generated from protobuf field: bytes key = 1;
+ */
+ key: Uint8Array;
+ /**
+ * Address to get data for, if none, use current address
+ *
+ * @generated from protobuf field: optional google.protobuf.StringValue address = 2;
+ */
+ address?: StringValue;
+}
+/**
+ * Get data result
+ *
+ * @generated from protobuf message massa.abi.v1.GetDsValueResult
+ */
+export interface GetDsValueResult {
+ /**
+ * value
+ *
+ * @generated from protobuf field: bytes value = 1;
+ */
+ value: Uint8Array;
+}
+/**
+ * Delete data store entry request
+ *
+ * @generated from protobuf message massa.abi.v1.DeleteDsEntryRequest
+ */
+export interface DeleteDsEntryRequest {
+ /**
+ * key
+ *
+ * @generated from protobuf field: bytes key = 1;
+ */
+ key: Uint8Array;
+ /**
+ * Address to delete data for, if none, use current address
+ *
+ * @generated from protobuf field: optional google.protobuf.StringValue address = 2;
+ */
+ address?: StringValue;
+}
+/**
+ * Delete data store entry result
+ *
+ * @generated from protobuf message massa.abi.v1.DeleteDsEntryResult
+ */
+export interface DeleteDsEntryResult {}
+/**
+ * Data store entry exists request
+ *
+ * @generated from protobuf message massa.abi.v1.DsEntryExistsRequest
+ */
+export interface DsEntryExistsRequest {
+ /**
+ * key
+ *
+ * @generated from protobuf field: bytes key = 1;
+ */
+ key: Uint8Array;
+ /**
+ * Address to check data for, if none, use current address
+ *
+ * @generated from protobuf field: optional google.protobuf.StringValue address = 2;
+ */
+ address?: StringValue;
+}
+/**
+ * Data store entry exists result
+ *
+ * @generated from protobuf message massa.abi.v1.DsEntryExistsResult
+ */
+export interface DsEntryExistsResult {
+ /**
+ * has data
+ *
+ * @generated from protobuf field: bool has_data = 1;
+ */
+ hasData: boolean;
+}
+/**
+ * Get owned addresses request
+ *
+ * @generated from protobuf message massa.abi.v1.GetOwnedAddressesRequest
+ */
+export interface GetOwnedAddressesRequest {}
+/**
+ * Get owned addresses result
+ *
+ * @generated from protobuf message massa.abi.v1.GetOwnedAddressesResult
+ */
+export interface GetOwnedAddressesResult {
+ /**
+ * owned addresses
+ *
+ * @generated from protobuf field: repeated string addresses = 1;
+ */
+ addresses: string[];
+}
+/**
+ * Get call stack request
+ *
+ * @generated from protobuf message massa.abi.v1.GetCallStackRequest
+ */
+export interface GetCallStackRequest {}
+/**
+ * Get call stack result
+ *
+ * @generated from protobuf message massa.abi.v1.GetCallStackResult
+ */
+export interface GetCallStackResult {
+ /**
+ * call stack
+ *
+ * @generated from protobuf field: repeated string calls = 1;
+ */
+ calls: string[];
+}
+/**
+ * Address from public key request
+ *
+ * @generated from protobuf message massa.abi.v1.AddressFromPubKeyRequest
+ */
+export interface AddressFromPubKeyRequest {
+ /**
+ * Native public key
+ *
+ * @generated from protobuf field: string pub_key = 1;
+ */
+ pubKey: string;
+}
+/**
+ * Address from public key result
+ *
+ * @generated from protobuf message massa.abi.v1.AddressFromPubKeyResult
+ */
+export interface AddressFromPubKeyResult {
+ /**
+ * Address
+ *
+ * @generated from protobuf field: string address = 1;
+ */
+ address: string;
+}
+/**
+ * Unsafe random request
+ *
+ * @generated from protobuf message massa.abi.v1.UnsafeRandomRequest
+ */
+export interface UnsafeRandomRequest {
+ /**
+ * @generated from protobuf field: uint32 num_bytes = 2;
+ */
+ numBytes: number;
+}
+/**
+ * Unsafe random result
+ *
+ * @generated from protobuf message massa.abi.v1.UnsafeRandomResult
+ */
+export interface UnsafeRandomResult {
+ /**
+ * Random bytes generated
+ *
+ * @generated from protobuf field: bytes random_bytes = 1;
+ */
+ randomBytes: Uint8Array;
+}
+/**
+ * Send async message request filter
+ *
+ * @generated from protobuf message massa.abi.v1.SendAsyncMessageFilter
+ */
+export interface SendAsyncMessageFilter {
+ /**
+ * Target address
+ *
+ * @generated from protobuf field: string target_address = 1;
+ */
+ targetAddress: string;
+ /**
+ * Target key
+ *
+ * @generated from protobuf field: google.protobuf.BytesValue target_key = 2;
+ */
+ targetKey?: BytesValue;
+}
+/**
+ * Send async message request
+ *
+ * @generated from protobuf message massa.abi.v1.SendAsyncMessageRequest
+ */
+export interface SendAsyncMessageRequest {
+ /**
+ * Target address
+ *
+ * @generated from protobuf field: string target_address = 1;
+ */
+ targetAddress: string;
+ /**
+ * Target handler (function name)
+ *
+ * @generated from protobuf field: string target_handler = 2;
+ */
+ targetHandler: string;
+ /**
+ * Start slot for the message execution
+ *
+ * @generated from protobuf field: massa.model.v1.Slot validity_start = 3;
+ */
+ validityStart?: Slot;
+ /**
+ * End slot for the message execution
+ *
+ * @generated from protobuf field: massa.model.v1.Slot validity_end = 4;
+ */
+ validityEnd?: Slot;
+ /**
+ * Gas given for the execution
+ *
+ * @generated from protobuf field: uint64 execution_gas = 5;
+ */
+ executionGas: bigint;
+ /**
+ * Message fee
+ *
+ * @generated from protobuf field: uint64 raw_fee = 6;
+ */
+ rawFee: bigint;
+ /**
+ * Coins sent to the execution context
+ *
+ * @generated from protobuf field: uint64 raw_coins = 7;
+ */
+ rawCoins: bigint;
+ /**
+ * Message data
+ *
+ * @generated from protobuf field: bytes data = 8;
+ */
+ data: Uint8Array;
+ /**
+ * Filter for the message
+ *
+ * @generated from protobuf field: massa.abi.v1.SendAsyncMessageFilter filter = 9;
+ */
+ filter?: SendAsyncMessageFilter;
+}
+/**
+ * Send async message result
+ *
+ * @generated from protobuf message massa.abi.v1.SendAsyncMessageResult
+ */
+export interface SendAsyncMessageResult {}
+/**
+ * Get origin operation id request
+ *
+ * @generated from protobuf message massa.abi.v1.GetOriginOperationIdRequest
+ */
+export interface GetOriginOperationIdRequest {}
+/**
+ * Get origin operation id result
+ *
+ * @generated from protobuf message massa.abi.v1.GetOriginOperationIdResult
+ */
+export interface GetOriginOperationIdResult {
+ /**
+ * @generated from protobuf field: optional google.protobuf.StringValue operation_id = 1;
+ */
+ operationId?: StringValue;
+}
+/**
+ * Get native time request
+ *
+ * @generated from protobuf message massa.abi.v1.GetNativeTimeRequest
+ */
+export interface GetNativeTimeRequest {}
+/**
+ * Get native time result
+ *
+ * @generated from protobuf message massa.abi.v1.GetNativeTimeResult
+ */
+export interface GetNativeTimeResult {
+ /**
+ * Native time
+ *
+ * @generated from protobuf field: massa.model.v1.NativeTime time = 1;
+ */
+ time?: NativeTime;
+}
+/**
+ * Get current slot request
+ *
+ * @generated from protobuf message massa.abi.v1.GetCurrentSlotRequest
+ */
+export interface GetCurrentSlotRequest {}
+/**
+ * Get current slot result
+ *
+ * @generated from protobuf message massa.abi.v1.GetCurrentSlotResult
+ */
+export interface GetCurrentSlotResult {
+ /**
+ * Current slot
+ *
+ * @generated from protobuf field: massa.model.v1.Slot slot = 1;
+ */
+ slot?: Slot;
+}
+/**
+ * Set bytecode request
+ *
+ * @generated from protobuf message massa.abi.v1.SetBytecodeRequest
+ */
+export interface SetBytecodeRequest {
+ /**
+ * Bytecode
+ *
+ * @generated from protobuf field: bytes bytecode = 1;
+ */
+ bytecode: Uint8Array;
+ /**
+ * Address to set bytecode for, if none, use current address
+ *
+ * @generated from protobuf field: optional google.protobuf.StringValue address = 2;
+ */
+ address?: StringValue;
+}
+/**
+ * Set bytecode result
+ *
+ * @generated from protobuf message massa.abi.v1.SetBytecodeResult
+ */
+export interface SetBytecodeResult {}
+/**
+ * Get bytecode request
+ *
+ * @generated from protobuf message massa.abi.v1.GetBytecodeRequest
+ */
+export interface GetBytecodeRequest {
+ /**
+ * Address to get bytecode for, if none, use current address
+ *
+ * @generated from protobuf field: optional google.protobuf.StringValue address = 1;
+ */
+ address?: StringValue;
+}
+/**
+ * Get bytecode result
+ *
+ * @generated from protobuf message massa.abi.v1.GetBytecodeResult
+ */
+export interface GetBytecodeResult {
+ /**
+ * Bytecode
+ *
+ * @generated from protobuf field: bytes bytecode = 1;
+ */
+ bytecode: Uint8Array;
+}
+/**
+ * Caller has write access request
+ *
+ * @generated from protobuf message massa.abi.v1.CallerHasWriteAccessRequest
+ */
+export interface CallerHasWriteAccessRequest {}
+/**
+ * Caller has write access result
+ *
+ * @generated from protobuf message massa.abi.v1.CallerHasWriteAccessResult
+ */
+export interface CallerHasWriteAccessResult {
+ /**
+ * Caller has write access
+ *
+ * @generated from protobuf field: bool has_write_access = 1;
+ */
+ hasWriteAccess: boolean;
+}
+/**
+ * Hash sha256 request
+ *
+ * @generated from protobuf message massa.abi.v1.HashSha256Request
+ */
+export interface HashSha256Request {
+ /**
+ * data
+ *
+ * @generated from protobuf field: bytes data = 1;
+ */
+ data: Uint8Array;
+}
+/**
+ * Hash sha256 result
+ *
+ * @generated from protobuf message massa.abi.v1.HashSha256Result
+ */
+export interface HashSha256Result {
+ /**
+ * hash
+ *
+ * @generated from protobuf field: bytes hash = 1;
+ */
+ hash: Uint8Array;
+}
+/**
+ * Get op data request
+ *
+ * @generated from protobuf message massa.abi.v1.GetOpDataRequest
+ */
+export interface GetOpDataRequest {
+ /**
+ * key
+ *
+ * @generated from protobuf field: bytes key = 1;
+ */
+ key: Uint8Array;
+}
+/**
+ * Get op data result
+ *
+ * @generated from protobuf message massa.abi.v1.GetOpDataResult
+ */
+export interface GetOpDataResult {
+ /**
+ * value
+ *
+ * @generated from protobuf field: bytes value = 1;
+ */
+ value: Uint8Array;
+}
+/**
+ * Op entry exists request
+ *
+ * @generated from protobuf message massa.abi.v1.OpEntryExistsRequest
+ */
+export interface OpEntryExistsRequest {
+ /**
+ * key
+ *
+ * @generated from protobuf field: bytes key = 1;
+ */
+ key: Uint8Array;
+}
+/**
+ * Op entry exists result
+ *
+ * @generated from protobuf message massa.abi.v1.OpEntryExistsResult
+ */
+export interface OpEntryExistsResult {
+ /**
+ * has key
+ *
+ * @generated from protobuf field: bool has_key = 1;
+ */
+ hasKey: boolean;
+}
+/**
+ * Get op keys request
+ *
+ * @generated from protobuf message massa.abi.v1.GetOpKeysRequest
+ */
+export interface GetOpKeysRequest {
+ /**
+ * keys prefix
+ *
+ * @generated from protobuf field: bytes prefix = 1;
+ */
+ prefix: Uint8Array;
+}
+/**
+ * Get op keys result
+ *
+ * @generated from protobuf message massa.abi.v1.GetOpKeysResult
+ */
+export interface GetOpKeysResult {
+ /**
+ * keys
+ *
+ * @generated from protobuf field: repeated bytes keys = 1;
+ */
+ keys: Uint8Array[];
+}
+/**
+ * Get remaining gas request
+ *
+ * @generated from protobuf message massa.abi.v1.GetRemainingGasRequest
+ */
+export interface GetRemainingGasRequest {}
+/**
+ * Get remaining gas result
+ *
+ * @generated from protobuf message massa.abi.v1.GetRemainingGasResult
+ */
+export interface GetRemainingGasResult {
+ /**
+ * remaining gas
+ *
+ * @generated from protobuf field: uint64 remaining_gas = 1;
+ */
+ remainingGas: bigint;
+}
+/**
+ * Get balance request
+ *
+ * @generated from protobuf message massa.abi.v1.GetBalanceRequest
+ */
+export interface GetBalanceRequest {
+ /**
+ * Address to get balance for, if none, use current address
+ *
+ * @generated from protobuf field: optional google.protobuf.StringValue address = 1;
+ */
+ address?: StringValue;
+}
+/**
+ * Get balance result
+ *
+ * @generated from protobuf message massa.abi.v1.GetBalanceResult
+ */
+export interface GetBalanceResult {
+ /**
+ * balance
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount balance = 1;
+ */
+ balance?: NativeAmount;
+}
+/**
+ * Get call coins request
+ *
+ * @generated from protobuf message massa.abi.v1.GetCallCoinsRequest
+ */
+export interface GetCallCoinsRequest {}
+/**
+ * Get call coins result
+ *
+ * @generated from protobuf message massa.abi.v1.GetCallCoinsResult
+ */
+export interface GetCallCoinsResult {
+ /**
+ * coins
+ *
+ * @generated from protobuf field: massa.model.v1.NativeAmount coins = 1;
+ */
+ coins?: NativeAmount;
+}
+/**
+ * Get the version of the address request
+ *
+ * @generated from protobuf message massa.abi.v1.GetAddressVersionRequest
+ */
+export interface GetAddressVersionRequest {
+ /**
+ * @generated from protobuf field: string address = 1;
+ */
+ address: string;
+}
+/**
+ * Get the version of the address result
+ *
+ * @generated from protobuf message massa.abi.v1.GetAddressVersionResult
+ */
+export interface GetAddressVersionResult {
+ /**
+ * @generated from protobuf field: uint64 version = 1;
+ */
+ version: bigint;
+}
+/**
+ * Get the category of the address request
+ *
+ * @generated from protobuf message massa.abi.v1.GetAddressCategoryRequest
+ */
+export interface GetAddressCategoryRequest {
+ /**
+ * @generated from protobuf field: string address = 1;
+ */
+ address: string;
+}
+/**
+ * Get the category of the address result
+ *
+ * @generated from protobuf message massa.abi.v1.GetAddressCategoryResult
+ */
+export interface GetAddressCategoryResult {
+ /**
+ * @generated from protobuf field: massa.model.v1.AddressCategory category = 1;
+ */
+ category: AddressCategory;
+}
+/**
+ * Get the version of the public key request
+ *
+ * @generated from protobuf message massa.abi.v1.GetPubKeyVersionRequest
+ */
+export interface GetPubKeyVersionRequest {
+ /**
+ * @generated from protobuf field: string pub_key = 1;
+ */
+ pubKey: string;
+}
+/**
+ * Get the version of the public key result
+ *
+ * @generated from protobuf message massa.abi.v1.GetPubKeyVersionResult
+ */
+export interface GetPubKeyVersionResult {
+ /**
+ * @generated from protobuf field: uint64 version = 1;
+ */
+ version: bigint;
+}
+/**
+ * Get the version of the signature request
+ *
+ * @generated from protobuf message massa.abi.v1.GetSignatureVersionRequest
+ */
+export interface GetSignatureVersionRequest {
+ /**
+ * @generated from protobuf field: string signature = 1;
+ */
+ signature: string;
+}
+/**
+ * Get the version of the signature result
+ *
+ * @generated from protobuf message massa.abi.v1.GetSignatureVersionResult
+ */
+export interface GetSignatureVersionResult {
+ /**
+ * @generated from protobuf field: uint64 version = 1;
+ */
+ version: bigint;
+}
+/**
+ * bytes to base58 request
+ *
+ * @generated from protobuf message massa.abi.v1.BytesToBase58CheckRequest
+ */
+export interface BytesToBase58CheckRequest {
+ /**
+ * @generated from protobuf field: bytes bytes = 1;
+ */
+ bytes: Uint8Array;
+}
+/**
+ * bytes to base58 result
+ *
+ * @generated from protobuf message massa.abi.v1.BytesToBase58CheckResult
+ */
+export interface BytesToBase58CheckResult {
+ /**
+ * @generated from protobuf field: string base58_check = 1;
+ */
+ base58Check: string;
+}
+/**
+ * base58 to bytes request
+ *
+ * @generated from protobuf message massa.abi.v1.Base58CheckToBytesRequest
+ */
+export interface Base58CheckToBytesRequest {
+ /**
+ * @generated from protobuf field: string base58_check = 1;
+ */
+ base58Check: string;
+}
+/**
+ * base58 to bytes result
+ *
+ * @generated from protobuf message massa.abi.v1.Base58CheckToBytesResult
+ */
+export interface Base58CheckToBytesResult {
+ /**
+ * @generated from protobuf field: bytes bytes = 1;
+ */
+ bytes: Uint8Array;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class Error$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.Error', [
+ { no: 1, name: 'message', kind: 'scalar', T: 9 /* ScalarType.STRING*/ },
+ ]);
+ }
+ create(value?: PartialMessage): Error {
+ const message = { message: '' };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: Error,
+ ): Error {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* string message */ 1:
+ message.message = reader.string();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: Error,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* string message = 1; */
+ if (message.message !== '')
+ writer.tag(1, WireType.LengthDelimited).string(message.message);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.Error
+ */
+export const Error = new Error$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CreateScRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CreateScRequest', [
+ { no: 1, name: 'bytecode', kind: 'scalar', T: 12 /* ScalarType.BYTES*/ },
+ ]);
+ }
+ create(value?: PartialMessage): CreateScRequest {
+ const message = { bytecode: new Uint8Array(0) };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CreateScRequest,
+ ): CreateScRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* bytes bytecode */ 1:
+ message.bytecode = reader.bytes();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CreateScRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* bytes bytecode = 1; */
+ if (message.bytecode.length)
+ writer.tag(1, WireType.LengthDelimited).bytes(message.bytecode);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CreateScRequest
+ */
+export const CreateScRequest = new CreateScRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CreateScResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CreateScResult', [
+ {
+ no: 1,
+ name: 'sc_address',
+ kind: 'scalar',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): CreateScResult {
+ const message = { scAddress: '' };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CreateScResult,
+ ): CreateScResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* string sc_address */ 1:
+ message.scAddress = reader.string();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CreateScResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* string sc_address = 1; */
+ if (message.scAddress !== '')
+ writer.tag(1, WireType.LengthDelimited).string(message.scAddress);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CreateScResult
+ */
+export const CreateScResult = new CreateScResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CallRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CallRequest', [
+ {
+ no: 1,
+ name: 'target_sc_address',
+ kind: 'scalar',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 2,
+ name: 'target_function_name',
+ kind: 'scalar',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 3,
+ name: 'function_arg',
+ kind: 'scalar',
+ T: 12 /* ScalarType.BYTES*/,
+ },
+ { no: 4, name: 'call_coins', kind: 'message', T: () => NativeAmount },
+ ]);
+ }
+ create(value?: PartialMessage): CallRequest {
+ const message = {
+ targetScAddress: '',
+ targetFunctionName: '',
+ functionArg: new Uint8Array(0),
+ };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CallRequest,
+ ): CallRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* string target_sc_address */ 1:
+ message.targetScAddress = reader.string();
+ break;
+ case /* string target_function_name */ 2:
+ message.targetFunctionName = reader.string();
+ break;
+ case /* bytes function_arg */ 3:
+ message.functionArg = reader.bytes();
+ break;
+ case /* massa.model.v1.NativeAmount call_coins */ 4:
+ message.callCoins = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.callCoins,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CallRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* string target_sc_address = 1; */
+ if (message.targetScAddress !== '')
+ writer.tag(1, WireType.LengthDelimited).string(message.targetScAddress);
+ /* string target_function_name = 2; */
+ if (message.targetFunctionName !== '')
+ writer
+ .tag(2, WireType.LengthDelimited)
+ .string(message.targetFunctionName);
+ /* bytes function_arg = 3; */
+ if (message.functionArg.length)
+ writer.tag(3, WireType.LengthDelimited).bytes(message.functionArg);
+ /* massa.model.v1.NativeAmount call_coins = 4; */
+ if (message.callCoins)
+ NativeAmount.internalBinaryWrite(
+ message.callCoins,
+ writer.tag(4, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CallRequest
+ */
+export const CallRequest = new CallRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CallResponse$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CallResponse', [
+ { no: 1, name: 'data', kind: 'scalar', T: 12 /* ScalarType.BYTES*/ },
+ ]);
+ }
+ create(value?: PartialMessage): CallResponse {
+ const message = { data: new Uint8Array(0) };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CallResponse,
+ ): CallResponse {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* bytes data */ 1:
+ message.data = reader.bytes();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CallResponse,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* bytes data = 1; */
+ if (message.data.length)
+ writer.tag(1, WireType.LengthDelimited).bytes(message.data);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CallResponse
+ */
+export const CallResponse = new CallResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LocalExecutionRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.LocalExecutionRequest', [
+ { no: 1, name: 'bytecode', kind: 'scalar', T: 12 /* ScalarType.BYTES*/ },
+ {
+ no: 2,
+ name: 'target_function_name',
+ kind: 'scalar',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 3,
+ name: 'function_arg',
+ kind: 'scalar',
+ T: 12 /* ScalarType.BYTES*/,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): LocalExecutionRequest {
+ const message = {
+ bytecode: new Uint8Array(0),
+ targetFunctionName: '',
+ functionArg: new Uint8Array(0),
+ };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: LocalExecutionRequest,
+ ): LocalExecutionRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* bytes bytecode */ 1:
+ message.bytecode = reader.bytes();
+ break;
+ case /* string target_function_name */ 2:
+ message.targetFunctionName = reader.string();
+ break;
+ case /* bytes function_arg */ 3:
+ message.functionArg = reader.bytes();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: LocalExecutionRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* bytes bytecode = 1; */
+ if (message.bytecode.length)
+ writer.tag(1, WireType.LengthDelimited).bytes(message.bytecode);
+ /* string target_function_name = 2; */
+ if (message.targetFunctionName !== '')
+ writer
+ .tag(2, WireType.LengthDelimited)
+ .string(message.targetFunctionName);
+ /* bytes function_arg = 3; */
+ if (message.functionArg.length)
+ writer.tag(3, WireType.LengthDelimited).bytes(message.functionArg);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.LocalExecutionRequest
+ */
+export const LocalExecutionRequest = new LocalExecutionRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LocalExecutionResponse$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.LocalExecutionResponse', [
+ { no: 1, name: 'data', kind: 'scalar', T: 12 /* ScalarType.BYTES*/ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): LocalExecutionResponse {
+ const message = { data: new Uint8Array(0) };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: LocalExecutionResponse,
+ ): LocalExecutionResponse {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* bytes data */ 1:
+ message.data = reader.bytes();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: LocalExecutionResponse,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* bytes data = 1; */
+ if (message.data.length)
+ writer.tag(1, WireType.LengthDelimited).bytes(message.data);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.LocalExecutionResponse
+ */
+export const LocalExecutionResponse = new LocalExecutionResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GenerateEventRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.GenerateEventRequest', [
+ { no: 1, name: 'event', kind: 'scalar', T: 12 /* ScalarType.BYTES*/ },
+ ]);
+ }
+ create(value?: PartialMessage): GenerateEventRequest {
+ const message = { event: new Uint8Array(0) };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: GenerateEventRequest,
+ ): GenerateEventRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* bytes event */ 1:
+ message.event = reader.bytes();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: GenerateEventRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* bytes event = 1; */
+ if (message.event.length)
+ writer.tag(1, WireType.LengthDelimited).bytes(message.event);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.GenerateEventRequest
+ */
+export const GenerateEventRequest = new GenerateEventRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GenerateEventResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.GenerateEventResult', []);
+ }
+ create(value?: PartialMessage): GenerateEventResult {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: GenerateEventResult,
+ ): GenerateEventResult {
+ return target ?? this.create();
+ }
+ internalBinaryWrite(
+ message: GenerateEventResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.GenerateEventResult
+ */
+export const GenerateEventResult = new GenerateEventResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TransferCoinsRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.TransferCoinsRequest', [
+ {
+ no: 1,
+ name: 'target_address',
+ kind: 'scalar',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 2,
+ name: 'amount_to_transfer',
+ kind: 'message',
+ T: () => NativeAmount,
+ },
+ { no: 3, name: 'sender_address', kind: 'message', T: () => StringValue },
+ ]);
+ }
+ create(value?: PartialMessage): TransferCoinsRequest {
+ const message = { targetAddress: '' };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: TransferCoinsRequest,
+ ): TransferCoinsRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* string target_address */ 1:
+ message.targetAddress = reader.string();
+ break;
+ case /* massa.model.v1.NativeAmount amount_to_transfer */ 2:
+ message.amountToTransfer = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.amountToTransfer,
+ );
+ break;
+ case /* optional google.protobuf.StringValue sender_address */ 3:
+ message.senderAddress = StringValue.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.senderAddress,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: TransferCoinsRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* string target_address = 1; */
+ if (message.targetAddress !== '')
+ writer.tag(1, WireType.LengthDelimited).string(message.targetAddress);
+ /* massa.model.v1.NativeAmount amount_to_transfer = 2; */
+ if (message.amountToTransfer)
+ NativeAmount.internalBinaryWrite(
+ message.amountToTransfer,
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* optional google.protobuf.StringValue sender_address = 3; */
+ if (message.senderAddress)
+ StringValue.internalBinaryWrite(
+ message.senderAddress,
+ writer.tag(3, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.TransferCoinsRequest
+ */
+export const TransferCoinsRequest = new TransferCoinsRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TransferCoinsResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.TransferCoinsResult', []);
+ }
+ create(value?: PartialMessage): TransferCoinsResult {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: TransferCoinsResult,
+ ): TransferCoinsResult {
+ return target ?? this.create();
+ }
+ internalBinaryWrite(
+ message: TransferCoinsResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.TransferCoinsResult
+ */
+export const TransferCoinsResult = new TransferCoinsResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class FunctionExistsRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.FunctionExistsRequest', [
+ {
+ no: 1,
+ name: 'target_sc_address',
+ kind: 'scalar',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ {
+ no: 2,
+ name: 'function_name',
+ kind: 'scalar',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): FunctionExistsRequest {
+ const message = { targetScAddress: '', functionName: '' };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: FunctionExistsRequest,
+ ): FunctionExistsRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* string target_sc_address */ 1:
+ message.targetScAddress = reader.string();
+ break;
+ case /* string function_name */ 2:
+ message.functionName = reader.string();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: FunctionExistsRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* string target_sc_address = 1; */
+ if (message.targetScAddress !== '')
+ writer.tag(1, WireType.LengthDelimited).string(message.targetScAddress);
+ /* string function_name = 2; */
+ if (message.functionName !== '')
+ writer.tag(2, WireType.LengthDelimited).string(message.functionName);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.FunctionExistsRequest
+ */
+export const FunctionExistsRequest = new FunctionExistsRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class FunctionExistsResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.FunctionExistsResult', [
+ { no: 1, name: 'exists', kind: 'scalar', T: 8 /* ScalarType.BOOL*/ },
+ ]);
+ }
+ create(value?: PartialMessage): FunctionExistsResult {
+ const message = { exists: false };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: FunctionExistsResult,
+ ): FunctionExistsResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* bool exists */ 1:
+ message.exists = reader.bool();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: FunctionExistsResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* bool exists = 1; */
+ if (message.exists !== false)
+ writer.tag(1, WireType.Varint).bool(message.exists);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.FunctionExistsResult
+ */
+export const FunctionExistsResult = new FunctionExistsResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RespResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.RespResult', [
+ {
+ no: 1,
+ name: 'add_native_amount_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => AddNativeAmountResult,
+ },
+ {
+ no: 2,
+ name: 'address_from_pub_key_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => AddressFromPubKeyResult,
+ },
+ {
+ no: 3,
+ name: 'append_ds_value_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => AppendDsValueResult,
+ },
+ {
+ no: 4,
+ name: 'base58_check_to_bytes_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => Base58CheckToBytesResult,
+ },
+ {
+ no: 5,
+ name: 'bytes_to_base58_check_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => BytesToBase58CheckResult,
+ },
+ {
+ no: 6,
+ name: 'caller_has_write_access_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => CallerHasWriteAccessResult,
+ },
+ {
+ no: 7,
+ name: 'check_address_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => CheckAddressResult,
+ },
+ {
+ no: 8,
+ name: 'check_native_amount_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => CheckNativeAmountResult,
+ },
+ {
+ no: 9,
+ name: 'check_pub_key_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => CheckPubKeyResult,
+ },
+ {
+ no: 10,
+ name: 'check_sig_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => CheckSigResult,
+ },
+ {
+ no: 11,
+ name: 'checked_add_native_time_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => CheckedAddNativeTimeResult,
+ },
+ {
+ no: 12,
+ name: 'checked_div_rem_native_time_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => CheckedDivRemNativeTimeResult,
+ },
+ {
+ no: 13,
+ name: 'checked_scalar_div_rem_native_time_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => CheckedScalarDivRemNativeTimeResult,
+ },
+ {
+ no: 14,
+ name: 'checked_scalar_mul_native_time_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => CheckedScalarMulNativeTimeResult,
+ },
+ {
+ no: 15,
+ name: 'checked_sub_native_time_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => CheckedSubNativeTimeResult,
+ },
+ {
+ no: 16,
+ name: 'compare_address_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => CompareAddressResult,
+ },
+ {
+ no: 17,
+ name: 'compare_native_amount_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => CompareNativeAmountResult,
+ },
+ {
+ no: 18,
+ name: 'compare_native_time_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => CompareNativeTimeResult,
+ },
+ {
+ no: 19,
+ name: 'compare_pub_key_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => ComparePubKeyResult,
+ },
+ {
+ no: 20,
+ name: 'create_sc_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => CreateScResult,
+ },
+ {
+ no: 21,
+ name: 'delete_ds_entry_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => DeleteDsEntryResult,
+ },
+ {
+ no: 22,
+ name: 'div_rem_native_amount_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => DivRemNativeAmountResult,
+ },
+ {
+ no: 23,
+ name: 'ds_entry_exists_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => DsEntryExistsResult,
+ },
+ {
+ no: 24,
+ name: 'function_exists_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => FunctionExistsResult,
+ },
+ {
+ no: 25,
+ name: 'generate_event_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GenerateEventResult,
+ },
+ {
+ no: 26,
+ name: 'get_address_category_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetAddressCategoryResult,
+ },
+ {
+ no: 27,
+ name: 'get_address_version_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetAddressVersionResult,
+ },
+ {
+ no: 28,
+ name: 'get_balance_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetBalanceResult,
+ },
+ {
+ no: 29,
+ name: 'get_bytecode_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetBytecodeResult,
+ },
+ {
+ no: 30,
+ name: 'get_call_coins_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetCallCoinsResult,
+ },
+ {
+ no: 31,
+ name: 'get_call_stack_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetCallStackResult,
+ },
+ {
+ no: 32,
+ name: 'get_current_slot_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetCurrentSlotResult,
+ },
+ {
+ no: 33,
+ name: 'get_ds_keys_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetDsKeysResult,
+ },
+ {
+ no: 34,
+ name: 'get_ds_value_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetDsValueResult,
+ },
+ {
+ no: 35,
+ name: 'get_native_time_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetNativeTimeResult,
+ },
+ {
+ no: 36,
+ name: 'get_op_data_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetOpDataResult,
+ },
+ {
+ no: 37,
+ name: 'get_op_keys_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetOpKeysResult,
+ },
+ {
+ no: 38,
+ name: 'get_origin_operation_id_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetOriginOperationIdResult,
+ },
+ {
+ no: 39,
+ name: 'get_owned_addresses_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetOwnedAddressesResult,
+ },
+ {
+ no: 40,
+ name: 'get_pub_key_version_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetPubKeyVersionResult,
+ },
+ {
+ no: 41,
+ name: 'get_remaining_gas_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetRemainingGasResult,
+ },
+ {
+ no: 42,
+ name: 'get_signature_version_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => GetSignatureVersionResult,
+ },
+ {
+ no: 43,
+ name: 'hash_blake3_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => HashBlake3Result,
+ },
+ {
+ no: 44,
+ name: 'hash_sha256_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => HashSha256Result,
+ },
+ {
+ no: 45,
+ name: 'op_entry_exists_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => OpEntryExistsResult,
+ },
+ {
+ no: 46,
+ name: 'keccak256_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => Keccak256Result,
+ },
+ {
+ no: 47,
+ name: 'local_execution_response',
+ kind: 'message',
+ oneof: 'res',
+ T: () => LocalExecutionResponse,
+ },
+ {
+ no: 48,
+ name: 'native_amount_from_string_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => NativeAmountFromStringResult,
+ },
+ {
+ no: 49,
+ name: 'native_amount_to_string_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => NativeAmountToStringResult,
+ },
+ {
+ no: 50,
+ name: 'scalar_div_rem_native_amount_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => ScalarDivRemNativeAmountResult,
+ },
+ {
+ no: 51,
+ name: 'scalar_mul_native_amount_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => ScalarMulNativeAmountResult,
+ },
+ {
+ no: 52,
+ name: 'send_async_message_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => SendAsyncMessageResult,
+ },
+ {
+ no: 53,
+ name: 'set_bytecode_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => SetBytecodeResult,
+ },
+ {
+ no: 54,
+ name: 'set_ds_value_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => SetDsValueResult,
+ },
+ {
+ no: 55,
+ name: 'sub_native_amount_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => SubNativeAmountResult,
+ },
+ {
+ no: 56,
+ name: 'transfer_coins_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => TransferCoinsResult,
+ },
+ {
+ no: 57,
+ name: 'unsafe_random_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => UnsafeRandomResult,
+ },
+ {
+ no: 58,
+ name: 'evm_verify_sig_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => EvmVerifySigResult,
+ },
+ {
+ no: 59,
+ name: 'verify_sig_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => VerifySigResult,
+ },
+ {
+ no: 60,
+ name: 'evm_get_address_from_pubkey_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => EvmGetAddressFromPubkeyResult,
+ },
+ {
+ no: 61,
+ name: 'evm_get_pubkey_from_signature_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => EvmGetPubkeyFromSignatureResult,
+ },
+ {
+ no: 62,
+ name: 'is_address_eoa_result',
+ kind: 'message',
+ oneof: 'res',
+ T: () => IsAddressEoaResult,
+ },
+ ]);
+ }
+ create(value?: PartialMessage): RespResult {
+ const message = { res: { oneofKind: undefined } };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: RespResult,
+ ): RespResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.abi.v1.AddNativeAmountResult add_native_amount_result */ 1:
+ message.res = {
+ oneofKind: 'addNativeAmountResult',
+ addNativeAmountResult: AddNativeAmountResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).addNativeAmountResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.AddressFromPubKeyResult address_from_pub_key_result */ 2:
+ message.res = {
+ oneofKind: 'addressFromPubKeyResult',
+ addressFromPubKeyResult: AddressFromPubKeyResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).addressFromPubKeyResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.AppendDsValueResult append_ds_value_result */ 3:
+ message.res = {
+ oneofKind: 'appendDsValueResult',
+ appendDsValueResult: AppendDsValueResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).appendDsValueResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.Base58CheckToBytesResult base58_check_to_bytes_result */ 4:
+ message.res = {
+ oneofKind: 'base58CheckToBytesResult',
+ base58CheckToBytesResult:
+ Base58CheckToBytesResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).base58CheckToBytesResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.BytesToBase58CheckResult bytes_to_base58_check_result */ 5:
+ message.res = {
+ oneofKind: 'bytesToBase58CheckResult',
+ bytesToBase58CheckResult:
+ BytesToBase58CheckResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).bytesToBase58CheckResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.CallerHasWriteAccessResult caller_has_write_access_result */ 6:
+ message.res = {
+ oneofKind: 'callerHasWriteAccessResult',
+ callerHasWriteAccessResult:
+ CallerHasWriteAccessResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).callerHasWriteAccessResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.CheckAddressResult check_address_result */ 7:
+ message.res = {
+ oneofKind: 'checkAddressResult',
+ checkAddressResult: CheckAddressResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).checkAddressResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.CheckNativeAmountResult check_native_amount_result */ 8:
+ message.res = {
+ oneofKind: 'checkNativeAmountResult',
+ checkNativeAmountResult: CheckNativeAmountResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).checkNativeAmountResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.CheckPubKeyResult check_pub_key_result */ 9:
+ message.res = {
+ oneofKind: 'checkPubKeyResult',
+ checkPubKeyResult: CheckPubKeyResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).checkPubKeyResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.CheckSigResult check_sig_result */ 10:
+ message.res = {
+ oneofKind: 'checkSigResult',
+ checkSigResult: CheckSigResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).checkSigResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.CheckedAddNativeTimeResult checked_add_native_time_result */ 11:
+ message.res = {
+ oneofKind: 'checkedAddNativeTimeResult',
+ checkedAddNativeTimeResult:
+ CheckedAddNativeTimeResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).checkedAddNativeTimeResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.CheckedDivRemNativeTimeResult checked_div_rem_native_time_result */ 12:
+ message.res = {
+ oneofKind: 'checkedDivRemNativeTimeResult',
+ checkedDivRemNativeTimeResult:
+ CheckedDivRemNativeTimeResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).checkedDivRemNativeTimeResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.CheckedScalarDivRemNativeTimeResult checked_scalar_div_rem_native_time_result */ 13:
+ message.res = {
+ oneofKind: 'checkedScalarDivRemNativeTimeResult',
+ checkedScalarDivRemNativeTimeResult:
+ CheckedScalarDivRemNativeTimeResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).checkedScalarDivRemNativeTimeResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.CheckedScalarMulNativeTimeResult checked_scalar_mul_native_time_result */ 14:
+ message.res = {
+ oneofKind: 'checkedScalarMulNativeTimeResult',
+ checkedScalarMulNativeTimeResult:
+ CheckedScalarMulNativeTimeResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).checkedScalarMulNativeTimeResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.CheckedSubNativeTimeResult checked_sub_native_time_result */ 15:
+ message.res = {
+ oneofKind: 'checkedSubNativeTimeResult',
+ checkedSubNativeTimeResult:
+ CheckedSubNativeTimeResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).checkedSubNativeTimeResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.CompareAddressResult compare_address_result */ 16:
+ message.res = {
+ oneofKind: 'compareAddressResult',
+ compareAddressResult: CompareAddressResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).compareAddressResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.CompareNativeAmountResult compare_native_amount_result */ 17:
+ message.res = {
+ oneofKind: 'compareNativeAmountResult',
+ compareNativeAmountResult:
+ CompareNativeAmountResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).compareNativeAmountResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.CompareNativeTimeResult compare_native_time_result */ 18:
+ message.res = {
+ oneofKind: 'compareNativeTimeResult',
+ compareNativeTimeResult: CompareNativeTimeResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).compareNativeTimeResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.ComparePubKeyResult compare_pub_key_result */ 19:
+ message.res = {
+ oneofKind: 'comparePubKeyResult',
+ comparePubKeyResult: ComparePubKeyResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).comparePubKeyResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.CreateScResult create_sc_result */ 20:
+ message.res = {
+ oneofKind: 'createScResult',
+ createScResult: CreateScResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).createScResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.DeleteDsEntryResult delete_ds_entry_result */ 21:
+ message.res = {
+ oneofKind: 'deleteDsEntryResult',
+ deleteDsEntryResult: DeleteDsEntryResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).deleteDsEntryResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.DivRemNativeAmountResult div_rem_native_amount_result */ 22:
+ message.res = {
+ oneofKind: 'divRemNativeAmountResult',
+ divRemNativeAmountResult:
+ DivRemNativeAmountResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).divRemNativeAmountResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.DsEntryExistsResult ds_entry_exists_result */ 23:
+ message.res = {
+ oneofKind: 'dsEntryExistsResult',
+ dsEntryExistsResult: DsEntryExistsResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).dsEntryExistsResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.FunctionExistsResult function_exists_result */ 24:
+ message.res = {
+ oneofKind: 'functionExistsResult',
+ functionExistsResult: FunctionExistsResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).functionExistsResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GenerateEventResult generate_event_result */ 25:
+ message.res = {
+ oneofKind: 'generateEventResult',
+ generateEventResult: GenerateEventResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).generateEventResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetAddressCategoryResult get_address_category_result */ 26:
+ message.res = {
+ oneofKind: 'getAddressCategoryResult',
+ getAddressCategoryResult:
+ GetAddressCategoryResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getAddressCategoryResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetAddressVersionResult get_address_version_result */ 27:
+ message.res = {
+ oneofKind: 'getAddressVersionResult',
+ getAddressVersionResult: GetAddressVersionResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getAddressVersionResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetBalanceResult get_balance_result */ 28:
+ message.res = {
+ oneofKind: 'getBalanceResult',
+ getBalanceResult: GetBalanceResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getBalanceResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetBytecodeResult get_bytecode_result */ 29:
+ message.res = {
+ oneofKind: 'getBytecodeResult',
+ getBytecodeResult: GetBytecodeResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getBytecodeResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetCallCoinsResult get_call_coins_result */ 30:
+ message.res = {
+ oneofKind: 'getCallCoinsResult',
+ getCallCoinsResult: GetCallCoinsResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getCallCoinsResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetCallStackResult get_call_stack_result */ 31:
+ message.res = {
+ oneofKind: 'getCallStackResult',
+ getCallStackResult: GetCallStackResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getCallStackResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetCurrentSlotResult get_current_slot_result */ 32:
+ message.res = {
+ oneofKind: 'getCurrentSlotResult',
+ getCurrentSlotResult: GetCurrentSlotResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getCurrentSlotResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetDsKeysResult get_ds_keys_result */ 33:
+ message.res = {
+ oneofKind: 'getDsKeysResult',
+ getDsKeysResult: GetDsKeysResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getDsKeysResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetDsValueResult get_ds_value_result */ 34:
+ message.res = {
+ oneofKind: 'getDsValueResult',
+ getDsValueResult: GetDsValueResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getDsValueResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetNativeTimeResult get_native_time_result */ 35:
+ message.res = {
+ oneofKind: 'getNativeTimeResult',
+ getNativeTimeResult: GetNativeTimeResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getNativeTimeResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetOpDataResult get_op_data_result */ 36:
+ message.res = {
+ oneofKind: 'getOpDataResult',
+ getOpDataResult: GetOpDataResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getOpDataResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetOpKeysResult get_op_keys_result */ 37:
+ message.res = {
+ oneofKind: 'getOpKeysResult',
+ getOpKeysResult: GetOpKeysResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getOpKeysResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetOriginOperationIdResult get_origin_operation_id_result */ 38:
+ message.res = {
+ oneofKind: 'getOriginOperationIdResult',
+ getOriginOperationIdResult:
+ GetOriginOperationIdResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getOriginOperationIdResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetOwnedAddressesResult get_owned_addresses_result */ 39:
+ message.res = {
+ oneofKind: 'getOwnedAddressesResult',
+ getOwnedAddressesResult: GetOwnedAddressesResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getOwnedAddressesResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetPubKeyVersionResult get_pub_key_version_result */ 40:
+ message.res = {
+ oneofKind: 'getPubKeyVersionResult',
+ getPubKeyVersionResult: GetPubKeyVersionResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getPubKeyVersionResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetRemainingGasResult get_remaining_gas_result */ 41:
+ message.res = {
+ oneofKind: 'getRemainingGasResult',
+ getRemainingGasResult: GetRemainingGasResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getRemainingGasResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.GetSignatureVersionResult get_signature_version_result */ 42:
+ message.res = {
+ oneofKind: 'getSignatureVersionResult',
+ getSignatureVersionResult:
+ GetSignatureVersionResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).getSignatureVersionResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.HashBlake3Result hash_blake3_result */ 43:
+ message.res = {
+ oneofKind: 'hashBlake3Result',
+ hashBlake3Result: HashBlake3Result.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).hashBlake3Result,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.HashSha256Result hash_sha256_result */ 44:
+ message.res = {
+ oneofKind: 'hashSha256Result',
+ hashSha256Result: HashSha256Result.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).hashSha256Result,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.OpEntryExistsResult op_entry_exists_result */ 45:
+ message.res = {
+ oneofKind: 'opEntryExistsResult',
+ opEntryExistsResult: OpEntryExistsResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).opEntryExistsResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.Keccak256Result keccak256_result */ 46:
+ message.res = {
+ oneofKind: 'keccak256Result',
+ keccak256Result: Keccak256Result.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).keccak256Result,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.LocalExecutionResponse local_execution_response */ 47:
+ message.res = {
+ oneofKind: 'localExecutionResponse',
+ localExecutionResponse: LocalExecutionResponse.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).localExecutionResponse,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.NativeAmountFromStringResult native_amount_from_string_result */ 48:
+ message.res = {
+ oneofKind: 'nativeAmountFromStringResult',
+ nativeAmountFromStringResult:
+ NativeAmountFromStringResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).nativeAmountFromStringResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.NativeAmountToStringResult native_amount_to_string_result */ 49:
+ message.res = {
+ oneofKind: 'nativeAmountToStringResult',
+ nativeAmountToStringResult:
+ NativeAmountToStringResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).nativeAmountToStringResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.ScalarDivRemNativeAmountResult scalar_div_rem_native_amount_result */ 50:
+ message.res = {
+ oneofKind: 'scalarDivRemNativeAmountResult',
+ scalarDivRemNativeAmountResult:
+ ScalarDivRemNativeAmountResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).scalarDivRemNativeAmountResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.ScalarMulNativeAmountResult scalar_mul_native_amount_result */ 51:
+ message.res = {
+ oneofKind: 'scalarMulNativeAmountResult',
+ scalarMulNativeAmountResult:
+ ScalarMulNativeAmountResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).scalarMulNativeAmountResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.SendAsyncMessageResult send_async_message_result */ 52:
+ message.res = {
+ oneofKind: 'sendAsyncMessageResult',
+ sendAsyncMessageResult: SendAsyncMessageResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).sendAsyncMessageResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.SetBytecodeResult set_bytecode_result */ 53:
+ message.res = {
+ oneofKind: 'setBytecodeResult',
+ setBytecodeResult: SetBytecodeResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).setBytecodeResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.SetDsValueResult set_ds_value_result */ 54:
+ message.res = {
+ oneofKind: 'setDsValueResult',
+ setDsValueResult: SetDsValueResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).setDsValueResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.SubNativeAmountResult sub_native_amount_result */ 55:
+ message.res = {
+ oneofKind: 'subNativeAmountResult',
+ subNativeAmountResult: SubNativeAmountResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).subNativeAmountResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.TransferCoinsResult transfer_coins_result */ 56:
+ message.res = {
+ oneofKind: 'transferCoinsResult',
+ transferCoinsResult: TransferCoinsResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).transferCoinsResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.UnsafeRandomResult unsafe_random_result */ 57:
+ message.res = {
+ oneofKind: 'unsafeRandomResult',
+ unsafeRandomResult: UnsafeRandomResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).unsafeRandomResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.EvmVerifySigResult evm_verify_sig_result */ 58:
+ message.res = {
+ oneofKind: 'evmVerifySigResult',
+ evmVerifySigResult: EvmVerifySigResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).evmVerifySigResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.VerifySigResult verify_sig_result */ 59:
+ message.res = {
+ oneofKind: 'verifySigResult',
+ verifySigResult: VerifySigResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).verifySigResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.EvmGetAddressFromPubkeyResult evm_get_address_from_pubkey_result */ 60:
+ message.res = {
+ oneofKind: 'evmGetAddressFromPubkeyResult',
+ evmGetAddressFromPubkeyResult:
+ EvmGetAddressFromPubkeyResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).evmGetAddressFromPubkeyResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.EvmGetPubkeyFromSignatureResult evm_get_pubkey_from_signature_result */ 61:
+ message.res = {
+ oneofKind: 'evmGetPubkeyFromSignatureResult',
+ evmGetPubkeyFromSignatureResult:
+ EvmGetPubkeyFromSignatureResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).evmGetPubkeyFromSignatureResult,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.IsAddressEoaResult is_address_eoa_result */ 62:
+ message.res = {
+ oneofKind: 'isAddressEoaResult',
+ isAddressEoaResult: IsAddressEoaResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.res as any).isAddressEoaResult,
+ ),
+ };
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: RespResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.abi.v1.AddNativeAmountResult add_native_amount_result = 1; */
+ if (message.res.oneofKind === 'addNativeAmountResult')
+ AddNativeAmountResult.internalBinaryWrite(
+ message.res.addNativeAmountResult,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.AddressFromPubKeyResult address_from_pub_key_result = 2; */
+ if (message.res.oneofKind === 'addressFromPubKeyResult')
+ AddressFromPubKeyResult.internalBinaryWrite(
+ message.res.addressFromPubKeyResult,
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.AppendDsValueResult append_ds_value_result = 3; */
+ if (message.res.oneofKind === 'appendDsValueResult')
+ AppendDsValueResult.internalBinaryWrite(
+ message.res.appendDsValueResult,
+ writer.tag(3, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.Base58CheckToBytesResult base58_check_to_bytes_result = 4; */
+ if (message.res.oneofKind === 'base58CheckToBytesResult')
+ Base58CheckToBytesResult.internalBinaryWrite(
+ message.res.base58CheckToBytesResult,
+ writer.tag(4, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.BytesToBase58CheckResult bytes_to_base58_check_result = 5; */
+ if (message.res.oneofKind === 'bytesToBase58CheckResult')
+ BytesToBase58CheckResult.internalBinaryWrite(
+ message.res.bytesToBase58CheckResult,
+ writer.tag(5, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.CallerHasWriteAccessResult caller_has_write_access_result = 6; */
+ if (message.res.oneofKind === 'callerHasWriteAccessResult')
+ CallerHasWriteAccessResult.internalBinaryWrite(
+ message.res.callerHasWriteAccessResult,
+ writer.tag(6, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.CheckAddressResult check_address_result = 7; */
+ if (message.res.oneofKind === 'checkAddressResult')
+ CheckAddressResult.internalBinaryWrite(
+ message.res.checkAddressResult,
+ writer.tag(7, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.CheckNativeAmountResult check_native_amount_result = 8; */
+ if (message.res.oneofKind === 'checkNativeAmountResult')
+ CheckNativeAmountResult.internalBinaryWrite(
+ message.res.checkNativeAmountResult,
+ writer.tag(8, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.CheckPubKeyResult check_pub_key_result = 9; */
+ if (message.res.oneofKind === 'checkPubKeyResult')
+ CheckPubKeyResult.internalBinaryWrite(
+ message.res.checkPubKeyResult,
+ writer.tag(9, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.CheckSigResult check_sig_result = 10; */
+ if (message.res.oneofKind === 'checkSigResult')
+ CheckSigResult.internalBinaryWrite(
+ message.res.checkSigResult,
+ writer.tag(10, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.CheckedAddNativeTimeResult checked_add_native_time_result = 11; */
+ if (message.res.oneofKind === 'checkedAddNativeTimeResult')
+ CheckedAddNativeTimeResult.internalBinaryWrite(
+ message.res.checkedAddNativeTimeResult,
+ writer.tag(11, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.CheckedDivRemNativeTimeResult checked_div_rem_native_time_result = 12; */
+ if (message.res.oneofKind === 'checkedDivRemNativeTimeResult')
+ CheckedDivRemNativeTimeResult.internalBinaryWrite(
+ message.res.checkedDivRemNativeTimeResult,
+ writer.tag(12, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.CheckedScalarDivRemNativeTimeResult checked_scalar_div_rem_native_time_result = 13; */
+ if (message.res.oneofKind === 'checkedScalarDivRemNativeTimeResult')
+ CheckedScalarDivRemNativeTimeResult.internalBinaryWrite(
+ message.res.checkedScalarDivRemNativeTimeResult,
+ writer.tag(13, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.CheckedScalarMulNativeTimeResult checked_scalar_mul_native_time_result = 14; */
+ if (message.res.oneofKind === 'checkedScalarMulNativeTimeResult')
+ CheckedScalarMulNativeTimeResult.internalBinaryWrite(
+ message.res.checkedScalarMulNativeTimeResult,
+ writer.tag(14, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.CheckedSubNativeTimeResult checked_sub_native_time_result = 15; */
+ if (message.res.oneofKind === 'checkedSubNativeTimeResult')
+ CheckedSubNativeTimeResult.internalBinaryWrite(
+ message.res.checkedSubNativeTimeResult,
+ writer.tag(15, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.CompareAddressResult compare_address_result = 16; */
+ if (message.res.oneofKind === 'compareAddressResult')
+ CompareAddressResult.internalBinaryWrite(
+ message.res.compareAddressResult,
+ writer.tag(16, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.CompareNativeAmountResult compare_native_amount_result = 17; */
+ if (message.res.oneofKind === 'compareNativeAmountResult')
+ CompareNativeAmountResult.internalBinaryWrite(
+ message.res.compareNativeAmountResult,
+ writer.tag(17, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.CompareNativeTimeResult compare_native_time_result = 18; */
+ if (message.res.oneofKind === 'compareNativeTimeResult')
+ CompareNativeTimeResult.internalBinaryWrite(
+ message.res.compareNativeTimeResult,
+ writer.tag(18, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.ComparePubKeyResult compare_pub_key_result = 19; */
+ if (message.res.oneofKind === 'comparePubKeyResult')
+ ComparePubKeyResult.internalBinaryWrite(
+ message.res.comparePubKeyResult,
+ writer.tag(19, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.CreateScResult create_sc_result = 20; */
+ if (message.res.oneofKind === 'createScResult')
+ CreateScResult.internalBinaryWrite(
+ message.res.createScResult,
+ writer.tag(20, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.DeleteDsEntryResult delete_ds_entry_result = 21; */
+ if (message.res.oneofKind === 'deleteDsEntryResult')
+ DeleteDsEntryResult.internalBinaryWrite(
+ message.res.deleteDsEntryResult,
+ writer.tag(21, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.DivRemNativeAmountResult div_rem_native_amount_result = 22; */
+ if (message.res.oneofKind === 'divRemNativeAmountResult')
+ DivRemNativeAmountResult.internalBinaryWrite(
+ message.res.divRemNativeAmountResult,
+ writer.tag(22, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.DsEntryExistsResult ds_entry_exists_result = 23; */
+ if (message.res.oneofKind === 'dsEntryExistsResult')
+ DsEntryExistsResult.internalBinaryWrite(
+ message.res.dsEntryExistsResult,
+ writer.tag(23, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.FunctionExistsResult function_exists_result = 24; */
+ if (message.res.oneofKind === 'functionExistsResult')
+ FunctionExistsResult.internalBinaryWrite(
+ message.res.functionExistsResult,
+ writer.tag(24, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GenerateEventResult generate_event_result = 25; */
+ if (message.res.oneofKind === 'generateEventResult')
+ GenerateEventResult.internalBinaryWrite(
+ message.res.generateEventResult,
+ writer.tag(25, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetAddressCategoryResult get_address_category_result = 26; */
+ if (message.res.oneofKind === 'getAddressCategoryResult')
+ GetAddressCategoryResult.internalBinaryWrite(
+ message.res.getAddressCategoryResult,
+ writer.tag(26, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetAddressVersionResult get_address_version_result = 27; */
+ if (message.res.oneofKind === 'getAddressVersionResult')
+ GetAddressVersionResult.internalBinaryWrite(
+ message.res.getAddressVersionResult,
+ writer.tag(27, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetBalanceResult get_balance_result = 28; */
+ if (message.res.oneofKind === 'getBalanceResult')
+ GetBalanceResult.internalBinaryWrite(
+ message.res.getBalanceResult,
+ writer.tag(28, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetBytecodeResult get_bytecode_result = 29; */
+ if (message.res.oneofKind === 'getBytecodeResult')
+ GetBytecodeResult.internalBinaryWrite(
+ message.res.getBytecodeResult,
+ writer.tag(29, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetCallCoinsResult get_call_coins_result = 30; */
+ if (message.res.oneofKind === 'getCallCoinsResult')
+ GetCallCoinsResult.internalBinaryWrite(
+ message.res.getCallCoinsResult,
+ writer.tag(30, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetCallStackResult get_call_stack_result = 31; */
+ if (message.res.oneofKind === 'getCallStackResult')
+ GetCallStackResult.internalBinaryWrite(
+ message.res.getCallStackResult,
+ writer.tag(31, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetCurrentSlotResult get_current_slot_result = 32; */
+ if (message.res.oneofKind === 'getCurrentSlotResult')
+ GetCurrentSlotResult.internalBinaryWrite(
+ message.res.getCurrentSlotResult,
+ writer.tag(32, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetDsKeysResult get_ds_keys_result = 33; */
+ if (message.res.oneofKind === 'getDsKeysResult')
+ GetDsKeysResult.internalBinaryWrite(
+ message.res.getDsKeysResult,
+ writer.tag(33, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetDsValueResult get_ds_value_result = 34; */
+ if (message.res.oneofKind === 'getDsValueResult')
+ GetDsValueResult.internalBinaryWrite(
+ message.res.getDsValueResult,
+ writer.tag(34, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetNativeTimeResult get_native_time_result = 35; */
+ if (message.res.oneofKind === 'getNativeTimeResult')
+ GetNativeTimeResult.internalBinaryWrite(
+ message.res.getNativeTimeResult,
+ writer.tag(35, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetOpDataResult get_op_data_result = 36; */
+ if (message.res.oneofKind === 'getOpDataResult')
+ GetOpDataResult.internalBinaryWrite(
+ message.res.getOpDataResult,
+ writer.tag(36, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetOpKeysResult get_op_keys_result = 37; */
+ if (message.res.oneofKind === 'getOpKeysResult')
+ GetOpKeysResult.internalBinaryWrite(
+ message.res.getOpKeysResult,
+ writer.tag(37, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetOriginOperationIdResult get_origin_operation_id_result = 38; */
+ if (message.res.oneofKind === 'getOriginOperationIdResult')
+ GetOriginOperationIdResult.internalBinaryWrite(
+ message.res.getOriginOperationIdResult,
+ writer.tag(38, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetOwnedAddressesResult get_owned_addresses_result = 39; */
+ if (message.res.oneofKind === 'getOwnedAddressesResult')
+ GetOwnedAddressesResult.internalBinaryWrite(
+ message.res.getOwnedAddressesResult,
+ writer.tag(39, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetPubKeyVersionResult get_pub_key_version_result = 40; */
+ if (message.res.oneofKind === 'getPubKeyVersionResult')
+ GetPubKeyVersionResult.internalBinaryWrite(
+ message.res.getPubKeyVersionResult,
+ writer.tag(40, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetRemainingGasResult get_remaining_gas_result = 41; */
+ if (message.res.oneofKind === 'getRemainingGasResult')
+ GetRemainingGasResult.internalBinaryWrite(
+ message.res.getRemainingGasResult,
+ writer.tag(41, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.GetSignatureVersionResult get_signature_version_result = 42; */
+ if (message.res.oneofKind === 'getSignatureVersionResult')
+ GetSignatureVersionResult.internalBinaryWrite(
+ message.res.getSignatureVersionResult,
+ writer.tag(42, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.HashBlake3Result hash_blake3_result = 43; */
+ if (message.res.oneofKind === 'hashBlake3Result')
+ HashBlake3Result.internalBinaryWrite(
+ message.res.hashBlake3Result,
+ writer.tag(43, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.HashSha256Result hash_sha256_result = 44; */
+ if (message.res.oneofKind === 'hashSha256Result')
+ HashSha256Result.internalBinaryWrite(
+ message.res.hashSha256Result,
+ writer.tag(44, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.OpEntryExistsResult op_entry_exists_result = 45; */
+ if (message.res.oneofKind === 'opEntryExistsResult')
+ OpEntryExistsResult.internalBinaryWrite(
+ message.res.opEntryExistsResult,
+ writer.tag(45, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.Keccak256Result keccak256_result = 46; */
+ if (message.res.oneofKind === 'keccak256Result')
+ Keccak256Result.internalBinaryWrite(
+ message.res.keccak256Result,
+ writer.tag(46, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.LocalExecutionResponse local_execution_response = 47; */
+ if (message.res.oneofKind === 'localExecutionResponse')
+ LocalExecutionResponse.internalBinaryWrite(
+ message.res.localExecutionResponse,
+ writer.tag(47, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.NativeAmountFromStringResult native_amount_from_string_result = 48; */
+ if (message.res.oneofKind === 'nativeAmountFromStringResult')
+ NativeAmountFromStringResult.internalBinaryWrite(
+ message.res.nativeAmountFromStringResult,
+ writer.tag(48, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.NativeAmountToStringResult native_amount_to_string_result = 49; */
+ if (message.res.oneofKind === 'nativeAmountToStringResult')
+ NativeAmountToStringResult.internalBinaryWrite(
+ message.res.nativeAmountToStringResult,
+ writer.tag(49, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.ScalarDivRemNativeAmountResult scalar_div_rem_native_amount_result = 50; */
+ if (message.res.oneofKind === 'scalarDivRemNativeAmountResult')
+ ScalarDivRemNativeAmountResult.internalBinaryWrite(
+ message.res.scalarDivRemNativeAmountResult,
+ writer.tag(50, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.ScalarMulNativeAmountResult scalar_mul_native_amount_result = 51; */
+ if (message.res.oneofKind === 'scalarMulNativeAmountResult')
+ ScalarMulNativeAmountResult.internalBinaryWrite(
+ message.res.scalarMulNativeAmountResult,
+ writer.tag(51, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.SendAsyncMessageResult send_async_message_result = 52; */
+ if (message.res.oneofKind === 'sendAsyncMessageResult')
+ SendAsyncMessageResult.internalBinaryWrite(
+ message.res.sendAsyncMessageResult,
+ writer.tag(52, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.SetBytecodeResult set_bytecode_result = 53; */
+ if (message.res.oneofKind === 'setBytecodeResult')
+ SetBytecodeResult.internalBinaryWrite(
+ message.res.setBytecodeResult,
+ writer.tag(53, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.SetDsValueResult set_ds_value_result = 54; */
+ if (message.res.oneofKind === 'setDsValueResult')
+ SetDsValueResult.internalBinaryWrite(
+ message.res.setDsValueResult,
+ writer.tag(54, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.SubNativeAmountResult sub_native_amount_result = 55; */
+ if (message.res.oneofKind === 'subNativeAmountResult')
+ SubNativeAmountResult.internalBinaryWrite(
+ message.res.subNativeAmountResult,
+ writer.tag(55, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.TransferCoinsResult transfer_coins_result = 56; */
+ if (message.res.oneofKind === 'transferCoinsResult')
+ TransferCoinsResult.internalBinaryWrite(
+ message.res.transferCoinsResult,
+ writer.tag(56, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.UnsafeRandomResult unsafe_random_result = 57; */
+ if (message.res.oneofKind === 'unsafeRandomResult')
+ UnsafeRandomResult.internalBinaryWrite(
+ message.res.unsafeRandomResult,
+ writer.tag(57, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.EvmVerifySigResult evm_verify_sig_result = 58; */
+ if (message.res.oneofKind === 'evmVerifySigResult')
+ EvmVerifySigResult.internalBinaryWrite(
+ message.res.evmVerifySigResult,
+ writer.tag(58, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.VerifySigResult verify_sig_result = 59; */
+ if (message.res.oneofKind === 'verifySigResult')
+ VerifySigResult.internalBinaryWrite(
+ message.res.verifySigResult,
+ writer.tag(59, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.EvmGetAddressFromPubkeyResult evm_get_address_from_pubkey_result = 60; */
+ if (message.res.oneofKind === 'evmGetAddressFromPubkeyResult')
+ EvmGetAddressFromPubkeyResult.internalBinaryWrite(
+ message.res.evmGetAddressFromPubkeyResult,
+ writer.tag(60, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.EvmGetPubkeyFromSignatureResult evm_get_pubkey_from_signature_result = 61; */
+ if (message.res.oneofKind === 'evmGetPubkeyFromSignatureResult')
+ EvmGetPubkeyFromSignatureResult.internalBinaryWrite(
+ message.res.evmGetPubkeyFromSignatureResult,
+ writer.tag(61, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.IsAddressEoaResult is_address_eoa_result = 62; */
+ if (message.res.oneofKind === 'isAddressEoaResult')
+ IsAddressEoaResult.internalBinaryWrite(
+ message.res.isAddressEoaResult,
+ writer.tag(62, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.RespResult
+ */
+export const RespResult = new RespResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AbiResponse$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.AbiResponse', [
+ {
+ no: 1,
+ name: 'res',
+ kind: 'message',
+ oneof: 'resp',
+ T: () => RespResult,
+ },
+ { no: 2, name: 'error', kind: 'message', oneof: 'resp', T: () => Error },
+ ]);
+ }
+ create(value?: PartialMessage): AbiResponse {
+ const message = { resp: { oneofKind: undefined } };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: AbiResponse,
+ ): AbiResponse {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.abi.v1.RespResult res */ 1:
+ message.resp = {
+ oneofKind: 'res',
+ res: RespResult.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.resp as any).res,
+ ),
+ };
+ break;
+ case /* massa.abi.v1.Error error */ 2:
+ message.resp = {
+ oneofKind: 'error',
+ error: Error.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ (message.resp as any).error,
+ ),
+ };
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: AbiResponse,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.abi.v1.RespResult res = 1; */
+ if (message.resp.oneofKind === 'res')
+ RespResult.internalBinaryWrite(
+ message.resp.res,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.abi.v1.Error error = 2; */
+ if (message.resp.oneofKind === 'error')
+ Error.internalBinaryWrite(
+ message.resp.error,
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.AbiResponse
+ */
+export const AbiResponse = new AbiResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class NativeAmountToStringRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.NativeAmountToStringRequest', [
+ { no: 1, name: 'to_convert', kind: 'message', T: () => NativeAmount },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): NativeAmountToStringRequest {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: NativeAmountToStringRequest,
+ ): NativeAmountToStringRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeAmount to_convert */ 1:
+ message.toConvert = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.toConvert,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: NativeAmountToStringRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeAmount to_convert = 1; */
+ if (message.toConvert)
+ NativeAmount.internalBinaryWrite(
+ message.toConvert,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.NativeAmountToStringRequest
+ */
+export const NativeAmountToStringRequest =
+ new NativeAmountToStringRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class NativeAmountToStringResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.NativeAmountToStringResult', [
+ {
+ no: 1,
+ name: 'converted_amount',
+ kind: 'scalar',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): NativeAmountToStringResult {
+ const message = { convertedAmount: '' };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: NativeAmountToStringResult,
+ ): NativeAmountToStringResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* string converted_amount */ 1:
+ message.convertedAmount = reader.string();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: NativeAmountToStringResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* string converted_amount = 1; */
+ if (message.convertedAmount !== '')
+ writer.tag(1, WireType.LengthDelimited).string(message.convertedAmount);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.NativeAmountToStringResult
+ */
+export const NativeAmountToStringResult = new NativeAmountToStringResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class NativeAmountFromStringRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.NativeAmountFromStringRequest', [
+ {
+ no: 1,
+ name: 'to_convert',
+ kind: 'scalar',
+ T: 9 /* ScalarType.STRING*/,
+ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): NativeAmountFromStringRequest {
+ const message = { toConvert: '' };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(
+ this,
+ message,
+ value,
+ );
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: NativeAmountFromStringRequest,
+ ): NativeAmountFromStringRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* string to_convert */ 1:
+ message.toConvert = reader.string();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: NativeAmountFromStringRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* string to_convert = 1; */
+ if (message.toConvert !== '')
+ writer.tag(1, WireType.LengthDelimited).string(message.toConvert);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.NativeAmountFromStringRequest
+ */
+export const NativeAmountFromStringRequest =
+ new NativeAmountFromStringRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class NativeAmountFromStringResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.NativeAmountFromStringResult', [
+ {
+ no: 1,
+ name: 'converted_amount',
+ kind: 'message',
+ T: () => NativeAmount,
+ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): NativeAmountFromStringResult {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(
+ this,
+ message,
+ value,
+ );
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: NativeAmountFromStringResult,
+ ): NativeAmountFromStringResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeAmount converted_amount */ 1:
+ message.convertedAmount = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.convertedAmount,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: NativeAmountFromStringResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeAmount converted_amount = 1; */
+ if (message.convertedAmount)
+ NativeAmount.internalBinaryWrite(
+ message.convertedAmount,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.NativeAmountFromStringResult
+ */
+export const NativeAmountFromStringResult =
+ new NativeAmountFromStringResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckAddressRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckAddressRequest', [
+ { no: 1, name: 'to_check', kind: 'scalar', T: 9 /* ScalarType.STRING*/ },
+ ]);
+ }
+ create(value?: PartialMessage): CheckAddressRequest {
+ const message = { toCheck: '' };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckAddressRequest,
+ ): CheckAddressRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* string to_check */ 1:
+ message.toCheck = reader.string();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckAddressRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* string to_check = 1; */
+ if (message.toCheck !== '')
+ writer.tag(1, WireType.LengthDelimited).string(message.toCheck);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckAddressRequest
+ */
+export const CheckAddressRequest = new CheckAddressRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckAddressResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckAddressResult', [
+ { no: 1, name: 'is_valid', kind: 'scalar', T: 8 /* ScalarType.BOOL*/ },
+ ]);
+ }
+ create(value?: PartialMessage): CheckAddressResult {
+ const message = { isValid: false };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckAddressResult,
+ ): CheckAddressResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* bool is_valid */ 1:
+ message.isValid = reader.bool();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckAddressResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* bool is_valid = 1; */
+ if (message.isValid !== false)
+ writer.tag(1, WireType.Varint).bool(message.isValid);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckAddressResult
+ */
+export const CheckAddressResult = new CheckAddressResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckPubKeyRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckPubKeyRequest', [
+ { no: 1, name: 'to_check', kind: 'scalar', T: 9 /* ScalarType.STRING*/ },
+ ]);
+ }
+ create(value?: PartialMessage): CheckPubKeyRequest {
+ const message = { toCheck: '' };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckPubKeyRequest,
+ ): CheckPubKeyRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* string to_check */ 1:
+ message.toCheck = reader.string();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckPubKeyRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* string to_check = 1; */
+ if (message.toCheck !== '')
+ writer.tag(1, WireType.LengthDelimited).string(message.toCheck);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckPubKeyRequest
+ */
+export const CheckPubKeyRequest = new CheckPubKeyRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckPubKeyResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckPubKeyResult', [
+ { no: 1, name: 'is_valid', kind: 'scalar', T: 8 /* ScalarType.BOOL*/ },
+ ]);
+ }
+ create(value?: PartialMessage): CheckPubKeyResult {
+ const message = { isValid: false };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckPubKeyResult,
+ ): CheckPubKeyResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* bool is_valid */ 1:
+ message.isValid = reader.bool();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckPubKeyResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* bool is_valid = 1; */
+ if (message.isValid !== false)
+ writer.tag(1, WireType.Varint).bool(message.isValid);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckPubKeyResult
+ */
+export const CheckPubKeyResult = new CheckPubKeyResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckSigRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckSigRequest', [
+ { no: 1, name: 'to_check', kind: 'scalar', T: 9 /* ScalarType.STRING*/ },
+ ]);
+ }
+ create(value?: PartialMessage): CheckSigRequest {
+ const message = { toCheck: '' };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckSigRequest,
+ ): CheckSigRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* string to_check */ 1:
+ message.toCheck = reader.string();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckSigRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* string to_check = 1; */
+ if (message.toCheck !== '')
+ writer.tag(1, WireType.LengthDelimited).string(message.toCheck);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckSigRequest
+ */
+export const CheckSigRequest = new CheckSigRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckSigResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckSigResult', [
+ { no: 1, name: 'is_valid', kind: 'scalar', T: 8 /* ScalarType.BOOL*/ },
+ ]);
+ }
+ create(value?: PartialMessage): CheckSigResult {
+ const message = { isValid: false };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckSigResult,
+ ): CheckSigResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* bool is_valid */ 1:
+ message.isValid = reader.bool();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckSigResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* bool is_valid = 1; */
+ if (message.isValid !== false)
+ writer.tag(1, WireType.Varint).bool(message.isValid);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckSigResult
+ */
+export const CheckSigResult = new CheckSigResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckNativeAmountRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckNativeAmountRequest', [
+ { no: 1, name: 'to_check', kind: 'message', T: () => NativeAmount },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): CheckNativeAmountRequest {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckNativeAmountRequest,
+ ): CheckNativeAmountRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeAmount to_check */ 1:
+ message.toCheck = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.toCheck,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckNativeAmountRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeAmount to_check = 1; */
+ if (message.toCheck)
+ NativeAmount.internalBinaryWrite(
+ message.toCheck,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckNativeAmountRequest
+ */
+export const CheckNativeAmountRequest = new CheckNativeAmountRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckNativeAmountResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckNativeAmountResult', [
+ { no: 1, name: 'is_valid', kind: 'scalar', T: 8 /* ScalarType.BOOL*/ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): CheckNativeAmountResult {
+ const message = { isValid: false };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckNativeAmountResult,
+ ): CheckNativeAmountResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* bool is_valid */ 1:
+ message.isValid = reader.bool();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckNativeAmountResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* bool is_valid = 1; */
+ if (message.isValid !== false)
+ writer.tag(1, WireType.Varint).bool(message.isValid);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckNativeAmountResult
+ */
+export const CheckNativeAmountResult = new CheckNativeAmountResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AddNativeAmountRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.AddNativeAmountRequest', [
+ { no: 1, name: 'amount1', kind: 'message', T: () => NativeAmount },
+ { no: 2, name: 'amount2', kind: 'message', T: () => NativeAmount },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): AddNativeAmountRequest {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: AddNativeAmountRequest,
+ ): AddNativeAmountRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeAmount amount1 */ 1:
+ message.amount1 = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.amount1,
+ );
+ break;
+ case /* massa.model.v1.NativeAmount amount2 */ 2:
+ message.amount2 = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.amount2,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: AddNativeAmountRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeAmount amount1 = 1; */
+ if (message.amount1)
+ NativeAmount.internalBinaryWrite(
+ message.amount1,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.model.v1.NativeAmount amount2 = 2; */
+ if (message.amount2)
+ NativeAmount.internalBinaryWrite(
+ message.amount2,
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.AddNativeAmountRequest
+ */
+export const AddNativeAmountRequest = new AddNativeAmountRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AddNativeAmountResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.AddNativeAmountResult', [
+ { no: 1, name: 'sum', kind: 'message', T: () => NativeAmount },
+ ]);
+ }
+ create(value?: PartialMessage): AddNativeAmountResult {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: AddNativeAmountResult,
+ ): AddNativeAmountResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeAmount sum */ 1:
+ message.sum = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.sum,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: AddNativeAmountResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeAmount sum = 1; */
+ if (message.sum)
+ NativeAmount.internalBinaryWrite(
+ message.sum,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.AddNativeAmountResult
+ */
+export const AddNativeAmountResult = new AddNativeAmountResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SubNativeAmountRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.SubNativeAmountRequest', [
+ { no: 1, name: 'left', kind: 'message', T: () => NativeAmount },
+ { no: 2, name: 'right', kind: 'message', T: () => NativeAmount },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): SubNativeAmountRequest {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: SubNativeAmountRequest,
+ ): SubNativeAmountRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeAmount left */ 1:
+ message.left = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.left,
+ );
+ break;
+ case /* massa.model.v1.NativeAmount right */ 2:
+ message.right = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.right,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: SubNativeAmountRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeAmount left = 1; */
+ if (message.left)
+ NativeAmount.internalBinaryWrite(
+ message.left,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.model.v1.NativeAmount right = 2; */
+ if (message.right)
+ NativeAmount.internalBinaryWrite(
+ message.right,
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.SubNativeAmountRequest
+ */
+export const SubNativeAmountRequest = new SubNativeAmountRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SubNativeAmountResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.SubNativeAmountResult', [
+ { no: 1, name: 'difference', kind: 'message', T: () => NativeAmount },
+ ]);
+ }
+ create(value?: PartialMessage): SubNativeAmountResult {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: SubNativeAmountResult,
+ ): SubNativeAmountResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeAmount difference */ 1:
+ message.difference = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.difference,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: SubNativeAmountResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeAmount difference = 1; */
+ if (message.difference)
+ NativeAmount.internalBinaryWrite(
+ message.difference,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.SubNativeAmountResult
+ */
+export const SubNativeAmountResult = new SubNativeAmountResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ScalarMulNativeAmountRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.ScalarMulNativeAmountRequest', [
+ { no: 1, name: 'amount', kind: 'message', T: () => NativeAmount },
+ {
+ no: 2,
+ name: 'coefficient',
+ kind: 'scalar',
+ T: 4 /* ScalarType.UINT64*/,
+ L: 0 /* LongType.BIGINT*/,
+ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): ScalarMulNativeAmountRequest {
+ const message = { coefficient: 0n };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(
+ this,
+ message,
+ value,
+ );
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: ScalarMulNativeAmountRequest,
+ ): ScalarMulNativeAmountRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeAmount amount */ 1:
+ message.amount = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.amount,
+ );
+ break;
+ case /* uint64 coefficient */ 2:
+ message.coefficient = reader.uint64().toBigInt();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: ScalarMulNativeAmountRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeAmount amount = 1; */
+ if (message.amount)
+ NativeAmount.internalBinaryWrite(
+ message.amount,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* uint64 coefficient = 2; */
+ if (message.coefficient !== 0n)
+ writer.tag(2, WireType.Varint).uint64(message.coefficient);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.ScalarMulNativeAmountRequest
+ */
+export const ScalarMulNativeAmountRequest =
+ new ScalarMulNativeAmountRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ScalarMulNativeAmountResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.ScalarMulNativeAmountResult', [
+ { no: 1, name: 'product', kind: 'message', T: () => NativeAmount },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): ScalarMulNativeAmountResult {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: ScalarMulNativeAmountResult,
+ ): ScalarMulNativeAmountResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeAmount product */ 1:
+ message.product = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.product,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: ScalarMulNativeAmountResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeAmount product = 1; */
+ if (message.product)
+ NativeAmount.internalBinaryWrite(
+ message.product,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.ScalarMulNativeAmountResult
+ */
+export const ScalarMulNativeAmountResult =
+ new ScalarMulNativeAmountResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ScalarDivRemNativeAmountRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.ScalarDivRemNativeAmountRequest', [
+ { no: 1, name: 'dividend', kind: 'message', T: () => NativeAmount },
+ {
+ no: 2,
+ name: 'divisor',
+ kind: 'scalar',
+ T: 4 /* ScalarType.UINT64*/,
+ L: 0 /* LongType.BIGINT*/,
+ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): ScalarDivRemNativeAmountRequest {
+ const message = { divisor: 0n };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(
+ this,
+ message,
+ value,
+ );
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: ScalarDivRemNativeAmountRequest,
+ ): ScalarDivRemNativeAmountRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeAmount dividend */ 1:
+ message.dividend = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.dividend,
+ );
+ break;
+ case /* uint64 divisor */ 2:
+ message.divisor = reader.uint64().toBigInt();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: ScalarDivRemNativeAmountRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeAmount dividend = 1; */
+ if (message.dividend)
+ NativeAmount.internalBinaryWrite(
+ message.dividend,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* uint64 divisor = 2; */
+ if (message.divisor !== 0n)
+ writer.tag(2, WireType.Varint).uint64(message.divisor);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.ScalarDivRemNativeAmountRequest
+ */
+export const ScalarDivRemNativeAmountRequest =
+ new ScalarDivRemNativeAmountRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ScalarDivRemNativeAmountResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.ScalarDivRemNativeAmountResult', [
+ { no: 1, name: 'quotient', kind: 'message', T: () => NativeAmount },
+ { no: 2, name: 'remainder', kind: 'message', T: () => NativeAmount },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): ScalarDivRemNativeAmountResult {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(
+ this,
+ message,
+ value,
+ );
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: ScalarDivRemNativeAmountResult,
+ ): ScalarDivRemNativeAmountResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeAmount quotient */ 1:
+ message.quotient = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.quotient,
+ );
+ break;
+ case /* massa.model.v1.NativeAmount remainder */ 2:
+ message.remainder = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.remainder,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: ScalarDivRemNativeAmountResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeAmount quotient = 1; */
+ if (message.quotient)
+ NativeAmount.internalBinaryWrite(
+ message.quotient,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.model.v1.NativeAmount remainder = 2; */
+ if (message.remainder)
+ NativeAmount.internalBinaryWrite(
+ message.remainder,
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.ScalarDivRemNativeAmountResult
+ */
+export const ScalarDivRemNativeAmountResult =
+ new ScalarDivRemNativeAmountResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DivRemNativeAmountRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.DivRemNativeAmountRequest', [
+ { no: 1, name: 'dividend', kind: 'message', T: () => NativeAmount },
+ { no: 2, name: 'divisor', kind: 'message', T: () => NativeAmount },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): DivRemNativeAmountRequest {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: DivRemNativeAmountRequest,
+ ): DivRemNativeAmountRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeAmount dividend */ 1:
+ message.dividend = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.dividend,
+ );
+ break;
+ case /* massa.model.v1.NativeAmount divisor */ 2:
+ message.divisor = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.divisor,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: DivRemNativeAmountRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeAmount dividend = 1; */
+ if (message.dividend)
+ NativeAmount.internalBinaryWrite(
+ message.dividend,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.model.v1.NativeAmount divisor = 2; */
+ if (message.divisor)
+ NativeAmount.internalBinaryWrite(
+ message.divisor,
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.DivRemNativeAmountRequest
+ */
+export const DivRemNativeAmountRequest = new DivRemNativeAmountRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DivRemNativeAmountResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.DivRemNativeAmountResult', [
+ {
+ no: 1,
+ name: 'quotient',
+ kind: 'scalar',
+ T: 4 /* ScalarType.UINT64*/,
+ L: 0 /* LongType.BIGINT*/,
+ },
+ { no: 2, name: 'remainder', kind: 'message', T: () => NativeAmount },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): DivRemNativeAmountResult {
+ const message = { quotient: 0n };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: DivRemNativeAmountResult,
+ ): DivRemNativeAmountResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* uint64 quotient */ 1:
+ message.quotient = reader.uint64().toBigInt();
+ break;
+ case /* massa.model.v1.NativeAmount remainder */ 2:
+ message.remainder = NativeAmount.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.remainder,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: DivRemNativeAmountResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* uint64 quotient = 1; */
+ if (message.quotient !== 0n)
+ writer.tag(1, WireType.Varint).uint64(message.quotient);
+ /* massa.model.v1.NativeAmount remainder = 2; */
+ if (message.remainder)
+ NativeAmount.internalBinaryWrite(
+ message.remainder,
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.DivRemNativeAmountResult
+ */
+export const DivRemNativeAmountResult = new DivRemNativeAmountResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckedAddNativeTimeRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckedAddNativeTimeRequest', [
+ { no: 1, name: 'left', kind: 'message', T: () => NativeTime },
+ { no: 2, name: 'right', kind: 'message', T: () => NativeTime },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): CheckedAddNativeTimeRequest {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckedAddNativeTimeRequest,
+ ): CheckedAddNativeTimeRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeTime left */ 1:
+ message.left = NativeTime.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.left,
+ );
+ break;
+ case /* massa.model.v1.NativeTime right */ 2:
+ message.right = NativeTime.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.right,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckedAddNativeTimeRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeTime left = 1; */
+ if (message.left)
+ NativeTime.internalBinaryWrite(
+ message.left,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.model.v1.NativeTime right = 2; */
+ if (message.right)
+ NativeTime.internalBinaryWrite(
+ message.right,
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckedAddNativeTimeRequest
+ */
+export const CheckedAddNativeTimeRequest =
+ new CheckedAddNativeTimeRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckedAddNativeTimeResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckedAddNativeTimeResult', [
+ { no: 1, name: 'sum', kind: 'message', T: () => NativeTime },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): CheckedAddNativeTimeResult {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckedAddNativeTimeResult,
+ ): CheckedAddNativeTimeResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeTime sum */ 1:
+ message.sum = NativeTime.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.sum,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckedAddNativeTimeResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeTime sum = 1; */
+ if (message.sum)
+ NativeTime.internalBinaryWrite(
+ message.sum,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckedAddNativeTimeResult
+ */
+export const CheckedAddNativeTimeResult = new CheckedAddNativeTimeResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckedSubNativeTimeRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckedSubNativeTimeRequest', [
+ { no: 1, name: 'left', kind: 'message', T: () => NativeTime },
+ { no: 2, name: 'right', kind: 'message', T: () => NativeTime },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): CheckedSubNativeTimeRequest {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckedSubNativeTimeRequest,
+ ): CheckedSubNativeTimeRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeTime left */ 1:
+ message.left = NativeTime.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.left,
+ );
+ break;
+ case /* massa.model.v1.NativeTime right */ 2:
+ message.right = NativeTime.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.right,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckedSubNativeTimeRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeTime left = 1; */
+ if (message.left)
+ NativeTime.internalBinaryWrite(
+ message.left,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* massa.model.v1.NativeTime right = 2; */
+ if (message.right)
+ NativeTime.internalBinaryWrite(
+ message.right,
+ writer.tag(2, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckedSubNativeTimeRequest
+ */
+export const CheckedSubNativeTimeRequest =
+ new CheckedSubNativeTimeRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckedSubNativeTimeResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckedSubNativeTimeResult', [
+ { no: 1, name: 'difference', kind: 'message', T: () => NativeTime },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): CheckedSubNativeTimeResult {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(this, message, value);
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckedSubNativeTimeResult,
+ ): CheckedSubNativeTimeResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeTime difference */ 1:
+ message.difference = NativeTime.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.difference,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckedSubNativeTimeResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeTime difference = 1; */
+ if (message.difference)
+ NativeTime.internalBinaryWrite(
+ message.difference,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckedSubNativeTimeResult
+ */
+export const CheckedSubNativeTimeResult = new CheckedSubNativeTimeResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckedScalarMulNativeTimeRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckedScalarMulNativeTimeRequest', [
+ { no: 1, name: 'time', kind: 'message', T: () => NativeTime },
+ {
+ no: 2,
+ name: 'coefficient',
+ kind: 'scalar',
+ T: 4 /* ScalarType.UINT64*/,
+ L: 0 /* LongType.BIGINT*/,
+ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): CheckedScalarMulNativeTimeRequest {
+ const message = { coefficient: 0n };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(
+ this,
+ message,
+ value,
+ );
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckedScalarMulNativeTimeRequest,
+ ): CheckedScalarMulNativeTimeRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeTime time */ 1:
+ message.time = NativeTime.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.time,
+ );
+ break;
+ case /* uint64 coefficient */ 2:
+ message.coefficient = reader.uint64().toBigInt();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckedScalarMulNativeTimeRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeTime time = 1; */
+ if (message.time)
+ NativeTime.internalBinaryWrite(
+ message.time,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* uint64 coefficient = 2; */
+ if (message.coefficient !== 0n)
+ writer.tag(2, WireType.Varint).uint64(message.coefficient);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckedScalarMulNativeTimeRequest
+ */
+export const CheckedScalarMulNativeTimeRequest =
+ new CheckedScalarMulNativeTimeRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckedScalarMulNativeTimeResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckedScalarMulNativeTimeResult', [
+ { no: 1, name: 'product', kind: 'message', T: () => NativeTime },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): CheckedScalarMulNativeTimeResult {
+ const message = {};
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(
+ this,
+ message,
+ value,
+ );
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckedScalarMulNativeTimeResult,
+ ): CheckedScalarMulNativeTimeResult {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeTime product */ 1:
+ message.product = NativeTime.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.product,
+ );
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckedScalarMulNativeTimeResult,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeTime product = 1; */
+ if (message.product)
+ NativeTime.internalBinaryWrite(
+ message.product,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckedScalarMulNativeTimeResult
+ */
+export const CheckedScalarMulNativeTimeResult =
+ new CheckedScalarMulNativeTimeResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckedScalarDivRemNativeTimeRequest$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckedScalarDivRemNativeTimeRequest', [
+ { no: 1, name: 'dividend', kind: 'message', T: () => NativeTime },
+ {
+ no: 2,
+ name: 'divisor',
+ kind: 'scalar',
+ T: 4 /* ScalarType.UINT64*/,
+ L: 0 /* LongType.BIGINT*/,
+ },
+ ]);
+ }
+ create(
+ value?: PartialMessage,
+ ): CheckedScalarDivRemNativeTimeRequest {
+ const message = { divisor: 0n };
+ globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+ enumerable: false,
+ value: this,
+ });
+ if (value !== undefined)
+ reflectionMergePartial(
+ this,
+ message,
+ value,
+ );
+ return message;
+ }
+ internalBinaryRead(
+ reader: IBinaryReader,
+ length: number,
+ options: BinaryReadOptions,
+ target?: CheckedScalarDivRemNativeTimeRequest,
+ ): CheckedScalarDivRemNativeTimeRequest {
+ let message = target ?? this.create();
+ let end = reader.pos + length;
+ while (reader.pos < end) {
+ let [fieldNo, wireType] = reader.tag();
+ switch (fieldNo) {
+ case /* massa.model.v1.NativeTime dividend */ 1:
+ message.dividend = NativeTime.internalBinaryRead(
+ reader,
+ reader.uint32(),
+ options,
+ message.dividend,
+ );
+ break;
+ case /* uint64 divisor */ 2:
+ message.divisor = reader.uint64().toBigInt();
+ break;
+ default:
+ let u = options.readUnknownField;
+ if (u === 'throw')
+ throw new globalThis.Error(
+ `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+ );
+ let d = reader.skip(wireType);
+ if (u !== false)
+ (u === true ? UnknownFieldHandler.onRead : u)(
+ this.typeName,
+ message,
+ fieldNo,
+ wireType,
+ d,
+ );
+ }
+ }
+ return message;
+ }
+ internalBinaryWrite(
+ message: CheckedScalarDivRemNativeTimeRequest,
+ writer: IBinaryWriter,
+ options: BinaryWriteOptions,
+ ): IBinaryWriter {
+ /* massa.model.v1.NativeTime dividend = 1; */
+ if (message.dividend)
+ NativeTime.internalBinaryWrite(
+ message.dividend,
+ writer.tag(1, WireType.LengthDelimited).fork(),
+ options,
+ ).join();
+ /* uint64 divisor = 2; */
+ if (message.divisor !== 0n)
+ writer.tag(2, WireType.Varint).uint64(message.divisor);
+ let u = options.writeUnknownFields;
+ if (u !== false)
+ (u == true ? UnknownFieldHandler.onWrite : u)(
+ this.typeName,
+ message,
+ writer,
+ );
+ return writer;
+ }
+}
+/**
+ * @generated MessageType for protobuf message massa.abi.v1.CheckedScalarDivRemNativeTimeRequest
+ */
+export const CheckedScalarDivRemNativeTimeRequest =
+ new CheckedScalarDivRemNativeTimeRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CheckedScalarDivRemNativeTimeResult$Type extends MessageType {
+ constructor() {
+ super('massa.abi.v1.CheckedScalarDivRemNativeTimeResult', [
+ { no: 1, name: 'quotient', kind: 'message', T: () => NativeTime },
+ { no: 2, name: 'remainder', kind: 'message', T: () => NativeTime },
+ ]);
+ }
+ create(
+ value?: PartialMessage