@canton-network/core-ledger-proto 0.1.0

package/dist/_proto/google/protobuf/duration.d.ts

@@ -0,0 +1,114 @@
+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';
+/**
+ * A Duration represents a signed, fixed-length span of time represented
+ * as a count of seconds and fractions of seconds at nanosecond
+ * resolution. It is independent of any calendar and concepts like "day"
+ * or "month". It is related to Timestamp in that the difference between
+ * two Timestamp values is a Duration and it can be added or subtracted
+ * from a Timestamp. Range is approximately +-10,000 years.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Duration from two Timestamps in pseudo code.
+ *
+ *     Timestamp start = ...;
+ *     Timestamp end = ...;
+ *     Duration duration = ...;
+ *
+ *     duration.seconds = end.seconds - start.seconds;
+ *     duration.nanos = end.nanos - start.nanos;
+ *
+ *     if (duration.seconds < 0 && duration.nanos > 0) {
+ *       duration.seconds += 1;
+ *       duration.nanos -= 1000000000;
+ *     } else if (duration.seconds > 0 && duration.nanos < 0) {
+ *       duration.seconds -= 1;
+ *       duration.nanos += 1000000000;
+ *     }
+ *
+ * Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+ *
+ *     Timestamp start = ...;
+ *     Duration duration = ...;
+ *     Timestamp end = ...;
+ *
+ *     end.seconds = start.seconds + duration.seconds;
+ *     end.nanos = start.nanos + duration.nanos;
+ *
+ *     if (end.nanos < 0) {
+ *       end.seconds -= 1;
+ *       end.nanos += 1000000000;
+ *     } else if (end.nanos >= 1000000000) {
+ *       end.seconds += 1;
+ *       end.nanos -= 1000000000;
+ *     }
+ *
+ * Example 3: Compute Duration from datetime.timedelta in Python.
+ *
+ *     td = datetime.timedelta(days=3, minutes=10)
+ *     duration = Duration()
+ *     duration.FromTimedelta(td)
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Duration type is encoded as a string rather than an
+ * object, where the string ends in the suffix "s" (indicating seconds) and
+ * is preceded by the number of seconds, with nanoseconds expressed as
+ * fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+ * encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+ * be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+ * microsecond should be expressed in JSON format as "3.000001s".
+ *
+ *
+ *
+ * @generated from protobuf message google.protobuf.Duration
+ */
+export interface Duration {
+    /**
+     * Signed seconds of the span of time. Must be from -315,576,000,000
+     * to +315,576,000,000 inclusive. Note: these bounds are computed from:
+     * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+     *
+     * @generated from protobuf field: int64 seconds = 1
+     */
+    seconds: bigint;
+    /**
+     * Signed fractions of a second at nanosecond resolution of the span
+     * of time. Durations less than one second are represented with a 0
+     * `seconds` field and a positive or negative `nanos` field. For durations
+     * of one second or more, a non-zero value for the `nanos` field must be
+     * of the same sign as the `seconds` field. Must be from -999,999,999
+     * to +999,999,999 inclusive.
+     *
+     * @generated from protobuf field: int32 nanos = 2
+     */
+    nanos: number;
+}
+declare class Duration$Type extends MessageType<Duration> {
+    constructor();
+    /**
+     * Encode `Duration` to JSON string like "3.000001s".
+     */
+    internalJsonWrite(message: Duration, options: JsonWriteOptions): JsonValue;
+    /**
+     * Decode `Duration` from JSON string like "3.000001s"
+     */
+    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Duration): Duration;
+    create(value?: PartialMessage<Duration>): Duration;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Duration): Duration;
+    internalBinaryWrite(message: Duration, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Duration
+ */
+export declare const Duration: Duration$Type;
+export {};
+//# sourceMappingURL=duration.d.ts.map

package/dist/_proto/google/protobuf/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../../../src/_proto/google/protobuf/duration.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAG1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAE5D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,MAAM,WAAW,QAAQ;IACrB;;;;;;OAMG;IACH,OAAO,EAAE,MAAM,CAAA;IACf;;;;;;;;;OASG;IACH,KAAK,EAAE,MAAM,CAAA;CAChB;AAED,cAAM,aAAc,SAAQ,WAAW,CAAC,QAAQ,CAAC;;IAa7C;;OAEG;IACH,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,gBAAgB,GAAG,SAAS;IAiB1E;;OAEG;IACH,gBAAgB,CACZ,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,eAAe,EACxB,MAAM,CAAC,EAAE,QAAQ,GAClB,QAAQ;IA6BX,MAAM,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,GAAG,QAAQ;IAQlD,kBAAkB,CACd,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,iBAAiB,EAC1B,MAAM,CAAC,EAAE,QAAQ,GAClB,QAAQ;IA+BX,mBAAmB,CACf,OAAO,EAAE,QAAQ,EACjB,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,kBAAkB,GAC5B,aAAa;CAgBnB;AACD;;GAEG;AACH,eAAO,MAAM,QAAQ,eAAsB,CAAA"}

package/dist/_proto/google/protobuf/duration.js

@@ -0,0 +1,113 @@
+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 { PbLong } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+// @generated message type with reflection information, may provide speed optimized methods
+class Duration$Type extends MessageType {
+    constructor() {
+        super('google.protobuf.Duration', [
+            {
+                no: 1,
+                name: 'seconds',
+                kind: 'scalar',
+                T: 3 /*ScalarType.INT64*/,
+                L: 0 /*LongType.BIGINT*/,
+            },
+            { no: 2, name: 'nanos', kind: 'scalar', T: 5 /*ScalarType.INT32*/ },
+        ]);
+    }
+    /**
+     * Encode `Duration` to JSON string like "3.000001s".
+     */
+    internalJsonWrite(message, options) {
+        let s = PbLong.from(message.seconds).toNumber();
+        if (s > 315576000000 || s < -315576000000)
+            throw new Error('Duration value out of range.');
+        let text = message.seconds.toString();
+        if (s === 0 && message.nanos < 0)
+            text = '-' + text;
+        if (message.nanos !== 0) {
+            let nanosStr = Math.abs(message.nanos).toString();
+            nanosStr = '0'.repeat(9 - nanosStr.length) + nanosStr;
+            if (nanosStr.substring(3) === '000000')
+                nanosStr = nanosStr.substring(0, 3);
+            else if (nanosStr.substring(6) === '000')
+                nanosStr = nanosStr.substring(0, 6);
+            text += '.' + nanosStr;
+        }
+        return text + 's';
+    }
+    /**
+     * Decode `Duration` from JSON string like "3.000001s"
+     */
+    internalJsonRead(json, options, target) {
+        if (typeof json !== 'string')
+            throw new Error('Unable to parse Duration from JSON ' +
+                typeofJsonValue(json) +
+                '. Expected string.');
+        let match = json.match(/^(-?)([0-9]+)(?:\.([0-9]+))?s/);
+        if (match === null)
+            throw new Error('Unable to parse Duration from JSON string. Invalid format.');
+        if (!target)
+            target = this.create();
+        let [, sign, secs, nanos] = match;
+        let longSeconds = PbLong.from(sign + secs);
+        if (longSeconds.toNumber() > 315576000000 ||
+            longSeconds.toNumber() < -315576000000)
+            throw new Error('Unable to parse Duration from JSON string. Value out of range.');
+        target.seconds = longSeconds.toBigInt();
+        if (typeof nanos == 'string') {
+            let nanosStr = sign + nanos + '0'.repeat(9 - nanos.length);
+            target.nanos = parseInt(nanosStr);
+        }
+        return target;
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.seconds = 0n;
+        message.nanos = 0;
+        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 /* int64 seconds */ 1:
+                    message.seconds = reader.int64().toBigInt();
+                    break;
+                case /* int32 nanos */ 2:
+                    message.nanos = 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, writer, options) {
+        /* int64 seconds = 1; */
+        if (message.seconds !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.seconds);
+        /* int32 nanos = 2; */
+        if (message.nanos !== 0)
+            writer.tag(2, WireType.Varint).int32(message.nanos);
+        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.Duration
+ */
+export const Duration = new Duration$Type();

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

@@ -0,0 +1,33 @@
+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);
+ *     }
+ *
+ * The JSON representation for `Empty` is empty JSON object `{}`.
+ *
+ * @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 {};
+//# sourceMappingURL=empty.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"empty.d.ts","sourceRoot":"","sources":["../../../../src/_proto/google/protobuf/empty.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAClD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,KAAK;CAAG;AAEzB,cAAM,UAAW,SAAQ,WAAW,CAAC,KAAK,CAAC;;IAIvC,MAAM,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC,KAAK,CAAC,GAAG,KAAK;IAM5C,kBAAkB,CACd,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,iBAAiB,EAC1B,MAAM,CAAC,EAAE,KAAK,GACf,KAAK;IAyBR,mBAAmB,CACf,OAAO,EAAE,KAAK,EACd,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,kBAAkB,GAC5B,aAAa;CAUnB;AACD;;GAEG;AACH,eAAO,MAAM,KAAK,YAAmB,CAAA"}

package/dist/_proto/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/_proto/google/protobuf/field_mask.d.ts

@@ -0,0 +1,240 @@
+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 {};
+//# sourceMappingURL=field_mask.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"field_mask.d.ts","sourceRoot":"","sources":["../../../../src/_proto/google/protobuf/field_mask.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAG1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAErD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0MG;AACH,MAAM,WAAW,SAAS;IACtB;;;;OAIG;IACH,KAAK,EAAE,MAAM,EAAE,CAAA;CAClB;AAED,cAAM,cAAe,SAAQ,WAAW,CAAC,SAAS,CAAC;;IAY/C;;OAEG;IACH,iBAAiB,CACb,OAAO,EAAE,SAAS,EAClB,OAAO,EAAE,gBAAgB,GAC1B,SAAS;IAcZ;;OAEG;IACH,gBAAgB,CACZ,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,eAAe,EACxB,MAAM,CAAC,EAAE,SAAS,GACnB,SAAS;IAuBZ,MAAM,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC,SAAS,CAAC,GAAG,SAAS;IAOpD,kBAAkB,CACd,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,iBAAiB,EAC1B,MAAM,CAAC,EAAE,SAAS,GACnB,SAAS;IA4BZ,mBAAmB,CACf,OAAO,EAAE,SAAS,EAClB,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,kBAAkB,GAC5B,aAAa;CAanB;AACD;;GAEG;AACH,eAAO,MAAM,SAAS,gBAAuB,CAAA"}

package/dist/_proto/google/protobuf/field_mask.js

@@ -0,0 +1,95 @@
+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();