@use-tusk/drift-schemas 0.1.10

package/dist/core/communication.client.d.ts

@@ -0,0 +1,59 @@
+import "../struct-BArXEwH6.js";
+import "../duration-2zPogS5a.js";
+import "../timestamp-2doLREh_.js";
+import "../span-BOpbAPMC.js";
+import { ConnectRequest, ConnectResponse, GetMockRequest, GetMockResponse, SendInboundSpanForReplayRequest, SendInboundSpanForReplayResponse } from "../communication-bKx0B3ai.js";
+import * as _protobuf_ts_runtime_rpc2 from "@protobuf-ts/runtime-rpc";
+import { RpcOptions, RpcTransport, ServiceInfo, UnaryCall } from "@protobuf-ts/runtime-rpc";
+import * as _protobuf_ts_runtime2 from "@protobuf-ts/runtime";
+
+//#region generated/ts/core/communication.client.d.ts
+
+/**
+ * Generic protocol between CLI and SDK - completely instrumentation-agnostic
+ *
+ * @generated from protobuf service tusk.drift.core.v1.MockService
+ */
+interface IMockServiceClient {
+  /**
+   * @generated from protobuf rpc: Connect
+   */
+  connect(input: ConnectRequest, options?: RpcOptions): UnaryCall<ConnectRequest, ConnectResponse>;
+  /**
+   * @generated from protobuf rpc: GetMock
+   */
+  getMock(input: GetMockRequest, options?: RpcOptions): UnaryCall<GetMockRequest, GetMockResponse>;
+  /**
+   * @generated from protobuf rpc: SendInboundSpanForReplay
+   */
+  sendInboundSpanForReplay(input: SendInboundSpanForReplayRequest, options?: RpcOptions): UnaryCall<SendInboundSpanForReplayRequest, SendInboundSpanForReplayResponse>;
+}
+/**
+ * Generic protocol between CLI and SDK - completely instrumentation-agnostic
+ *
+ * @generated from protobuf service tusk.drift.core.v1.MockService
+ */
+declare class MockServiceClient implements IMockServiceClient, ServiceInfo {
+  private readonly _transport;
+  typeName: string;
+  methods: _protobuf_ts_runtime_rpc2.MethodInfo<any, any>[];
+  options: {
+    [extensionName: string]: _protobuf_ts_runtime2.JsonValue;
+  };
+  constructor(_transport: RpcTransport);
+  /**
+   * @generated from protobuf rpc: Connect
+   */
+  connect(input: ConnectRequest, options?: RpcOptions): UnaryCall<ConnectRequest, ConnectResponse>;
+  /**
+   * @generated from protobuf rpc: GetMock
+   */
+  getMock(input: GetMockRequest, options?: RpcOptions): UnaryCall<GetMockRequest, GetMockResponse>;
+  /**
+   * @generated from protobuf rpc: SendInboundSpanForReplay
+   */
+  sendInboundSpanForReplay(input: SendInboundSpanForReplayRequest, options?: RpcOptions): UnaryCall<SendInboundSpanForReplayRequest, SendInboundSpanForReplayResponse>;
+}
+//#endregion
+export { IMockServiceClient, MockServiceClient };
+//# sourceMappingURL=communication.client.d.ts.map

