@replit/protocol 0.4.20 → 0.4.22

package/dist/google/protobuf/empty.d.ts

@@ -0,0 +1,31 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+/**
+ * A generic empty message that you can re-use to avoid defining duplicated
+ * empty messages in your APIs. A typical example is to use it as the request
+ * or the response type of an API method. For instance:
+ *
+ *     service Foo {
+ *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+ *     }
+ *
+ *
+ * @generated from protobuf message google.protobuf.Empty
+ */
+export interface Empty {
+}
+declare class Empty$Type extends MessageType<Empty> {
+    constructor();
+    create(value?: PartialMessage<Empty>): Empty;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Empty): Empty;
+    internalBinaryWrite(message: Empty, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Empty
+ */
+export declare const Empty: Empty$Type;
+export {};

package/dist/google/protobuf/empty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty.d.ts","sourceRoot":"","sources":["empty.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,KAAK;CACrB;AAED,cAAM,UAAW,SAAQ,WAAW,CAAC,KAAK,CAAC;;IAIvC,MAAM,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC,KAAK,CAAC,GAAG,KAAK;IAM5C,kBAAkB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK;IAgB5G,mBAAmB,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,kBAAkB,GAAG,aAAa;CAMzG;AACD;;GAEG;AACH,eAAO,MAAM,KAAK,YAAmB,CAAC"}

package/dist/google/protobuf/empty.js

@@ -0,0 +1,41 @@
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+// @generated message type with reflection information, may provide speed optimized methods
+class Empty$Type extends MessageType {
+    constructor() {
+        super("google.protobuf.Empty", []);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Empty
+ */
+export const Empty = new Empty$Type();

package/dist/google/protobuf/field_mask.d.ts

@@ -0,0 +1,239 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } 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";
+/**
+ * `FieldMask` represents a set of symbolic field paths, for example:
+ *
+ *     paths: "f.a"
+ *     paths: "f.b.d"
+ *
+ * Here `f` represents a field in some root message, `a` and `b`
+ * fields in the message found in `f`, and `d` a field found in the
+ * message in `f.b`.
+ *
+ * Field masks are used to specify a subset of fields that should be
+ * returned by a get operation or modified by an update operation.
+ * Field masks also have a custom JSON encoding (see below).
+ *
+ * # Field Masks in Projections
+ *
+ * When used in the context of a projection, a response message or
+ * sub-message is filtered by the API to only contain those fields as
+ * specified in the mask. For example, if the mask in the previous
+ * example is applied to a response message as follows:
+ *
+ *     f {
+ *       a : 22
+ *       b {
+ *         d : 1
+ *         x : 2
+ *       }
+ *       y : 13
+ *     }
+ *     z: 8
+ *
+ * The result will not contain specific values for fields x,y and z
+ * (their value will be set to the default, and omitted in proto text
+ * output):
+ *
+ *
+ *     f {
+ *       a : 22
+ *       b {
+ *         d : 1
+ *       }
+ *     }
+ *
+ * A repeated field is not allowed except at the last position of a
+ * paths string.
+ *
+ * If a FieldMask object is not present in a get operation, the
+ * operation applies to all fields (as if a FieldMask of all fields
+ * had been specified).
+ *
+ * Note that a field mask does not necessarily apply to the
+ * top-level response message. In case of a REST get operation, the
+ * field mask applies directly to the response, but in case of a REST
+ * list operation, the mask instead applies to each individual message
+ * in the returned resource list. In case of a REST custom method,
+ * other definitions may be used. Where the mask applies will be
+ * clearly documented together with its declaration in the API.  In
+ * any case, the effect on the returned resource/resources is required
+ * behavior for APIs.
+ *
+ * # Field Masks in Update Operations
+ *
+ * A field mask in update operations specifies which fields of the
+ * targeted resource are going to be updated. The API is required
+ * to only change the values of the fields as specified in the mask
+ * and leave the others untouched. If a resource is passed in to
+ * describe the updated values, the API ignores the values of all
+ * fields not covered by the mask.
+ *
+ * If a repeated field is specified for an update operation, new values will
+ * be appended to the existing repeated field in the target resource. Note that
+ * a repeated field is only allowed in the last position of a `paths` string.
+ *
+ * If a sub-message is specified in the last position of the field mask for an
+ * update operation, then new value will be merged into the existing sub-message
+ * in the target resource.
+ *
+ * For example, given the target message:
+ *
+ *     f {
+ *       b {
+ *         d: 1
+ *         x: 2
+ *       }
+ *       c: [1]
+ *     }
+ *
+ * And an update message:
+ *
+ *     f {
+ *       b {
+ *         d: 10
+ *       }
+ *       c: [2]
+ *     }
+ *
+ * then if the field mask is:
+ *
+ *  paths: ["f.b", "f.c"]
+ *
+ * then the result will be:
+ *
+ *     f {
+ *       b {
+ *         d: 10
+ *         x: 2
+ *       }
+ *       c: [1, 2]
+ *     }
+ *
+ * An implementation may provide options to override this default behavior for
+ * repeated and message fields.
+ *
+ * In order to reset a field's value to the default, the field must
+ * be in the mask and set to the default value in the provided resource.
+ * Hence, in order to reset all fields of a resource, provide a default
+ * instance of the resource and set all fields in the mask, or do
+ * not provide a mask as described below.
+ *
+ * If a field mask is not present on update, the operation applies to
+ * all fields (as if a field mask of all fields has been specified).
+ * Note that in the presence of schema evolution, this may mean that
+ * fields the client does not know and has therefore not filled into
+ * the request will be reset to their default. If this is unwanted
+ * behavior, a specific service may require a client to always specify
+ * a field mask, producing an error if not.
+ *
+ * As with get operations, the location of the resource which
+ * describes the updated values in the request message depends on the
+ * operation kind. In any case, the effect of the field mask is
+ * required to be honored by the API.
+ *
+ * ## Considerations for HTTP REST
+ *
+ * The HTTP kind of an update operation which uses a field mask must
+ * be set to PATCH instead of PUT in order to satisfy HTTP semantics
+ * (PUT must only be used for full updates).
+ *
+ * # JSON Encoding of Field Masks
+ *
+ * In JSON, a field mask is encoded as a single string where paths are
+ * separated by a comma. Fields name in each path are converted
+ * to/from lower-camel naming conventions.
+ *
+ * As an example, consider the following message declarations:
+ *
+ *     message Profile {
+ *       User user = 1;
+ *       Photo photo = 2;
+ *     }
+ *     message User {
+ *       string display_name = 1;
+ *       string address = 2;
+ *     }
+ *
+ * In proto a field mask for `Profile` may look as such:
+ *
+ *     mask {
+ *       paths: "user.display_name"
+ *       paths: "photo"
+ *     }
+ *
+ * In JSON, the same mask is represented as below:
+ *
+ *     {
+ *       mask: "user.displayName,photo"
+ *     }
+ *
+ * # Field Masks and Oneof Fields
+ *
+ * Field masks treat fields in oneofs just as regular fields. Consider the
+ * following message:
+ *
+ *     message SampleMessage {
+ *       oneof test_oneof {
+ *         string name = 4;
+ *         SubMessage sub_message = 9;
+ *       }
+ *     }
+ *
+ * The field mask can be:
+ *
+ *     mask {
+ *       paths: "name"
+ *     }
+ *
+ * Or:
+ *
+ *     mask {
+ *       paths: "sub_message"
+ *     }
+ *
+ * Note that oneof type names ("test_oneof" in this case) cannot be used in
+ * paths.
+ *
+ * ## Field Mask Verification
+ *
+ * The implementation of any API method which has a FieldMask type field in the
+ * request should verify the included field paths, and return an
+ * `INVALID_ARGUMENT` error if any path is unmappable.
+ *
+ * @generated from protobuf message google.protobuf.FieldMask
+ */
+export interface FieldMask {
+    /**
+     * The set of field mask paths.
+     *
+     * @generated from protobuf field: repeated string paths = 1
+     */
+    paths: string[];
+}
+declare class FieldMask$Type extends MessageType<FieldMask> {
+    constructor();
+    /**
+     * Encode `FieldMask` to JSON object.
+     */
+    internalJsonWrite(message: FieldMask, options: JsonWriteOptions): JsonValue;
+    /**
+     * Decode `FieldMask` from JSON object.
+     */
+    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: FieldMask): FieldMask;
+    create(value?: PartialMessage<FieldMask>): FieldMask;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FieldMask): FieldMask;
+    internalBinaryWrite(message: FieldMask, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.FieldMask
+ */
+export declare const FieldMask: FieldMask$Type;
+export {};

package/dist/google/protobuf/field_mask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field_mask.d.ts","sourceRoot":"","sources":["field_mask.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0MG;AACH,MAAM,WAAW,SAAS;IACtB;;;;OAIG;IACH,KAAK,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,cAAM,cAAe,SAAQ,WAAW,CAAC,SAAS,CAAC;;IAM/C;;OAEG;IACH,iBAAiB,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,gBAAgB,GAAG,SAAS;IAQ3E;;OAEG;IACH,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,SAAS,GAAG,SAAS;IAgB1F,MAAM,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC,SAAS,CAAC,GAAG,SAAS;IAOpD,kBAAkB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,SAAS,GAAG,SAAS;IAmBpH,mBAAmB,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,kBAAkB,GAAG,aAAa;CAS7G;AACD;;GAEG;AACH,eAAO,MAAM,SAAS,gBAAuB,CAAC"}

package/dist/google/protobuf/field_mask.js

@@ -0,0 +1,83 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { typeofJsonValue } from "@protobuf-ts/runtime";
+import { lowerCamelCase } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+// @generated message type with reflection information, may provide speed optimized methods
+class FieldMask$Type extends MessageType {
+    constructor() {
+        super("google.protobuf.FieldMask", [
+            { no: 1, name: "paths", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    /**
+     * Encode `FieldMask` to JSON object.
+     */
+    internalJsonWrite(message, options) {
+        const invalidFieldMaskJsonRegex = /[A-Z]|(_([.0-9_]|$))/g;
+        return message.paths.map(p => {
+            if (invalidFieldMaskJsonRegex.test(p))
+                throw new Error("Unable to encode FieldMask to JSON. lowerCamelCase of path name \"" + p + "\" is irreversible.");
+            return lowerCamelCase(p);
+        }).join(",");
+    }
+    /**
+     * Decode `FieldMask` from JSON object.
+     */
+    internalJsonRead(json, options, target) {
+        if (typeof json !== "string")
+            throw new Error("Unable to parse FieldMask from JSON " + typeofJsonValue(json) + ". Expected string.");
+        if (!target)
+            target = this.create();
+        if (json === "")
+            return target;
+        let camelToSnake = (str) => {
+            if (str.includes("_"))
+                throw new Error("Unable to parse FieldMask from JSON. Path names must be lowerCamelCase.");
+            let sc = str.replace(/[A-Z]/g, letter => "_" + letter.toLowerCase());
+            return sc;
+        };
+        target.paths = json.split(",").map(camelToSnake);
+        return target;
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.paths = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated string paths */ 1:
+                    message.paths.push(reader.string());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated string paths = 1; */
+        for (let i = 0; i < message.paths.length; i++)
+            writer.tag(1, WireType.LengthDelimited).string(message.paths[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.FieldMask
+ */
+export const FieldMask = new FieldMask$Type();

package/dist/google/protobuf/struct.d.ts

@@ -0,0 +1,186 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } 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";
+/**
+ * `Struct` represents a structured data value, consisting of fields
+ * which map to dynamically typed values. In some languages, `Struct`
+ * might be supported by a native representation. For example, in
+ * scripting languages like JS a struct is represented as an
+ * object. The details of that representation are described together
+ * with the proto support for the language.
+ *
+ * The JSON representation for `Struct` is JSON object.
+ *
+ * @generated from protobuf message google.protobuf.Struct
+ */
+export interface Struct {
+    /**
+     * Unordered map of dynamically typed values.
+     *
+     * @generated from protobuf field: map<string, google.protobuf.Value> fields = 1
+     */
+    fields: {
+        [key: string]: Value;
+    };
+}
+/**
+ * `Value` represents a dynamically typed value which can be either
+ * null, a number, a string, a boolean, a recursive struct value, or a
+ * list of values. A producer of value is expected to set one of these
+ * variants. Absence of any variant indicates an error.
+ *
+ * The JSON representation for `Value` is JSON value.
+ *
+ * @generated from protobuf message google.protobuf.Value
+ */
+export interface Value {
+    /**
+     * The kind of value.
+     *
+     * @generated from protobuf oneof: kind
+     */
+    kind: {
+        oneofKind: "nullValue";
+        /**
+         * Represents a null value.
+         *
+         * @generated from protobuf field: google.protobuf.NullValue null_value = 1
+         */
+        nullValue: NullValue;
+    } | {
+        oneofKind: "numberValue";
+        /**
+         * Represents a double value.
+         *
+         * @generated from protobuf field: double number_value = 2
+         */
+        numberValue: number;
+    } | {
+        oneofKind: "stringValue";
+        /**
+         * Represents a string value.
+         *
+         * @generated from protobuf field: string string_value = 3
+         */
+        stringValue: string;
+    } | {
+        oneofKind: "boolValue";
+        /**
+         * Represents a boolean value.
+         *
+         * @generated from protobuf field: bool bool_value = 4
+         */
+        boolValue: boolean;
+    } | {
+        oneofKind: "structValue";
+        /**
+         * Represents a structured value.
+         *
+         * @generated from protobuf field: google.protobuf.Struct struct_value = 5
+         */
+        structValue: Struct;
+    } | {
+        oneofKind: "listValue";
+        /**
+         * Represents a repeated `Value`.
+         *
+         * @generated from protobuf field: google.protobuf.ListValue list_value = 6
+         */
+        listValue: ListValue;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * `ListValue` is a wrapper around a repeated field of values.
+ *
+ * The JSON representation for `ListValue` is JSON array.
+ *
+ * @generated from protobuf message google.protobuf.ListValue
+ */
+export interface ListValue {
+    /**
+     * Repeated field of dynamically typed values.
+     *
+     * @generated from protobuf field: repeated google.protobuf.Value values = 1
+     */
+    values: Value[];
+}
+/**
+ * `NullValue` is a singleton enumeration to represent the null value for the
+ * `Value` type union.
+ *
+ * The JSON representation for `NullValue` is JSON `null`.
+ *
+ * @generated from protobuf enum google.protobuf.NullValue
+ */
+export declare enum NullValue {
+    /**
+     * Null value.
+     *
+     * @generated from protobuf enum value: NULL_VALUE = 0;
+     */
+    NULL_VALUE = 0
+}
+declare class Struct$Type extends MessageType<Struct> {
+    constructor();
+    /**
+     * Encode `Struct` to JSON object.
+     */
+    internalJsonWrite(message: Struct, options: JsonWriteOptions): JsonValue;
+    /**
+     * Decode `Struct` from JSON object.
+     */
+    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Struct): Struct;
+    create(value?: PartialMessage<Struct>): Struct;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Struct): Struct;
+    private binaryReadMap1;
+    internalBinaryWrite(message: Struct, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Struct
+ */
+export declare const Struct: Struct$Type;
+declare class Value$Type extends MessageType<Value> {
+    constructor();
+    /**
+     * Encode `Value` to JSON value.
+     */
+    internalJsonWrite(message: Value, options: JsonWriteOptions): JsonValue;
+    /**
+     * Decode `Value` from JSON value.
+     */
+    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Value): Value;
+    create(value?: PartialMessage<Value>): Value;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Value): Value;
+    internalBinaryWrite(message: Value, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Value
+ */
+export declare const Value: Value$Type;
+declare class ListValue$Type extends MessageType<ListValue> {
+    constructor();
+    /**
+     * Encode `ListValue` to JSON array.
+     */
+    internalJsonWrite(message: ListValue, options: JsonWriteOptions): JsonValue;
+    /**
+     * Decode `ListValue` from JSON array.
+     */
+    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: ListValue): ListValue;
+    create(value?: PartialMessage<ListValue>): ListValue;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListValue): ListValue;
+    internalBinaryWrite(message: ListValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.ListValue
+ */
+export declare const ListValue: ListValue$Type;
+export {};

package/dist/google/protobuf/struct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"struct.d.ts","sourceRoot":"","sources":["struct.ts"],"names":[],"mappings":"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"}