@mysten/sui 1.42.0 → 1.43.1

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,103 +135,124 @@ 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