@bufbuild/protobuf 1.9.0 → 2.0.0-alpha.2

package/dist/esm/proto-base64.js

@@ -1,125 +0,0 @@
-// 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.
-/* eslint-disable @typescript-eslint/ban-ts-comment, @typescript-eslint/no-unnecessary-condition, prefer-const */
-// lookup table from base64 character to byte
-let encTable = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
-// lookup table from base64 character *code* to byte because lookup by number is fast
-let decTable = [];
-for (let i = 0; i < encTable.length; i++)
-    decTable[encTable[i].charCodeAt(0)] = i;
-// support base64url variants
-decTable["-".charCodeAt(0)] = encTable.indexOf("+");
-decTable["_".charCodeAt(0)] = encTable.indexOf("/");
-export const protoBase64 = {
-    /**
-     * Decodes a base64 string to a byte array.
-     *
-     * - ignores white-space, including line breaks and tabs
-     * - allows inner padding (can decode concatenated base64 strings)
-     * - does not require padding
-     * - understands base64url encoding:
-     *   "-" instead of "+",
-     *   "_" instead of "/",
-     *   no padding
-     */
-    dec(base64Str) {
-        // estimate byte size, not accounting for inner padding and whitespace
-        let es = (base64Str.length * 3) / 4;
-        if (base64Str[base64Str.length - 2] == "=")
-            es -= 2;
-        else if (base64Str[base64Str.length - 1] == "=")
-            es -= 1;
-        let bytes = new Uint8Array(es), bytePos = 0, // position in byte array
-        groupPos = 0, // position in base64 group
-        b, // current byte
-        p = 0; // previous byte
-        for (let i = 0; i < base64Str.length; i++) {
-            b = decTable[base64Str.charCodeAt(i)];
-            if (b === undefined) {
-                switch (base64Str[i]) {
-                    // @ts-ignore TS7029: Fallthrough case in switch
-                    case "=":
-                        groupPos = 0; // reset state when padding found
-                    // @ts-ignore TS7029: Fallthrough case in switch
-                    case "\n":
-                    case "\r":
-                    case "\t":
-                    case " ":
-                        continue; // skip white-space, and padding
-                    default:
-                        throw Error("invalid base64 string.");
-                }
-            }
-            switch (groupPos) {
-                case 0:
-                    p = b;
-                    groupPos = 1;
-                    break;
-                case 1:
-                    bytes[bytePos++] = (p << 2) | ((b & 48) >> 4);
-                    p = b;
-                    groupPos = 2;
-                    break;
-                case 2:
-                    bytes[bytePos++] = ((p & 15) << 4) | ((b & 60) >> 2);
-                    p = b;
-                    groupPos = 3;
-                    break;
-                case 3:
-                    bytes[bytePos++] = ((p & 3) << 6) | b;
-                    groupPos = 0;
-                    break;
-            }
-        }
-        if (groupPos == 1)
-            throw Error("invalid base64 string.");
-        return bytes.subarray(0, bytePos);
-    },
-    /**
-     * Encode a byte array to a base64 string.
-     */
-    enc(bytes) {
-        let base64 = "", groupPos = 0, // position in base64 group
-        b, // current byte
-        p = 0; // carry over from previous byte
-        for (let i = 0; i < bytes.length; i++) {
-            b = bytes[i];
-            switch (groupPos) {
-                case 0:
-                    base64 += encTable[b >> 2];
-                    p = (b & 3) << 4;
-                    groupPos = 1;
-                    break;
-                case 1:
-                    base64 += encTable[p | (b >> 4)];
-                    p = (b & 15) << 2;
-                    groupPos = 2;
-                    break;
-                case 2:
-                    base64 += encTable[p | (b >> 6)];
-                    base64 += encTable[b & 63];
-                    groupPos = 0;
-                    break;
-            }
-        }
-        // add output padding
-        if (groupPos) {
-            base64 += encTable[p];
-            base64 += "=";
-            if (groupPos == 1)
-                base64 += "=";
-        }
-        return base64;
-    },
-};

package/dist/esm/proto-delimited.d.ts