package/dist/core/communication.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"communication.client.d.ts","names":[],"sources":["../../generated/ts/core/communication.client.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AAoBA;;;;;AAIoF,UAJnE,kBAAA,CAImE;;;;SAIhB,CAAA,KAAA,EAJjD,cAIiD,EAAA,OAAA,CAAA,EAJvB,UAIuB,CAAA,EAJV,SAIU,CAJA,cAIA,EAJgB,eAIhB,CAAA;;;;SAIW,CAAA,KAAA,EAJ5D,cAI4D,EAAA,OAAA,CAAA,EAJlC,UAIkC,CAAA,EAJrB,SAIqB,CAJX,cAIW,EAJK,eAIL,CAAA;;;;EAAsB,wBAAA,CAAA,KAAA,EAAjE,+BAAiE,EAAA,OAAA,CAAA,EAAtB,UAAsB,CAAA,EAAT,SAAS,CAAC,+BAAD,EAAkC,gCAAlC,CAAA;AAOrG;;;;;;AAS6C,cAThC,iBAAA,YAA6B,kBASG,EATiB,WASjB,CAAA;mBAAuB,UAAA;UAAgB,EAAA,MAAA;SAA1B,EAT3B,yBAAA,CAEpB,UAO+C,CAAA,GAAA,EAAA,GAAA,CAAA,EAAA;SAOvC,EAAA;IAA0B,CAAA,aAAA,EAAA,MAAA,CAAA,EAdlC,qBAAA,CAAA,SAckC;;aAAuC,CAAA,UAAA,EAZvC,YAYuC;;;;SAOkB,CAAA,KAAA,EAdnF,cAcmF,EAAA,OAAA,CAAA,EAdzD,UAcyD,CAAA,EAd5C,SAc4C,CAdlC,cAckC,EAdlB,eAckB,CAAA;;;;SAvBxC,CAAA,KAAA,EAgB3C,cAhB2C,EAAA,OAAA,CAAA,EAgBjB,UAhBiB,CAAA,EAgBJ,SAhBI,CAgBM,cAhBN,EAgBsB,eAhBtB,CAAA;EAAW;;;kCAuBrC,2CAA2C,aAAa,UAAU,iCAAiC"}

package/dist/core/communication.client.js

@@ -0,0 +1,46 @@
+import "../struct-LJz5_MGH.js";
+import "../duration-B3fwb4jB.js";
+import "../timestamp-CN7C70ih.js";
+import "../span-DwoKrEhp.js";
+import { MockService } from "../communication-Np8Uorqu.js";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+
+//#region generated/ts/core/communication.client.ts
+/**
+* Generic protocol between CLI and SDK - completely instrumentation-agnostic
+*
+* @generated from protobuf service tusk.drift.core.v1.MockService
+*/
+var MockServiceClient = class {
+	constructor(_transport) {
+		this._transport = _transport;
+		this.typeName = MockService.typeName;
+		this.methods = MockService.methods;
+		this.options = MockService.options;
+	}
+	/**
+	* @generated from protobuf rpc: Connect
+	*/
+	connect(input, options) {
+		const method = this.methods[0], opt = this._transport.mergeOptions(options);
+		return stackIntercept("unary", this._transport, method, opt, input);
+	}
+	/**
+	* @generated from protobuf rpc: GetMock
+	*/
+	getMock(input, options) {
+		const method = this.methods[1], opt = this._transport.mergeOptions(options);
+		return stackIntercept("unary", this._transport, method, opt, input);
+	}
+	/**
+	* @generated from protobuf rpc: SendInboundSpanForReplay
+	*/
+	sendInboundSpanForReplay(input, options) {
+		const method = this.methods[2], opt = this._transport.mergeOptions(options);
+		return stackIntercept("unary", this._transport, method, opt, input);
+	}
+};
+
+//#endregion
+export { MockServiceClient };
+//# sourceMappingURL=communication.client.js.map

