@mysten/sui 1.41.0 → 1.42.0

package/src/grpc/proto/google/protobuf/timestamp.ts

@@ -36,12 +36,12 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
-import { typeofJsonValue } 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 { PbLong } from '@protobuf-ts/runtime';
-import { MessageType } from '@protobuf-ts/runtime';
+import { typeofJsonValue } 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 { PbLong } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
 /**
  * A Timestamp represents a point in time independent of any time zone
  * or calendar, represented as seconds and fractions of seconds at
@@ -135,124 +135,103 @@ import { MessageType } from '@protobuf-ts/runtime';
  * @generated from protobuf message google.protobuf.Timestamp
  */
 export interface Timestamp {
-	/**
-	 * Represents seconds of UTC time since Unix epoch
-	 * `1970-01-01T00:00:00Z`. Must be from `0001-01-01T00:00:00Z` to
-	 * `9999-12-31T23:59:59Z` inclusive.
-	 *
-	 * @generated from protobuf field: int64 seconds = 1;
-	 */
-	seconds: bigint;
-	/**
-	 * Non-negative fractions of a second at nanosecond resolution. Negative
-	 * second values with fractions must still have non-negative nano values
-	 * that count forward in time. Must be from 0 to 999,999,999
-	 * inclusive.
-	 *
-	 * @generated from protobuf field: int32 nanos = 2;
-	 */
-	nanos: number;
+    /**
+     * Represents seconds of UTC time since Unix epoch
+     * `1970-01-01T00:00:00Z`. Must be from `0001-01-01T00:00:00Z` to
+     * `9999-12-31T23:59:59Z` inclusive.
+     *
+     * @generated from protobuf field: int64 seconds = 1;
+     */
+    seconds: bigint;
+    /**
+     * Non-negative fractions of a second at nanosecond resolution. Negative
+     * second values with fractions must still have non-negative nano values
+     * that count forward in time. Must be from 0 to 999,999,999
+     * inclusive.
+     *
+     * @generated from protobuf field: int32 nanos = 2;
+     */
+    nanos: number;
 }
 // @generated message type with reflection information, may provide speed optimized methods
 class Timestamp$Type extends MessageType<Timestamp> {
-	constructor() {
-		super('google.protobuf.Timestamp', [
-			{
-				no: 1,
-				name: 'seconds',
-				kind: 'scalar',
-				T: 3 /*ScalarType.INT64*/,
-				L: 0 /*LongType.BIGINT*/,
-			},
-			{ no: 2, name: 'nanos', kind: 'scalar', T: 5 /*ScalarType.INT32*/ },
-		]);
-	}
-	/**
-	 * Creates a new `Timestamp` for the current time.
-	 */
-	now(): Timestamp {
-		const msg = this.create();
-		const ms = Date.now();
-		msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt();
-		msg.nanos = (ms % 1000) * 1000000;
-		return msg;
-	}
-	/**
-	 * Converts a `Timestamp` to a JavaScript Date.
-	 */
-	toDate(message: Timestamp): Date {
-		return new Date(
-			PbLong.from(message.seconds).toNumber() * 1000 + Math.ceil(message.nanos / 1000000),
-		);
-	}
-	/**
-	 * Converts a JavaScript Date to a `Timestamp`.
-	 */
-	fromDate(date: Date): Timestamp {
-		const msg = this.create();
-		const ms = date.getTime();
-		msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt();
-		msg.nanos = ((ms % 1000) + (ms < 0 && ms % 1000 !== 0 ? 1000 : 0)) * 1000000;
-		return msg;
-	}
-	/**
-	 * In JSON format, the `Timestamp` type is encoded as a string
-	 * in the RFC 3339 format.
-	 */
-	internalJsonWrite(message: Timestamp, options: JsonWriteOptions): JsonValue {
-		let ms = PbLong.from(message.seconds).toNumber() * 1000;
-		if (ms < Date.parse('0001-01-01T00:00:00Z') || ms > Date.parse('9999-12-31T23:59:59Z'))
-			throw new Error(
-				'Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.',
-			);
-		if (message.nanos < 0)
-			throw new Error('Unable to encode invalid Timestamp to JSON. Nanos must not be negative.');
-		let z = 'Z';
-		if (message.nanos > 0) {
-			let nanosStr = (message.nanos + 1000000000).toString().substring(1);
-			if (nanosStr.substring(3) === '000000') z = '.' + nanosStr.substring(0, 3) + 'Z';
-			else if (nanosStr.substring(6) === '000') z = '.' + nanosStr.substring(0, 6) + 'Z';
-			else z = '.' + nanosStr + 'Z';
-		}
-		return new Date(ms).toISOString().replace('.000Z', z);
-	}
-	/**
-	 * In JSON format, the `Timestamp` type is encoded as a string
-	 * in the RFC 3339 format.
-	 */
-	internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Timestamp): Timestamp {
-		if (typeof json !== 'string')
-			throw new Error('Unable to parse Timestamp from JSON ' + typeofJsonValue(json) + '.');
-		let matches = json.match(
-			/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/,
-		);
-		if (!matches) throw new Error('Unable to parse Timestamp from JSON. Invalid format.');
-		let ms = Date.parse(
-			matches[1] +
-				'-' +
-				matches[2] +
-				'-' +
-				matches[3] +
-				'T' +
-				matches[4] +
-				':' +
-				matches[5] +
-				':' +
-				matches[6] +
-				(matches[8] ? matches[8] : 'Z'),
-		);
-		if (Number.isNaN(ms)) throw new Error('Unable to parse Timestamp from JSON. Invalid value.');
-		if (ms < Date.parse('0001-01-01T00:00:00Z') || ms > Date.parse('9999-12-31T23:59:59Z'))
-			throw new globalThis.Error(
-				'Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.',
-			);
-		if (!target) target = this.create();
-		target.seconds = PbLong.from(ms / 1000).toBigInt();
-		target.nanos = 0;
-		if (matches[7])
-			target.nanos = parseInt('1' + matches[7] + '0'.repeat(9 - matches[7].length)) - 1000000000;
-		return target;
-	}
+    constructor() {
+        super("google.protobuf.Timestamp", [
+            { no: 1, name: "seconds", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "nanos", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
+        ]);
+    }
+    /**
+     * Creates a new `Timestamp` for the current time.
+     */
+    now(): Timestamp {
+        const msg = this.create();
+        const ms = Date.now();
+        msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt();
+        msg.nanos = (ms % 1000) * 1000000;
+        return msg;
+    }
+    /**
+     * Converts a `Timestamp` to a JavaScript Date.
+     */
+    toDate(message: Timestamp): Date {
+        return new Date(PbLong.from(message.seconds).toNumber() * 1000 + Math.ceil(message.nanos / 1000000));
+    }
+    /**
+     * Converts a JavaScript Date to a `Timestamp`.
+     */
+    fromDate(date: Date): Timestamp {
+        const msg = this.create();
+        const ms = date.getTime();
+        msg.seconds = PbLong.from(Math.floor(ms / 1000)).toBigInt();
+        msg.nanos = ((ms % 1000) + (ms < 0 && ms % 1000 !== 0 ? 1000 : 0)) * 1000000;
+        return msg;
+    }
+    /**
+     * In JSON format, the `Timestamp` type is encoded as a string
+     * in the RFC 3339 format.
+     */
+    internalJsonWrite(message: Timestamp, options: JsonWriteOptions): JsonValue {
+        let ms = PbLong.from(message.seconds).toNumber() * 1000;
+        if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z"))
+            throw new Error("Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.");
+        if (message.nanos < 0)
+            throw new Error("Unable to encode invalid Timestamp to JSON. Nanos must not be negative.");
+        let z = "Z";
+        if (message.nanos > 0) {
+            let nanosStr = (message.nanos + 1000000000).toString().substring(1);
+            if (nanosStr.substring(3) === "000000")
+                z = "." + nanosStr.substring(0, 3) + "Z";
+            else if (nanosStr.substring(6) === "000")
+                z = "." + nanosStr.substring(0, 6) + "Z";
+            else
+                z = "." + nanosStr + "Z";
+        }
+        return new Date(ms).toISOString().replace(".000Z", z);
+    }
+    /**
+     * In JSON format, the `Timestamp` type is encoded as a string
+     * in the RFC 3339 format.
+     */
+    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Timestamp): Timestamp {
+        if (typeof json !== "string")
+            throw new Error("Unable to parse Timestamp from JSON " + typeofJsonValue(json) + ".");
+        let matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
+        if (!matches)
+            throw new Error("Unable to parse Timestamp from JSON. Invalid format.");
+        let ms = Date.parse(matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z"));
+        if (Number.isNaN(ms))
+            throw new Error("Unable to parse Timestamp from JSON. Invalid value.");
+        if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z"))
+            throw new globalThis.Error("Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.");
+        if (!target)
+            target = this.create();
+        target.seconds = PbLong.from(ms / 1000).toBigInt();
+        target.nanos = 0;
+        if (matches[7])
+            target.nanos = (parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - 1000000000);
+        return target;
+    }
 }
 /**
  * @generated MessageType for protobuf message google.protobuf.Timestamp