@@ -1,54 +0,0 @@
-import type { BinaryReadOptions, BinaryWriteOptions } from "./binary-format.js";
-import type { Message } from "./message.js";
-import type { MessageType } from "./message-type.js";
-/**
- * protoDelimited provides functions to serialize and parse 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
- */
-export declare const protoDelimited: {
-    /**
-     * Serialize a message, prefixing it with its size.
-     */
-    enc(message: Message, options?: BinaryWriteOptions): Uint8Array;
-    /**
-     * Parse a size-delimited message, ignoring extra bytes.
-     */
-    dec<T extends Message<T>>(type: MessageType<T>, bytes: Uint8Array, options?: BinaryReadOptions): T;
-    /**
-     * Parse a stream of size-delimited messages.
-     */
-    decStream<T_1 extends Message<T_1>>(type: MessageType<T_1>, iterable: AsyncIterable<Uint8Array>): AsyncGenerator<T_1, void, unknown>;
-    /**
-     * 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.
-     */
-    peekSize(data: Uint8Array): {
-        readonly eof: false;
-        readonly size: number;
-        readonly offset: number;
-    } | {
-        readonly eof: true;
-        readonly size: null;
-        readonly offset: null;
-    };
-};

package/dist/esm/proto-delimited.js

@@ -1,152 +0,0 @@
-// 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]); }
-};
-import { BinaryReader } from "./binary-encoding.js";
-/**
- * protoDelimited provides functions to serialize and parse 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
- */
-export const protoDelimited = {
-    /**
-     * Serialize a message, prefixing it with its size.
-     */
-    enc(message, options) {
-        const opt = message.getType().runtime.bin.makeWriteOptions(options);
-        return opt.writerFactory().bytes(message.toBinary(opt)).finish();
-    },
-    /**
-     * Parse a size-delimited message, ignoring extra bytes.
-     */
-    dec(type, bytes, options) {
-        const opt = type.runtime.bin.makeReadOptions(options);
-        return type.fromBinary(opt.readerFactory(bytes).bytes(), opt);
-    },
-    /**
-     * Parse a stream of size-delimited messages.
-     */
-    decStream(type, iterable) {
-        return __asyncGenerator(this, arguments, function* decStream_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 = protoDelimited.peekSize(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(protoDelimited.dec(type, buffer));
-                        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");
-            }
-        });
-    },
-    /**
-     * 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.
-     */
-    peekSize(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 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");
-    },
-};

package/dist/esm/proto-double.d.ts

@@ -1,5 +0,0 @@
-export declare const protoDouble: {
-    readonly NaN: number;
-    readonly POSITIVE_INFINITY: number;
-    readonly NEGATIVE_INFINITY: number;
-};

package/dist/esm/proto-double.js

@@ -1,26 +0,0 @@
-// 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.
-// Export global Number constants. This is done so that we can safely use
-// these global constants when generating code and be assured we're using
-// the correct values. We cannot rely on globalThis since we support ES2017
-// and globalThis was introduced in ES2020. We also don't want to explicitly
-// generate code using, for example, Number.NaN, since this could clash with
-// a message name of Number. Instead we can export them here since this will
-// be in a different scope as the generated code and we are guaranteed to use
-// the intended global values.
-export const protoDouble = {
-    NaN: Number.NaN,
-    POSITIVE_INFINITY: Number.POSITIVE_INFINITY,
-    NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
-};

package/dist/esm/proto2.d.ts

@@ -1,4 +0,0 @@
-/**
- * Provides functionality for messages defined with the proto2 syntax.
- */
-export declare const proto2: import("./private/proto-runtime.js").ProtoRuntime;

package/dist/esm/proto2.js

@@ -1,50 +0,0 @@
-// 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.
-import { makeProtoRuntime } from "./private/proto-runtime.js";
-import { InternalFieldList } from "./private/field-list.js";
-import { normalizeFieldInfos } from "./private/field-normalize.js";
-/**
- * Provides functionality for messages defined with the proto2 syntax.
- */
-export const proto2 = makeProtoRuntime("proto2", (fields) => {
-    return new InternalFieldList(fields, (source) => normalizeFieldInfos(source, false));
-}, 
-// TODO merge with proto3 and initExtensionField, also see initPartial, equals, clone
-(target) => {
-    for (const member of target.getType().fields.byMember()) {
-        const name = member.localName, t = target;
-        if (member.repeated) {
-            t[name] = [];
-            continue;
-        }
-        switch (member.kind) {
-            case "oneof":
-                t[name] = { case: undefined };
-                break;
-            case "map":
-                t[name] = {};
-                break;
-            case "scalar":
-            case "enum":
-            case "message":
-                // In contrast to proto3, enum and scalar fields have no intrinsic default value,
-                // only an optional explicit default value.
-                // Unlike proto3 intrinsic default values, proto2 explicit default values are not
-                // set on construction, because they are not omitted on the wire. If we did set
-                // default values on construction, a deserialize-serialize round-trip would add
-                // fields to a message.
-                break;
-        }
-    }
-});