package/dist/core/communication.client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"communication.client.js","names":["_transport: RpcTransport"],"sources":["../../generated/ts/core/communication.client.ts"],"sourcesContent":["// @generated by protobuf-ts 2.11.1 with parameter generate_dependencies\n// @generated from protobuf file \"core/communication.proto\" (package \"tusk.drift.core.v1\", syntax proto3)\n// tslint:disable\nimport type { RpcTransport } from \"@protobuf-ts/runtime-rpc\";\nimport type { ServiceInfo } from \"@protobuf-ts/runtime-rpc\";\nimport { MockService } from \"./communication\";\nimport type { SendInboundSpanForReplayResponse } from \"./communication\";\nimport type { SendInboundSpanForReplayRequest } from \"./communication\";\nimport type { GetMockResponse } from \"./communication\";\nimport type { GetMockRequest } from \"./communication\";\nimport { stackIntercept } from \"@protobuf-ts/runtime-rpc\";\nimport type { ConnectResponse } from \"./communication\";\nimport type { ConnectRequest } from \"./communication\";\nimport type { UnaryCall } from \"@protobuf-ts/runtime-rpc\";\nimport type { RpcOptions } from \"@protobuf-ts/runtime-rpc\";\n/**\n * Generic protocol between CLI and SDK - completely instrumentation-agnostic\n *\n * @generated from protobuf service tusk.drift.core.v1.MockService\n */\nexport interface IMockServiceClient {\n    /**\n     * @generated from protobuf rpc: Connect\n     */\n    connect(input: ConnectRequest, options?: RpcOptions): UnaryCall<ConnectRequest, ConnectResponse>;\n    /**\n     * @generated from protobuf rpc: GetMock\n     */\n    getMock(input: GetMockRequest, options?: RpcOptions): UnaryCall<GetMockRequest, GetMockResponse>;\n    /**\n     * @generated from protobuf rpc: SendInboundSpanForReplay\n     */\n    sendInboundSpanForReplay(input: SendInboundSpanForReplayRequest, options?: RpcOptions): UnaryCall<SendInboundSpanForReplayRequest, SendInboundSpanForReplayResponse>;\n}\n/**\n * Generic protocol between CLI and SDK - completely instrumentation-agnostic\n *\n * @generated from protobuf service tusk.drift.core.v1.MockService\n */\nexport class MockServiceClient implements IMockServiceClient, ServiceInfo {\n    typeName = MockService.typeName;\n    methods = MockService.methods;\n    options = MockService.options;\n    constructor(private readonly _transport: RpcTransport) {\n    }\n    /**\n     * @generated from protobuf rpc: Connect\n     */\n    connect(input: ConnectRequest, options?: RpcOptions): UnaryCall<ConnectRequest, ConnectResponse> {\n        const method = this.methods[0], opt = this._transport.mergeOptions(options);\n        return stackIntercept<ConnectRequest, ConnectResponse>(\"unary\", this._transport, method, opt, input);\n    }\n    /**\n     * @generated from protobuf rpc: GetMock\n     */\n    getMock(input: GetMockRequest, options?: RpcOptions): UnaryCall<GetMockRequest, GetMockResponse> {\n        const method = this.methods[1], opt = this._transport.mergeOptions(options);\n        return stackIntercept<GetMockRequest, GetMockResponse>(\"unary\", this._transport, method, opt, input);\n    }\n    /**\n     * @generated from protobuf rpc: SendInboundSpanForReplay\n     */\n    sendInboundSpanForReplay(input: SendInboundSpanForReplayRequest, options?: RpcOptions): UnaryCall<SendInboundSpanForReplayRequest, SendInboundSpanForReplayResponse> {\n        const method = this.methods[2], opt = this._transport.mergeOptions(options);\n        return stackIntercept<SendInboundSpanForReplayRequest, SendInboundSpanForReplayResponse>(\"unary\", this._transport, method, opt, input);\n    }\n}\n"],"mappings":";;;;;;;;;;;;;AAuCA,IAAa,oBAAb,MAA0E;CAItE,YAAY,AAAiBA,YAA0B;EAA1B;OAH7B,WAAW,YAAY;OACvB,UAAU,YAAY;OACtB,UAAU,YAAY;;;;;CAMtB,QAAQ,OAAuB,SAAkE;EAC7F,MAAM,SAAS,KAAK,QAAQ,IAAI,MAAM,KAAK,WAAW,aAAa,QAAQ;AAC3E,SAAO,eAAgD,SAAS,KAAK,YAAY,QAAQ,KAAK,MAAM;;;;;CAKxG,QAAQ,OAAuB,SAAkE;EAC7F,MAAM,SAAS,KAAK,QAAQ,IAAI,MAAM,KAAK,WAAW,aAAa,QAAQ;AAC3E,SAAO,eAAgD,SAAS,KAAK,YAAY,QAAQ,KAAK,MAAM;;;;;CAKxG,yBAAyB,OAAwC,SAAoG;EACjK,MAAM,SAAS,KAAK,QAAQ,IAAI,MAAM,KAAK,WAAW,aAAa,QAAQ;AAC3E,SAAO,eAAkF,SAAS,KAAK,YAAY,QAAQ,KAAK,MAAM"}

