@bufbuild/protobuf 1.9.0 → 2.0.0-alpha.1

package/dist/cjs/wire/size-delimited.js

@@ -0,0 +1,154 @@
+"use strict";
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sizeDelimitedPeek = exports.sizeDelimitedDecodeStream = exports.sizeDelimitedEncode = void 0;
+const to_binary_js_1 = require("../to-binary.js");
+const binary_encoding_js_1 = require("./binary-encoding.js");
+const from_binary_js_1 = require("../from-binary.js");
+/**
+ * Serialize a message, prefixing it with its size.
+ *
+ * A size-delimited message is a varint size in bytes, followed by exactly
+ * that many bytes of a message serialized with the binary format.
+ *
+ * This size-delimited format is compatible with other implementations.
+ * For details, see https://github.com/protocolbuffers/protobuf/issues/10229
+ */
+function sizeDelimitedEncode(messageDesc, message, options) {
+    const writer = new binary_encoding_js_1.BinaryWriter();
+    writer.bytes((0, to_binary_js_1.toBinary)(messageDesc, message, options));
+    return writer.finish();
+}
+exports.sizeDelimitedEncode = sizeDelimitedEncode;
+/**
+ * Parse a stream of size-delimited messages.
+ *
+ * A size-delimited message is a varint size in bytes, followed by exactly
+ * that many bytes of a message serialized with the binary format.
+ *
+ * This size-delimited format is compatible with other implementations.
+ * For details, see https://github.com/protocolbuffers/protobuf/issues/10229
+ */
+function sizeDelimitedDecodeStream(messageDesc, iterable, options) {
+    return __asyncGenerator(this, arguments, function* sizeDelimitedDecodeStream_1() {
+        var _a, e_1, _b, _c;
+        // append chunk to buffer, returning updated buffer
+        function append(buffer, chunk) {
+            const n = new Uint8Array(buffer.byteLength + chunk.byteLength);
+            n.set(buffer);
+            n.set(chunk, buffer.length);
+            return n;
+        }
+        let buffer = new Uint8Array(0);
+        try {
+            for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = yield __await(iterable_1.next()), _a = iterable_1_1.done, !_a; _d = true) {
+                _c = iterable_1_1.value;
+                _d = false;
+                const chunk = _c;
+                buffer = append(buffer, chunk);
+                for (;;) {
+                    const size = sizeDelimitedPeek(buffer);
+                    if (size.eof) {
+                        // size is incomplete, buffer more data
+                        break;
+                    }
+                    if (size.offset + size.size > buffer.byteLength) {
+                        // message is incomplete, buffer more data
+                        break;
+                    }
+                    yield yield __await((0, from_binary_js_1.fromBinary)(messageDesc, buffer.subarray(size.offset, size.offset + size.size), options));
+                    buffer = buffer.subarray(size.offset + size.size);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = iterable_1.return)) yield __await(_b.call(iterable_1));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (buffer.byteLength > 0) {
+            throw new Error("incomplete data");
+        }
+    });
+}
+exports.sizeDelimitedDecodeStream = sizeDelimitedDecodeStream;
+/**
+ * Decodes the size from the given size-delimited message, which may be
+ * incomplete.
+ *
+ * Returns an object with the following properties:
+ * - size: The size of the delimited message in bytes
+ * - offset: The offset in the given byte array where the message starts
+ * - eof: true
+ *
+ * If the size-delimited data does not include all bytes of the varint size,
+ * the following object is returned:
+ * - size: null
+ * - offset: null
+ * - eof: false
+ *
+ * This function can be used to implement parsing of size-delimited messages
+ * from a stream.
+ */
+function sizeDelimitedPeek(data) {
+    const sizeEof = { eof: true, size: null, offset: null };
+    for (let i = 0; i < 10; i++) {
+        if (i > data.byteLength) {
+            return sizeEof;
+        }
+        if ((data[i] & 0x80) == 0) {
+            const reader = new binary_encoding_js_1.BinaryReader(data);
+            let size;
+            try {
+                size = reader.uint32();
+            }
+            catch (e) {
+                if (e instanceof RangeError) {
+                    return sizeEof;
+                }
+                throw e;
+            }
+            return {
+                eof: false,
+                size,
+                offset: reader.pos,
+            };
+        }
+    }
+    throw new Error("invalid varint");
+}
+exports.sizeDelimitedPeek = sizeDelimitedPeek;