package/dist/esm/proto3.d.ts

@@ -1,4 +0,0 @@
-/**
- * Provides functionality for messages defined with the proto3 syntax.
- */
-export declare const proto3: import("./private/proto-runtime.js").ProtoRuntime;

package/dist/esm/proto3.js

@@ -1,53 +0,0 @@
-// 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.
-import { makeProtoRuntime } from "./private/proto-runtime.js";
-import { InternalFieldList } from "./private/field-list.js";
-import { scalarZeroValue } from "./private/scalars.js";
-import { normalizeFieldInfos } from "./private/field-normalize.js";
-/**
- * Provides functionality for messages defined with the proto3 syntax.
- */
-export const proto3 = makeProtoRuntime("proto3", (fields) => {
-    return new InternalFieldList(fields, (source) => normalizeFieldInfos(source, true));
-}, 
-// TODO merge with proto2 and initExtensionField, also see initPartial, equals, clone
-(target) => {
-    for (const member of target.getType().fields.byMember()) {
-        if (member.opt) {
-            continue;
-        }
-        const name = member.localName, t = target;
-        if (member.repeated) {
-            t[name] = [];
-            continue;
-        }
-        switch (member.kind) {
-            case "oneof":
-                t[name] = { case: undefined };
-                break;
-            case "enum":
-                t[name] = 0;
-                break;
-            case "map":
-                t[name] = {};
-                break;
-            case "scalar":
-                t[name] = scalarZeroValue(member.T, member.L);
-                break;
-            case "message":
-                // message fields are always optional in proto3
-                break;
-        }
-    }
-});

package/dist/esm/scalar.js

@@ -1,78 +0,0 @@
-// 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.
-/**
- * Scalar value types. This is a subset of field types declared by protobuf
- * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE
- * are omitted, but the numerical values are identical.
- */
-export var ScalarType;
-(function (ScalarType) {
-    // 0 is reserved for errors.
-    // Order is weird for historical reasons.
-    ScalarType[ScalarType["DOUBLE"] = 1] = "DOUBLE";
-    ScalarType[ScalarType["FLOAT"] = 2] = "FLOAT";
-    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
-    // negative values are likely.
-    ScalarType[ScalarType["INT64"] = 3] = "INT64";
-    ScalarType[ScalarType["UINT64"] = 4] = "UINT64";
-    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
-    // negative values are likely.
-    ScalarType[ScalarType["INT32"] = 5] = "INT32";
-    ScalarType[ScalarType["FIXED64"] = 6] = "FIXED64";
-    ScalarType[ScalarType["FIXED32"] = 7] = "FIXED32";
-    ScalarType[ScalarType["BOOL"] = 8] = "BOOL";
-    ScalarType[ScalarType["STRING"] = 9] = "STRING";
-    // 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.
-    // TYPE_GROUP = 10,
-    // TYPE_MESSAGE = 11,  // Length-delimited aggregate.
-    // New in version 2.
-    ScalarType[ScalarType["BYTES"] = 12] = "BYTES";
-    ScalarType[ScalarType["UINT32"] = 13] = "UINT32";
-    // TYPE_ENUM = 14,
-    ScalarType[ScalarType["SFIXED32"] = 15] = "SFIXED32";
-    ScalarType[ScalarType["SFIXED64"] = 16] = "SFIXED64";
-    ScalarType[ScalarType["SINT32"] = 17] = "SINT32";
-    ScalarType[ScalarType["SINT64"] = 18] = "SINT64";
-})(ScalarType || (ScalarType = {}));
-/**
- * JavaScript representation of fields with 64 bit integral types (int64, uint64,
- * sint64, fixed64, sfixed64).
- *
- * This is a subset of google.protobuf.FieldOptions.JSType, which defines JS_NORMAL,
- * JS_STRING, and JS_NUMBER. Protobuf-ES uses BigInt by default, but will use
- * String if `[jstype = JS_STRING]` is specified.
- *
- * ```protobuf
- * uint64 field_a = 1; // BigInt
- * uint64 field_b = 2 [jstype = JS_NORMAL]; // BigInt
- * uint64 field_b = 2 [jstype = JS_NUMBER]; // BigInt
- * uint64 field_b = 2 [jstype = JS_STRING]; // String
- * ```
- */
-export var LongType;
-(function (LongType) {
-    /**
-     * Use JavaScript BigInt.
-     */
-    LongType[LongType["BIGINT"] = 0] = "BIGINT";
-    /**
-     * Use JavaScript String.
-     *
-     * Field option `[jstype = JS_STRING]`.
-     */
-    LongType[LongType["STRING"] = 1] = "STRING";
-})(LongType || (LongType = {}));