package/dist/core/communication.d.cts

@@ -0,0 +1,6 @@
+import "../struct-ByyMh9ro.cjs";
+import "../duration-C9RVKjpO.cjs";
+import "../timestamp-C1kA6yb7.cjs";
+import "../span-EQEkCEbn.cjs";
+import { CLIMessage, ConnectRequest, ConnectResponse, GetMockRequest, GetMockResponse, MessageType, MockService, SDKMessage, SendInboundSpanForReplayRequest, SendInboundSpanForReplayResponse } from "../communication-D_MVOCQQ.cjs";
+export { CLIMessage, ConnectRequest, ConnectResponse, GetMockRequest, GetMockResponse, MessageType, MockService, SDKMessage, SendInboundSpanForReplayRequest, SendInboundSpanForReplayResponse };

package/dist/core/communication.d.ts

@@ -0,0 +1,6 @@
+import "../struct-BArXEwH6.js";
+import "../duration-2zPogS5a.js";
+import "../timestamp-2doLREh_.js";
+import "../span-BOpbAPMC.js";
+import { CLIMessage, ConnectRequest, ConnectResponse, GetMockRequest, GetMockResponse, MessageType, MockService, SDKMessage, SendInboundSpanForReplayRequest, SendInboundSpanForReplayResponse } from "../communication-bKx0B3ai.js";
+export { CLIMessage, ConnectRequest, ConnectResponse, GetMockRequest, GetMockResponse, MessageType, MockService, SDKMessage, SendInboundSpanForReplayRequest, SendInboundSpanForReplayResponse };

package/dist/core/communication.js

@@ -0,0 +1,7 @@
+import "../struct-LJz5_MGH.js";
+import "../duration-B3fwb4jB.js";
+import "../timestamp-CN7C70ih.js";
+import "../span-DwoKrEhp.js";
+import { CLIMessage, ConnectRequest, ConnectResponse, GetMockRequest, GetMockResponse, MessageType, MockService, SDKMessage, SendInboundSpanForReplayRequest, SendInboundSpanForReplayResponse } from "../communication-Np8Uorqu.js";
+
+export { CLIMessage, ConnectRequest, ConnectResponse, GetMockRequest, GetMockResponse, MessageType, MockService, SDKMessage, SendInboundSpanForReplayRequest, SendInboundSpanForReplayResponse };

package/dist/core/span.cjs

@@ -0,0 +1,13 @@
+require('../struct-B_Dk4HR1.cjs');
+require('../duration-DXK3bnoh.cjs');
+require('../timestamp-Dfs_RIb3.cjs');
+const require_span = require('../span-DdxaadRr.cjs');
+
+exports.PackageType = require_span.PackageType;
+exports.Span = require_span.Span;
+exports.SpanEvent = require_span.SpanEvent;
+exports.SpanKind = require_span.SpanKind;
+exports.SpanLink = require_span.SpanLink;
+exports.SpanStatus = require_span.SpanStatus;
+exports.StatusCode = require_span.StatusCode;
+exports.Trace = require_span.Trace;

package/dist/core/span.d.cts

@@ -0,0 +1,5 @@
+import "../struct-ByyMh9ro.cjs";
+import "../duration-C9RVKjpO.cjs";
+import "../timestamp-C1kA6yb7.cjs";
+import { PackageType, Span, SpanEvent, SpanKind, SpanLink, SpanStatus, StatusCode, Trace } from "../span-EQEkCEbn.cjs";
+export { PackageType, Span, SpanEvent, SpanKind, SpanLink, SpanStatus, StatusCode, Trace };

package/dist/core/span.d.ts