package/dist/cjs/wire/text-encoding.d.ts

@@ -0,0 +1,26 @@
+interface TextEncoding {
+    /**
+     * Verify that the given text is valid UTF-8.
+     */
+    checkUtf8: (text: string) => boolean;
+    /**
+     * Encode UTF-8 text to binary.
+     */
+    encodeUtf8: (text: string) => Uint8Array;
+    /**
+     * Decode UTF-8 text from binary.
+     */
+    decodeUtf8: (bytes: Uint8Array) => string;
+}
+/**
+ * Protobuf-ES requires the Text Encoding API to convert UTF-8 from and to
+ * binary. This WHATWG API is widely available, but it is not part of the
+ * ECMAScript standard. On runtimes where it is not available, use this
+ * function to provide your own implementation.
+ *
+ * Note that the Text Encoding API does not provide a way to validate UTF-8.
+ * Our implementation falls back to use encodeURIComponent().
+ */
+export declare function configureTextEncoding(textEncoding: TextEncoding): void;
+export declare function getTextEncoding(): TextEncoding;
+export {};

package/dist/cjs/wire/text-encoding.js

@@ -0,0 +1,55 @@
+"use strict";
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTextEncoding = exports.configureTextEncoding = void 0;
+const symbol = Symbol.for("@bufbuild/protobuf/text-encoding");
+/**
+ * Protobuf-ES requires the Text Encoding API to convert UTF-8 from and to
+ * binary. This WHATWG API is widely available, but it is not part of the
+ * ECMAScript standard. On runtimes where it is not available, use this
+ * function to provide your own implementation.
+ *
+ * Note that the Text Encoding API does not provide a way to validate UTF-8.
+ * Our implementation falls back to use encodeURIComponent().
+ */
+function configureTextEncoding(textEncoding) {
+    globalThis[symbol] = textEncoding;
+}
+exports.configureTextEncoding = configureTextEncoding;
+function getTextEncoding() {
+    if (globalThis[symbol] == undefined) {
+        const te = new globalThis.TextEncoder();
+        const td = new globalThis.TextDecoder();
+        globalThis[symbol] = {
+            encodeUtf8(text) {
+                return te.encode(text);
+            },
+            decodeUtf8(bytes) {
+                return td.decode(bytes);
+            },
+            checkUtf8(text) {
+                try {
+                    encodeURIComponent(text);
+                    return true;
+                }
+                catch (e) {
+                    return false;
+                }
+            },
+        };
+    }
+    return globalThis[symbol];
+}
+exports.getTextEncoding = getTextEncoding;

package/dist/cjs/wire/text-format.d.ts

@@ -0,0 +1,14 @@
+import type { DescEnum } from "../desc-types.js";
+import { ScalarType } from "../reflect/scalar.js";
+/**
+ * Parse an enum value from the Protobuf text format.
+ *
+ * @private
+ */
+export declare function parseTextFormatEnumValue(descEnum: DescEnum, value: string): number;
+/**
+ * Parse a scalar value from the Protobuf text format.
+ *
+ * @private
+ */
+export declare function parseTextFormatScalarValue(type: ScalarType, value: string): number | boolean | string | bigint | Uint8Array;

package/dist/cjs/{private → wire}/text-format.js

@@ -14,15 +14,25 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTextFormatScalarValue = exports.parseTextFormatEnumValue = void 0;
-const assert_js_1 = require("./assert.js");
+const assert_js_1 = require("../reflect/assert.js");
 const proto_int64_js_1 = require("../proto-int64.js");