package/dist/esm/service-type.d.ts

@@ -1,96 +0,0 @@
-import type { AnyMessage, Message } from "./message.js";
-import type { MessageType } from "./message-type.js";
-/**
- * ServiceType represents a protobuf services. It provides metadata for
- * reflection-based operations.
- */
-export interface ServiceType {
-    /**
-     * The fully qualified name of the service.
-     */
-    readonly typeName: string;
-    /**
-     * A map of local name (safe to use in ECMAScript) to method.
-     */
-    readonly methods: {
-        [localName: string]: MethodInfo;
-    };
-}
-/**
- * MethodInfo represents a method of a protobuf service, a remote procedure
- * call. All methods provide the following properties:
- *
- * - "name": The original name of the protobuf rpc.
- * - "I": The input message type.
- * - "O": The output message type.
- * - "kind": The method type.
- * - "idempotency": User-provided indication whether the method will cause
- *   the same effect every time it is called.
- */
-export type MethodInfo<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage> = MethodInfoUnary<I, O> | MethodInfoServerStreaming<I, O> | MethodInfoClientStreaming<I, O> | MethodInfoBiDiStreaming<I, O>;
-/**
- * A unary method: rpc (Input) returns (Output)
- */
-export interface MethodInfoUnary<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
-    readonly kind: MethodKind.Unary;
-}
-/**
- * A server streaming method: rpc (Input) returns (stream Output)
- */
-export interface MethodInfoServerStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
-    readonly kind: MethodKind.ServerStreaming;
-}
-/**
- * A client streaming method: rpc (stream Input) returns (Output)
- */
-export interface MethodInfoClientStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
-    readonly kind: MethodKind.ClientStreaming;
-}
-/**
- * A method that streams bi-directionally: rpc (stream Input) returns (stream Output)
- */
-export interface MethodInfoBiDiStreaming<I extends Message<I>, O extends Message<O>> extends miShared<I, O> {
-    readonly kind: MethodKind.BiDiStreaming;
-}
-interface miShared<I extends Message<I> = AnyMessage, O extends Message<O> = AnyMessage> {
-    readonly name: string;
-    readonly I: MessageType<I>;
-    readonly O: MessageType<O>;
-    readonly idempotency?: MethodIdempotency;
-}
-/**
- * MethodKind represents the four method types that can be declared in
- * protobuf with the `stream` keyword:
- *
- * 1. Unary:           rpc (Input) returns (Output)
- * 2. ServerStreaming: rpc (Input) returns (stream Output)
- * 3. ClientStreaming: rpc (stream Input) returns (Output)
- * 4. BiDiStreaming:   rpc (stream Input) returns (stream Output)
- */
-export declare enum MethodKind {
-    Unary = 0,
-    ServerStreaming = 1,
-    ClientStreaming = 2,
-    BiDiStreaming = 3
-}
-/**
- * Is this method side-effect-free (or safe in HTTP parlance), or just
- * 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.
- *
- * This enum matches the protobuf enum google.protobuf.MethodOptions.IdempotencyLevel,
- * defined in the well-known type google/protobuf/descriptor.proto, but
- * drops UNKNOWN.
- */
-export declare enum MethodIdempotency {
-    /**
-     * Idempotent, no side effects.
-     */
-    NoSideEffects = 1,
-    /**
-     * Idempotent, but may have side effects.
-     */
-    Idempotent = 2
-}
-export {};