@@ -0,0 +1,5 @@
+import "../struct-BArXEwH6.js";
+import "../duration-2zPogS5a.js";
+import "../timestamp-2doLREh_.js";
+import { PackageType, Span, SpanEvent, SpanKind, SpanLink, SpanStatus, StatusCode, Trace } from "../span-BOpbAPMC.js";
+export { PackageType, Span, SpanEvent, SpanKind, SpanLink, SpanStatus, StatusCode, Trace };

package/dist/core/span.js

@@ -0,0 +1,6 @@
+import "../struct-LJz5_MGH.js";
+import "../duration-B3fwb4jB.js";
+import "../timestamp-CN7C70ih.js";
+import { PackageType, Span, SpanEvent, SpanKind, SpanLink, SpanStatus, StatusCode, Trace } from "../span-DwoKrEhp.js";
+
+export { PackageType, Span, SpanEvent, SpanKind, SpanLink, SpanStatus, StatusCode, Trace };

package/dist/duration-2zPogS5a.d.ts

@@ -0,0 +1,109 @@
+import { BinaryReadOptions, BinaryWriteOptions, IBinaryReader, IBinaryWriter, JsonReadOptions, JsonValue, JsonWriteOptions, MessageType, PartialMessage } from "@protobuf-ts/runtime";
+
+//#region generated/ts/google/protobuf/duration.d.ts
+
+/**
+ * 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
+ */
+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
+ */
+declare const Duration: Duration$Type;
+//#endregion
+export { Duration };
+//# sourceMappingURL=duration-2zPogS5a.d.ts.map

package/dist/duration-2zPogS5a.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration-2zPogS5a.d.ts","names":[],"sources":["../generated/ts/google/protobuf/duration.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAqOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAtHiB,QAAA;;;;;;;;;;;;;;;;;;;;;cAsBX,aAAA,SAAsB,YAAY;;;;;6BAUT,mBAAmB,mBAAmB;;;;yBAqB1C,oBAAoB,0BAA0B,WAAW;iBAmBjE,eAAe,YAAY;6BAQf,wCAAwC,4BAA4B,WAAW;+BAsB7E,kBAAkB,wBAAwB,qBAAqB;;;;;cAgBnF,UAAQ"}

package/dist/duration-B3fwb4jB.js