-const scalar_js_1 = require("../scalar.js");
+const scalar_js_1 = require("../reflect/scalar.js");
+/**
+ * Parse an enum value from the Protobuf text format.
+ *
+ * @private
+ */
 function parseTextFormatEnumValue(descEnum, value) {
     const enumValue = descEnum.values.find((v) => v.name === value);
     (0, assert_js_1.assert)(enumValue, `cannot parse ${descEnum.name} default value: ${value}`);
     return enumValue.number;
 }
 exports.parseTextFormatEnumValue = parseTextFormatEnumValue;
+/**
+ * Parse a scalar value from the Protobuf text format.
+ *
+ * @private
+ */
 function parseTextFormatScalarValue(type, value) {
     switch (type) {
         case scalar_js_1.ScalarType.STRING:

package/dist/{esm/google → cjs/wire}/varint.d.ts

@@ -9,7 +9,7 @@
  *
  * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175
  */
-export declare function varint64read(this: ReaderLike): [number, number];
+export declare function varint64read<T extends ReaderLike>(this: T): [number, number];
 /**
  * Write a 64 bit varint, given as two JS numbers, to the given bytes array.
  *
@@ -60,7 +60,7 @@ export declare function varint32write(value: number, bytes: number[]): void;
  *
  * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
  */
-export declare function varint32read(this: ReaderLike): number;
+export declare function varint32read<T extends ReaderLike>(this: T): number;
 type ReaderLike = {
     buf: Uint8Array;
     pos: number;

package/dist/cjs/{google → wire}/varint.js

@@ -162,7 +162,7 @@ function int64ToString(lo, hi) {
     let bits = newBits(lo, hi);
     // If we're treating the input as a signed value and the high bit is set, do
     // a manual two's complement conversion before the decimal conversion.
-    const negative = (bits.hi & 0x80000000);
+    const negative = bits.hi & 0x80000000;
     if (negative) {
         bits = negate(bits.lo, bits.hi);
     }
@@ -186,7 +186,7 @@ function uInt64ToString(lo, hi) {
     // highBits <= 0x1FFFFF can be safely expressed with a double and retain
     // integer precision.
     // Proven by: Number.isSafeInteger(0x1FFFFF * 2**32 + 0xFFFFFFFF) == true.
-    if (hi <= 0x1FFFFF) {
+    if (hi <= 0x1fffff) {
         return String(TWO_PWR_32_DBL * hi + lo);
     }
     // What this code is doing is essentially converting the input number from
@@ -198,15 +198,15 @@ function uInt64ToString(lo, hi) {
     // 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7.
     // Split 32:32 representation into 16:24:24 representation so our
     // intermediate digits don't overflow.
-    const low = lo & 0xFFFFFF;
-    const mid = ((lo >>> 24) | (hi << 8)) & 0xFFFFFF;
-    const high = (hi >> 16) & 0xFFFF;
+    const low = lo & 0xffffff;
+    const mid = ((lo >>> 24) | (hi << 8)) & 0xffffff;
+    const high = (hi >> 16) & 0xffff;
     // Assemble our three base-1e7 digits, ignoring carries. The maximum
     // value in a digit at this step is representable as a 48-bit integer, which
     // can be stored in a 64-bit floating point number.
-    let digitA = low + (mid * 6777216) + (high * 6710656);
-    let digitB = mid + (high * 8147497);
-    let digitC = (high * 2);
+    let digitA = low + mid * 6777216 + high * 6710656;
+    let digitB = mid + high * 8147497;
+    let digitC = high * 2;
     // Apply carries from A to B and from B to C.
     const base = 10000000;
     if (digitA >= base) {
@@ -220,8 +220,9 @@ function uInt64ToString(lo, hi) {
     // If digitC is 0, then we should have returned in the trivial code path
     // at the top for non-safe integers. Given this, we can assume both digitB
     // and digitA need leading zeros.
-    return digitC.toString() + decimalFrom1e7WithLeadingZeros(digitB) +
-        decimalFrom1e7WithLeadingZeros(digitA);
+    return (digitC.toString() +
+        decimalFrom1e7WithLeadingZeros(digitB) +
+        decimalFrom1e7WithLeadingZeros(digitA));
 }
 exports.uInt64ToString = uInt64ToString;
 function toUnsigned(lo, hi) {

package/dist/cjs/wkt/any.d.ts

@@ -0,0 +1,38 @@
+import type { Message, MessageShape } from "../types.js";
+import type { Any } from "./gen/google/protobuf/any_pb.js";
+import type { DescMessage } from "../desc-types.js";
+import type { Registry } from "../reflect/index.js";
+/**
+ * Creates a `google.protobuf.Any` from a message.
+ */
+export declare function anyPack<Desc extends DescMessage>(messageDesc: Desc, message: MessageShape<Desc>): Any;
+/**
+ * Packs the message into the given any.
+ */
+export declare function anyPack<Desc extends DescMessage>(messageDesc: Desc, message: MessageShape<Desc>, into: Any): void;
+/**
+ * Returns true if the Any contains the type given by messageDesc.
+ */
+export declare function anyIs(any: Any, messageDesc: DescMessage): boolean;
+/**
+ * Returns true if the Any contains a message with the given typeName.
+ */
+export declare function anyIs(any: Any, typeName: string): boolean;
+/**
+ * Unpacks the message the Any represents.
+ *
+ * Returns undefined if the Any is empty, or if packed type is not included
+ * in the given registry.
+ */
+export declare function anyUnpack(any: Any, registry: Registry): Message | undefined;
+/**
+ * Unpacks the message the Any represents.
+ *
+ * Returns undefined if the Any is empty, or if it does not contain the type
+ * given by messageDesc.
+ */
+export declare function anyUnpack<Desc extends DescMessage>(any: Any, messageDesc: Desc): MessageShape<Desc> | undefined;
+/**
+ * Same as anyUnpack but unpacks into the target message.
+ */
+export declare function anyUnpackTo<Desc extends DescMessage>(any: Any, messageDesc: Desc, message: MessageShape<Desc>): MessageShape<Desc> | undefined;

package/dist/cjs/wkt/any.js

@@ -0,0 +1,76 @@
+"use strict";
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anyUnpackTo = exports.anyUnpack = exports.anyIs = exports.anyPack = void 0;
+const any_pb_js_1 = require("./gen/google/protobuf/any_pb.js");
+const create_js_1 = require("../create.js");
+const to_binary_js_1 = require("../to-binary.js");
+const from_binary_js_1 = require("../from-binary.js");
+function anyPack(messageDesc, message, into) {
+    let ret = false;
+    if (!into) {
+        into = (0, create_js_1.create)(any_pb_js_1.AnyDesc);
+        ret = true;
+    }
+    into.value = (0, to_binary_js_1.toBinary)(messageDesc, message);
+    into.typeUrl = typeNameToUrl(message.$typeName);
+    return ret ? into : undefined;
+}
+exports.anyPack = anyPack;
+function anyIs(any, descOrTypeName) {
+    if (any.typeUrl === "") {
+        return false;
+    }
+    const want = typeof descOrTypeName == "string"
+        ? descOrTypeName
+        : descOrTypeName.typeName;
+    const got = typeUrlToName(any.typeUrl);
+    return want === got;
+}
+exports.anyIs = anyIs;
+function anyUnpack(any, registryOrMessageDesc) {
+    if (any.typeUrl === "") {
+        return undefined;
+    }
+    const desc = registryOrMessageDesc.kind == "message"
+        ? registryOrMessageDesc
+        : registryOrMessageDesc.getMessage(typeUrlToName(any.typeUrl));
+    if (!desc) {
+        return undefined;
+    }
+    return (0, from_binary_js_1.fromBinary)(desc, any.value);
+}
+exports.anyUnpack = anyUnpack;
+/**
+ * Same as anyUnpack but unpacks into the target message.
+ */
+function anyUnpackTo(any, messageDesc, message) {
+    if (any.typeUrl === "") {
+        return undefined;
+    }
+    return (0, from_binary_js_1.mergeFromBinary)(messageDesc, message, any.value);
+}
+exports.anyUnpackTo = anyUnpackTo;
+function typeNameToUrl(name) {
+    return `type.googleapis.com/${name}`;
+}
+function typeUrlToName(url) {
+    const slash = url.lastIndexOf("/");
+    const name = slash >= 0 ? url.substring(slash + 1) : url;
+    if (!name.length) {
+        throw new Error(`invalid type url: ${url}`);
+    }
+    return name;
+}

package/dist/cjs/{google → wkt/gen/google}/protobuf/any_pb.d.ts

@@ -1,11 +1,6 @@
-import type { PartialMessage, PlainMessage } from "../../message.js";
-import { Message } from "../../message.js";
-import { proto3 } from "../../proto3.js";
-import type { JsonReadOptions, JsonValue, JsonWriteOptions } from "../../json-format.js";
-import type { IMessageTypeRegistry } from "../../type-registry.js";
-import type { MessageType } from "../../message-type.js";
-import type { FieldList } from "../../field-list.js";
-import type { BinaryReadOptions } from "../../binary-format.js";
+import type { GenDescFile, GenDescMessage } from "../../../../codegenv1/types.js";
+import type { Message } from "../../../../types.js";
+export declare const fileDesc_google_protobuf_any: GenDescFile;
 /**
  * `Any` contains an arbitrary serialized protocol buffer message along with a
  * URL that describes the type of the serialized message.
@@ -96,7 +91,7 @@ import type { BinaryReadOptions } from "../../binary-format.js";
  *
  * @generated from message google.protobuf.Any
  */
-export declare class Any extends Message<Any> {
+export type Any = Message<"google.protobuf.Any"> & {
     /**
      * A URL/resource name that uniquely identifies the type of the serialized
      * protocol buffer message. This string must contain at least
@@ -137,21 +132,5 @@ export declare class Any extends Message<Any> {
      * @generated from field: bytes value = 2;
      */
     value: Uint8Array;
-    constructor(data?: PartialMessage<Any>);
-    toJson(options?: Partial<JsonWriteOptions>): JsonValue;
-    fromJson(json: JsonValue, options?: Partial<JsonReadOptions>): this;
-    packFrom(message: Message): void;
-    unpackTo(target: Message): boolean;
-    unpack(registry: IMessageTypeRegistry): Message | undefined;
-    is(type: MessageType | string): boolean;
-    private typeNameToUrl;
-    private typeUrlToName;
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "google.protobuf.Any";
-    static readonly fields: FieldList;
-    static pack(message: Message): Any;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Any;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Any;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Any;
-    static equals(a: Any | PlainMessage<Any> | undefined, b: Any | PlainMessage<Any> | undefined): boolean;
-}
+};
+export declare const AnyDesc: GenDescMessage<Any>;

package/dist/cjs/wkt/gen/google/protobuf/any_pb.js

@@ -0,0 +1,22 @@
+"use strict";
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyDesc = exports.fileDesc_google_protobuf_any = void 0;
+const file_js_1 = require("../../../../codegenv1/file.js");
+const message_js_1 = require("../../../../codegenv1/message.js");
+exports.fileDesc_google_protobuf_any = (0, file_js_1.fileDesc)("Chlnb29nbGUvcHJvdG9idWYvYW55LnByb3RvEg9nb29nbGUucHJvdG9idWYiJgoDQW55EhAKCHR5cGVfdXJsGAEgASgJEg0KBXZhbHVlGAIgASgMQnYKE2NvbS5nb29nbGUucHJvdG9idWZCCEFueVByb3RvUAFaLGdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL2FueXBiogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93blR5cGVzYgZwcm90bzM");
+// Describes the message google.protobuf.Any.
+// Use `create(AnyDesc)` to create a new Any.
+exports.AnyDesc = (0, message_js_1.messageDesc)(exports.fileDesc_google_protobuf_any, 0);

package/dist/cjs/{google → wkt/gen/google}/protobuf/api_pb.d.ts

@@ -1,11 +1,8 @@
-import type { PartialMessage, PlainMessage } from "../../message.js";
-import { Message } from "../../message.js";
-import { Option, Syntax } from "./type_pb.js";
-import { SourceContext } from "./source_context_pb.js";
-import { proto3 } from "../../proto3.js";
-import type { FieldList } from "../../field-list.js";
-import type { BinaryReadOptions } from "../../binary-format.js";
-import type { JsonReadOptions, JsonValue } from "../../json-format.js";
+import type { GenDescFile, GenDescMessage } from "../../../../codegenv1/types.js";
+import type { SourceContext } from "./source_context_pb.js";
+import type { Option, Syntax } from "./type_pb.js";
+import type { Message } from "../../../../types.js";
+export declare const fileDesc_google_protobuf_api: GenDescFile;
 /**
  * Api is a light-weight descriptor for an API Interface.
  *
@@ -19,7 +16,7 @@ import type { JsonReadOptions, JsonValue } from "../../json-format.js";
  *
  * @generated from message google.protobuf.Api
  */
-export declare class Api extends Message<Api> {
+export type Api = Message<"google.protobuf.Api"> & {
     /**
      * The fully qualified name of this interface, including package name
      * followed by the interface's simple name.
@@ -83,21 +80,14 @@ export declare class Api extends Message<Api> {
      * @generated from field: google.protobuf.Syntax syntax = 7;
      */
     syntax: Syntax;
-    constructor(data?: PartialMessage<Api>);
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "google.protobuf.Api";
-    static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Api;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Api;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Api;
-    static equals(a: Api | PlainMessage<Api> | undefined, b: Api | PlainMessage<Api> | undefined): boolean;
-}
+};
+export declare const ApiDesc: GenDescMessage<Api>;
 /**
  * Method represents a method of an API interface.
  *
  * @generated from message google.protobuf.Method
  */
-export declare class Method extends Message<Method> {
+export type Method = Message<"google.protobuf.Method"> & {
     /**
      * The simple name of this method.
      *
@@ -140,15 +130,8 @@ export declare class Method extends Message<Method> {
      * @generated from field: google.protobuf.Syntax syntax = 7;
      */
     syntax: Syntax;
-    constructor(data?: PartialMessage<Method>);
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "google.protobuf.Method";
-    static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Method;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Method;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Method;
-    static equals(a: Method | PlainMessage<Method> | undefined, b: Method | PlainMessage<Method> | undefined): boolean;
-}
+};
+export declare const MethodDesc: GenDescMessage<Method>;
 /**
  * Declares an API Interface to be included in this interface. The including
  * interface must redeclare all the methods from the included interface, but
@@ -231,7 +214,7 @@ export declare class Method extends Message<Method> {
  *
  * @generated from message google.protobuf.Mixin
  */
-export declare class Mixin extends Message<Mixin> {
+export type Mixin = Message<"google.protobuf.Mixin"> & {
     /**
      * The fully qualified name of the interface which is included.
      *
@@ -245,12 +228,5 @@ export declare class Mixin extends Message<Mixin> {
      * @generated from field: string root = 2;
      */
     root: string;
-    constructor(data?: PartialMessage<Mixin>);
-    static readonly runtime: typeof proto3;
-    static readonly typeName = "google.protobuf.Mixin";
-    static readonly fields: FieldList;
-    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Mixin;
-    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Mixin;
-    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Mixin;
-    static equals(a: Mixin | PlainMessage<Mixin> | undefined, b: Mixin | PlainMessage<Mixin> | undefined): boolean;
-}
+};
+export declare const MixinDesc: GenDescMessage<Mixin>;