@@ -0,0 +1,96 @@
+import { MessageType, PbLong, UnknownFieldHandler, WireType, reflectionMergePartial, typeofJsonValue } from "@protobuf-ts/runtime";
+
+//#region generated/ts/google/protobuf/duration.ts
+var Duration$Type = class extends MessageType {
+	constructor() {
+		super("google.protobuf.Duration", [{
+			no: 1,
+			name: "seconds",
+			kind: "scalar",
+			T: 3,
+			L: 0
+		}, {
+			no: 2,
+			name: "nanos",
+			kind: "scalar",
+			T: 5
+		}]);
+	}
+	/**
+	* Encode `Duration` to JSON string like "3.000001s".
+	*/
+	internalJsonWrite(message, options) {
+		let s = PbLong.from(message.seconds).toNumber();
+		if (s > 315576e6 || s < -315576e6) 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() > 315576e6 || longSeconds.toNumber() < -315576e6) 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 !== void 0) 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 1:
+					message.seconds = reader.int64().toBigInt();
+					break;
+				case 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) {
+		if (message.seconds !== 0n) writer.tag(1, WireType.Varint).int64(message.seconds);
+		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
+*/
+const Duration = new Duration$Type();
+
+//#endregion
+export { Duration };
+//# sourceMappingURL=duration-B3fwb4jB.js.map

package/dist/duration-B3fwb4jB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration-B3fwb4jB.js","names":[],"sources":["../generated/ts/google/protobuf/duration.ts"],"sourcesContent":["// @generated by protobuf-ts 2.11.1 with parameter generate_dependencies\n// @generated from protobuf file \"google/protobuf/duration.proto\" (package \"google.protobuf\", syntax proto3)\n// tslint:disable\n//\n// Protocol Buffers - Google's data interchange format\n// Copyright 2008 Google Inc.  All rights reserved.\n// https://developers.google.com/protocol-buffers/\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions are\n// met:\n//\n//     * Redistributions of source code must retain the above copyright\n// notice, this list of conditions and the following disclaimer.\n//     * Redistributions in binary form must reproduce the above\n// copyright notice, this list of conditions and the following disclaimer\n// in the documentation and/or other materials provided with the\n// distribution.\n//     * Neither the name of Google Inc. nor the names of its\n// contributors may be used to endorse or promote products derived from\n// this software without specific prior written permission.\n//\n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n// \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\nimport type { BinaryWriteOptions } from \"@protobuf-ts/runtime\";\nimport type { IBinaryWriter } from \"@protobuf-ts/runtime\";\nimport { WireType } from \"@protobuf-ts/runtime\";\nimport type { BinaryReadOptions } from \"@protobuf-ts/runtime\";\nimport type { IBinaryReader } from \"@protobuf-ts/runtime\";\nimport { UnknownFieldHandler } from \"@protobuf-ts/runtime\";\nimport type { PartialMessage } from \"@protobuf-ts/runtime\";\nimport { reflectionMergePartial } from \"@protobuf-ts/runtime\";\nimport { typeofJsonValue } from \"@protobuf-ts/runtime\";\nimport type { JsonValue } from \"@protobuf-ts/runtime\";\nimport type { JsonReadOptions } from \"@protobuf-ts/runtime\";\nimport type { JsonWriteOptions } from \"@protobuf-ts/runtime\";\nimport { PbLong } from \"@protobuf-ts/runtime\";\nimport { MessageType } from \"@protobuf-ts/runtime\";\n/**\n * A Duration represents a signed, fixed-length span of time represented\n * as a count of seconds and fractions of seconds at nanosecond\n * resolution. It is independent of any calendar and concepts like \"day\"\n * or \"month\". It is related to Timestamp in that the difference between\n * two Timestamp values is a Duration and it can be added or subtracted\n * from a Timestamp. Range is approximately +-10,000 years.\n *\n * # Examples\n *\n * Example 1: Compute Duration from two Timestamps in pseudo code.\n *\n *     Timestamp start = ...;\n *     Timestamp end = ...;\n *     Duration duration = ...;\n *\n *     duration.seconds = end.seconds - start.seconds;\n *     duration.nanos = end.nanos - start.nanos;\n *\n *     if (duration.seconds < 0 && duration.nanos > 0) {\n *       duration.seconds += 1;\n *       duration.nanos -= 1000000000;\n *     } else if (duration.seconds > 0 && duration.nanos < 0) {\n *       duration.seconds -= 1;\n *       duration.nanos += 1000000000;\n *     }\n *\n * Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.\n *\n *     Timestamp start = ...;\n *     Duration duration = ...;\n *     Timestamp end = ...;\n *\n *     end.seconds = start.seconds + duration.seconds;\n *     end.nanos = start.nanos + duration.nanos;\n *\n *     if (end.nanos < 0) {\n *       end.seconds -= 1;\n *       end.nanos += 1000000000;\n *     } else if (end.nanos >= 1000000000) {\n *       end.seconds += 1;\n *       end.nanos -= 1000000000;\n *     }\n *\n * Example 3: Compute Duration from datetime.timedelta in Python.\n *\n *     td = datetime.timedelta(days=3, minutes=10)\n *     duration = Duration()\n *     duration.FromTimedelta(td)\n *\n * # JSON Mapping\n *\n * In JSON format, the Duration type is encoded as a string rather than an\n * object, where the string ends in the suffix \"s\" (indicating seconds) and\n * is preceded by the number of seconds, with nanoseconds expressed as\n * fractional seconds. For example, 3 seconds with 0 nanoseconds should be\n * encoded in JSON format as \"3s\", while 3 seconds and 1 nanosecond should\n * be expressed in JSON format as \"3.000000001s\", and 3 seconds and 1\n * microsecond should be expressed in JSON format as \"3.000001s\".\n *\n *\n * @generated from protobuf message google.protobuf.Duration\n */\nexport interface Duration {\n    /**\n     * Signed seconds of the span of time. Must be from -315,576,000,000\n     * to +315,576,000,000 inclusive. Note: these bounds are computed from:\n     * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years\n     *\n     * @generated from protobuf field: int64 seconds = 1\n     */\n    seconds: bigint;\n    /**\n     * Signed fractions of a second at nanosecond resolution of the span\n     * of time. Durations less than one second are represented with a 0\n     * `seconds` field and a positive or negative `nanos` field. For durations\n     * of one second or more, a non-zero value for the `nanos` field must be\n     * of the same sign as the `seconds` field. Must be from -999,999,999\n     * to +999,999,999 inclusive.\n     *\n     * @generated from protobuf field: int32 nanos = 2\n     */\n    nanos: number;\n}\n// @generated message type with reflection information, may provide speed optimized methods\nclass Duration$Type extends MessageType<Duration> {\n    constructor() {\n        super(\"google.protobuf.Duration\", [\n            { no: 1, name: \"seconds\", kind: \"scalar\", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },\n            { no: 2, name: \"nanos\", kind: \"scalar\", T: 5 /*ScalarType.INT32*/ }\n        ]);\n    }\n    /**\n     * Encode `Duration` to JSON string like \"3.000001s\".\n     */\n    internalJsonWrite(message: Duration, options: JsonWriteOptions): JsonValue {\n        let s = PbLong.from(message.seconds).toNumber();\n        if (s > 315576000000 || s < -315576000000)\n            throw new Error(\"Duration value out of range.\");\n        let text = message.seconds.toString();\n        if (s === 0 && message.nanos < 0)\n            text = \"-\" + text;\n        if (message.nanos !== 0) {\n            let nanosStr = Math.abs(message.nanos).toString();\n            nanosStr = \"0\".repeat(9 - nanosStr.length) + nanosStr;\n            if (nanosStr.substring(3) === \"000000\")\n                nanosStr = nanosStr.substring(0, 3);\n            else if (nanosStr.substring(6) === \"000\")\n                nanosStr = nanosStr.substring(0, 6);\n            text += \".\" + nanosStr;\n        }\n        return text + \"s\";\n    }\n    /**\n     * Decode `Duration` from JSON string like \"3.000001s\"\n     */\n    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Duration): Duration {\n        if (typeof json !== \"string\")\n            throw new Error(\"Unable to parse Duration from JSON \" + typeofJsonValue(json) + \". Expected string.\");\n        let match = json.match(/^(-?)([0-9]+)(?:\\.([0-9]+))?s/);\n        if (match === null)\n            throw new Error(\"Unable to parse Duration from JSON string. Invalid format.\");\n        if (!target)\n            target = this.create();\n        let [, sign, secs, nanos] = match;\n        let longSeconds = PbLong.from(sign + secs);\n        if (longSeconds.toNumber() > 315576000000 || longSeconds.toNumber() < -315576000000)\n            throw new Error(\"Unable to parse Duration from JSON string. Value out of range.\");\n        target.seconds = longSeconds.toBigInt();\n        if (typeof nanos == \"string\") {\n            let nanosStr = sign + nanos + \"0\".repeat(9 - nanos.length);\n            target.nanos = parseInt(nanosStr);\n        }\n        return target;\n    }\n    create(value?: PartialMessage<Duration>): Duration {\n        const message = globalThis.Object.create((this.messagePrototype!));\n        message.seconds = 0n;\n        message.nanos = 0;\n        if (value !== undefined)\n            reflectionMergePartial<Duration>(this, message, value);\n        return message;\n    }\n    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Duration): Duration {\n        let message = target ?? this.create(), end = reader.pos + length;\n        while (reader.pos < end) {\n            let [fieldNo, wireType] = reader.tag();\n            switch (fieldNo) {\n                case /* int64 seconds */ 1:\n                    message.seconds = reader.int64().toBigInt();\n                    break;\n                case /* int32 nanos */ 2:\n                    message.nanos = reader.int32();\n                    break;\n                default:\n                    let u = options.readUnknownField;\n                    if (u === \"throw\")\n                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);\n                    let d = reader.skip(wireType);\n                    if (u !== false)\n                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);\n            }\n        }\n        return message;\n    }\n    internalBinaryWrite(message: Duration, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {\n        /* int64 seconds = 1; */\n        if (message.seconds !== 0n)\n            writer.tag(1, WireType.Varint).int64(message.seconds);\n        /* int32 nanos = 2; */\n        if (message.nanos !== 0)\n            writer.tag(2, WireType.Varint).int32(message.nanos);\n        let u = options.writeUnknownFields;\n        if (u !== false)\n            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);\n        return writer;\n    }\n}\n/**\n * @generated MessageType for protobuf message google.protobuf.Duration\n */\nexport const Duration = new Duration$Type();\n"],"mappings":"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"}

package/dist/duration-C9RVKjpO.d.cts

@@ -0,0 +1,109 @@
+import { BinaryReadOptions, BinaryWriteOptions, IBinaryReader, IBinaryWriter, JsonReadOptions, JsonValue, JsonWriteOptions, MessageType, PartialMessage } from "@protobuf-ts/runtime";
+
+//#region generated/ts/google/protobuf/duration.d.ts
+
+/**
+ * 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
+ */
+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
+ */
+declare const Duration: Duration$Type;
+//#endregion
+export { Duration };
+//# sourceMappingURL=duration-C9RVKjpO.d.cts.map

package/dist/duration-C9RVKjpO.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration-C9RVKjpO.d.cts","names":[],"sources":["../generated/ts/google/protobuf/duration.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAqOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAtHiB,QAAA;;;;;;;;;;;;;;;;;;;;;cAsBX,aAAA,SAAsB,YAAY;;;;;6BAUT,mBAAmB,mBAAmB;;;;yBAqB1C,oBAAoB,0BAA0B,WAAW;iBAmBjE,eAAe,YAAY;6BAQf,wCAAwC,4BAA4B,WAAW;+BAsB7E,kBAAkB,wBAAwB,qBAAqB;;;;;cAgBnF,UAAQ"}

package/dist/duration-DXK3bnoh.cjs

@@ -0,0 +1,103 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+let __protobuf_ts_runtime = require("@protobuf-ts/runtime");
+__protobuf_ts_runtime = require_chunk.__toESM(__protobuf_ts_runtime);
+
+//#region generated/ts/google/protobuf/duration.ts
+var Duration$Type = class extends __protobuf_ts_runtime.MessageType {
+	constructor() {
+		super("google.protobuf.Duration", [{
+			no: 1,
+			name: "seconds",
+			kind: "scalar",
+			T: 3,
+			L: 0
+		}, {
+			no: 2,
+			name: "nanos",
+			kind: "scalar",
+			T: 5
+		}]);
+	}
+	/**
+	* Encode `Duration` to JSON string like "3.000001s".
+	*/
+	internalJsonWrite(message, options) {
+		let s = __protobuf_ts_runtime.PbLong.from(message.seconds).toNumber();
+		if (s > 315576e6 || s < -315576e6) 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 " + (0, __protobuf_ts_runtime.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 = __protobuf_ts_runtime.PbLong.from(sign + secs);
+		if (longSeconds.toNumber() > 315576e6 || longSeconds.toNumber() < -315576e6) 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 !== void 0) (0, __protobuf_ts_runtime.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 1:
+					message.seconds = reader.int64().toBigInt();
+					break;
+				case 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 ? __protobuf_ts_runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.seconds !== 0n) writer.tag(1, __protobuf_ts_runtime.WireType.Varint).int64(message.seconds);
+		if (message.nanos !== 0) writer.tag(2, __protobuf_ts_runtime.WireType.Varint).int32(message.nanos);
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? __protobuf_ts_runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message google.protobuf.Duration
+*/
+const Duration = new Duration$Type();
+
+//#endregion
+Object.defineProperty(exports, 'Duration', {
+  enumerable: true,
+  get: function () {
+    return Duration;
+  }
+});
+//# sourceMappingURL=duration-DXK3bnoh.cjs.map