@algorandfoundation/algokit-utils 9.2.0 → 10.0.0-alpha.10

package/packages/sdk/src/encoding/encoding.mjs

@@ -0,0 +1,298 @@
+import intDecoding_default from "../types/intDecoding.mjs";
+import { arrayEqual, parseJSON, stringifyJSON } from "../utils/utils.mjs";
+import { bytesToBase64, coerceToBytes } from "./binarydata.mjs";
+import { IntMode, RawBinaryString, decode, encode } from "algorand-msgpack";
+
+//#region packages/sdk/src/encoding/encoding.ts
+/**
+* This file is a wrapper of msgpack.js.
+* The wrapper was written in order to ensure correct encoding of Algorand Transaction and other formats.
+* In particular, it matches go-algorand blockchain client, written in go (https://www.github.com/algorand/go-algorand.
+* Algorand's msgpack encoding follows to following rules -
+*  1. Every integer must be encoded to the smallest type possible (0-255-\>8bit, 256-65535-\>16bit, etx)
+*  2. All fields names must be sorted
+*  3. All empty and 0 fields should be omitted
+*  4. Every positive number must be encoded as uint
+*  5. Binary blob should be used for binary data and string for strings
+*  */
+const ERROR_CONTAINS_EMPTY_STRING = "The object contains empty or 0 values. First empty or 0 value encountered during encoding: ";
+/**
+* containsEmpty returns true if any of the object's values are empty, false otherwise.
+* Empty arrays considered empty
+* @param obj - The object to check
+* @returns \{true, empty key\} if contains empty, \{false, undefined\} otherwise
+*/
+function containsEmpty(obj) {
+	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) {
+		if (!obj[key] || obj[key].length === 0) return {
+			containsEmpty: true,
+			firstEmptyKey: key
+		};
+	}
+	return {
+		containsEmpty: false,
+		firstEmptyKey: void 0
+	};
+}
+/**
+* msgpackRawEncode encodes objects using msgpack, regardless of whether there are
+* empty or 0 value fields.
+* @param obj - a dictionary to be encoded. May or may not contain empty or 0 values.
+* @returns msgpack representation of the object
+*/
+function msgpackRawEncode(obj) {
+	return encode(obj, { sortKeys: true });
+}
+/**
+* encodeObj takes a javascript object and returns its msgpack encoding
+* Note that the encoding sorts the fields alphabetically
+* @param o - js object to be encoded. Must not contain empty or 0 values.
+* @returns Uint8Array binary representation
+* @throws Error containing ERROR_CONTAINS_EMPTY_STRING if the object contains empty or zero values
+*
+* @deprecated Use {@link msgpackRawEncode} instead. Note that function does not
+*   check for empty values like this one does.
+*/
+function encodeObj(obj) {
+	const emptyCheck = containsEmpty(obj);
+	if (emptyCheck.containsEmpty) throw new Error(ERROR_CONTAINS_EMPTY_STRING + emptyCheck.firstEmptyKey);
+	return msgpackRawEncode(obj);
+}
+function intDecodingToIntMode(intDecoding) {
+	switch (intDecoding) {
+		case intDecoding_default.UNSAFE: return IntMode.UNSAFE_NUMBER;
+		case intDecoding_default.SAFE: return IntMode.SAFE_NUMBER;
+		case intDecoding_default.MIXED: return IntMode.MIXED;
+		case intDecoding_default.BIGINT: return IntMode.BIGINT;
+		default: throw new Error(`Invalid intDecoding: ${intDecoding}`);
+	}
+}
+/**
+* Decodes msgpack bytes into a plain JavaScript object.
+* @param buffer - The msgpack bytes to decode
+* @param options - Options for decoding, including int decoding mode. See {@link IntDecoding} for more information.
+* @returns The decoded object
+*/
+function msgpackRawDecode(buffer, options) {
+	return decode(buffer, { intMode: options?.intDecoding ? intDecodingToIntMode(options?.intDecoding) : IntMode.BIGINT });
+}
+/**
+* decodeObj takes a Uint8Array and returns its javascript obj
+* @param o - Uint8Array to decode
+* @returns object
+*
+* @deprecated Use {@link msgpackRawDecode} instead. Note that this function uses `IntDecoding.MIXED`
+*   while `msgpackRawDecode` defaults to `IntDecoding.BIGINT` for int decoding, though it is
+*   configurable.
+*/
+function decodeObj(o) {
+	return msgpackRawDecode(o, { intDecoding: intDecoding_default.MIXED });
+}
+/**
+* Decodes msgpack bytes into a Map object. This supports decoding non-string map keys.
+* @param encoded - The msgpack bytes to decode
+* @param options - Options for decoding, including int decoding mode. See {@link IntDecoding} for more information.
+* @returns The decoded Map object
+*/
+function msgpackRawDecodeAsMap(encoded, options) {
+	return decode(encoded, {
+		intMode: options?.intDecoding ? intDecodingToIntMode(options?.intDecoding) : IntMode.BIGINT,
+		useMap: true
+	});
+}
+function msgpackRawDecodeAsMapWithRawStrings(encoded, options) {
+	return decode(encoded, {
+		intMode: options?.intDecoding ? intDecodingToIntMode(options?.intDecoding) : IntMode.BIGINT,
+		useMap: true,
+		rawBinaryStringKeys: true,
+		rawBinaryStringValues: true,
+		useRawBinaryStringClass: true
+	});
+}
+function msgpackEncodingDataToJSONEncodingData(e) {
+	if (e === null || e === void 0) return e;
+	if (e instanceof Uint8Array) return bytesToBase64(e);
+	if (Array.isArray(e)) return e.map(msgpackEncodingDataToJSONEncodingData);
+	if (e instanceof Map) {
+		const obj = {};
+		for (const [k, v] of e) {
+			if (typeof k !== "string") throw new Error(`JSON map key must be a string: ${k}`);
+			obj[k] = msgpackEncodingDataToJSONEncodingData(v);
+		}
+		return obj;
+	}
+	return e;
+}
+function jsonEncodingDataToMsgpackEncodingData(e) {
+	if (e === null || e === void 0) return e;
+	if (typeof e === "string" || typeof e === "number" || typeof e === "bigint" || typeof e === "boolean") return e;
+	if (Array.isArray(e)) return e.map(jsonEncodingDataToMsgpackEncodingData);
+	if (typeof e === "object") {
+		const obj = /* @__PURE__ */ new Map();
+		for (const [key, value] of Object.entries(e)) obj.set(key, jsonEncodingDataToMsgpackEncodingData(value));
+		return obj;
+	}
+	throw new Error(`Invalid JSON encoding data: ${e}`);
+}
+var MsgpackObjectPathSegmentKind = /* @__PURE__ */ function(MsgpackObjectPathSegmentKind$1) {
+	MsgpackObjectPathSegmentKind$1[MsgpackObjectPathSegmentKind$1["MAP_VALUE"] = 0] = "MAP_VALUE";
+	MsgpackObjectPathSegmentKind$1[MsgpackObjectPathSegmentKind$1["ARRAY_ELEMENT"] = 1] = "ARRAY_ELEMENT";
+	return MsgpackObjectPathSegmentKind$1;
+}(MsgpackObjectPathSegmentKind || {});
+/**
+* This class is used to index into an encoded msgpack object and extract raw strings.
+*/
+var MsgpackRawStringProvider = class MsgpackRawStringProvider {
+	parent;
+	baseObjectBytes;
+	segment;
+	resolvedCache = null;
+	resolvedCachePresent = false;
+	constructor({ parent, segment, baseObjectBytes }) {
+		this.parent = parent;
+		this.segment = segment;
+		this.baseObjectBytes = baseObjectBytes;
+	}
+	/**
+	* Create a new provider that resolves to the current provider's map value at the given key.
+	*/
+	withMapValue(key) {
+		return new MsgpackRawStringProvider({
+			parent: this,
+			segment: {
+				kind: MsgpackObjectPathSegmentKind.MAP_VALUE,
+				key
+			}
+		});
+	}
+	/**
+	* Create a new provider that resolves to the current provider's array element at the given index.
+	*/
+	withArrayElement(index) {
+		return new MsgpackRawStringProvider({
+			parent: this,
+			segment: {
+				kind: MsgpackObjectPathSegmentKind.ARRAY_ELEMENT,
+				key: index
+			}
+		});
+	}
+	/**
+	* Get the raw string at the current location. If the current location is not a raw string, an error is thrown.
+	*/
+	getRawStringAtCurrentLocation() {
+		const resolved = this.resolve();
+		if (resolved instanceof RawBinaryString) return resolved.rawBinaryValue;
+		throw new Error(`Invalid type. Expected RawBinaryString, got ${resolved} (${typeof resolved})`);
+	}
+	/**
+	* Get the raw string map keys and values at the current location. If the current location is not a map, an error is thrown.
+	*/
+	getRawStringKeysAndValuesAtCurrentLocation() {
+		const resolved = this.resolve();
+		if (!(resolved instanceof Map)) throw new Error(`Invalid type. Expected Map, got ${resolved} (${typeof resolved})`);
+		const keysAndValues = /* @__PURE__ */ new Map();
+		for (const [key, value] of resolved) if (key instanceof RawBinaryString) keysAndValues.set(key.rawBinaryValue, value);
+		else throw new Error(`Invalid type for map key. Expected RawBinaryString, got ${key} (${typeof key})`);
+		return keysAndValues;
+	}
+	/**
+	* Resolve the provider by extracting the value it indicates from the base msgpack object.
+	*/
+	resolve() {
+		if (this.resolvedCachePresent) return this.resolvedCache;
+		let parentResolved;
+		if (this.parent) parentResolved = this.parent.resolve();
+		else parentResolved = msgpackRawDecodeAsMapWithRawStrings(this.baseObjectBytes);
+		if (!this.segment) {
+			this.resolvedCache = parentResolved;
+			this.resolvedCachePresent = true;
+			return parentResolved;
+		}
+		if (this.segment.kind === MsgpackObjectPathSegmentKind.MAP_VALUE) {
+			if (!(parentResolved instanceof Map)) throw new Error(`Invalid type. Expected Map, got ${parentResolved} (${typeof parentResolved})`);
+			if (typeof this.segment.key === "string" || this.segment.key instanceof Uint8Array || this.segment.key instanceof RawBinaryString) {
+				const targetBytes = this.segment.key instanceof RawBinaryString ? this.segment.key.rawBinaryValue : coerceToBytes(this.segment.key);
+				const targetIsRawString = typeof this.segment.key === "string" || this.segment.key instanceof RawBinaryString;
+				for (const [key, value] of parentResolved) {
+					let potentialKeyBytes;
+					if (targetIsRawString) {
+						if (key instanceof RawBinaryString) potentialKeyBytes = key.rawBinaryValue;
+					} else if (key instanceof Uint8Array) potentialKeyBytes = key;
+					if (potentialKeyBytes && arrayEqual(targetBytes, potentialKeyBytes)) {
+						this.resolvedCache = value;
+						break;
+					}
+				}
+			} else this.resolvedCache = parentResolved.get(this.segment.key);
+			this.resolvedCachePresent = true;
+			return this.resolvedCache;
+		}
+		if (this.segment.kind === MsgpackObjectPathSegmentKind.ARRAY_ELEMENT) {
+			if (!Array.isArray(parentResolved)) throw new Error(`Invalid type. Expected Array, got ${parentResolved} (${typeof parentResolved})`);
+			this.resolvedCache = parentResolved[this.segment.key];
+			this.resolvedCachePresent = true;
+			return this.resolvedCache;
+		}
+		throw new Error(`Invalid segment kind: ${this.segment.kind}`);
+	}
+	/**
+	* Get the path string of the current location indicated by the provider. Useful for debugging.
+	*/
+	getPathString() {
+		const parentPathString = this.parent ? this.parent.getPathString() : "root";
+		if (!this.segment) return parentPathString;
+		if (this.segment.kind === MsgpackObjectPathSegmentKind.MAP_VALUE) return `${parentPathString} -> map key "${this.segment.key}" (${typeof this.segment.key})`;
+		if (this.segment.kind === MsgpackObjectPathSegmentKind.ARRAY_ELEMENT) return `${parentPathString} -> array index ${this.segment.key} (${typeof this.segment.key})`;
+		return `${parentPathString} -> unknown segment kind ${this.segment.kind}`;
+	}
+};
+/**
+* A Schema is used to prepare objects for encoding and decoding from msgpack and JSON.
+*
+* Schemas represent a specific type.
+*/
+var Schema = class {};
+/**
+* Decode a msgpack byte array to an Encodable object.
+* @param encoded - The msgpack bytes to decode
+* @param c - The class of the object to decode. This class must match the object that was encoded.
+* @returns An instance of the class with the decoded data
+*/
+function decodeMsgpack(encoded, c) {
+	const decoded = msgpackRawDecodeAsMap(encoded);
+	const rawStringProvider = new MsgpackRawStringProvider({ baseObjectBytes: encoded });
+	return c.fromEncodingData(c.encodingSchema.fromPreparedMsgpack(decoded, rawStringProvider));
+}
+/**
+* Encode an Encodable object to a msgpack byte array.
+* @param e - The object to encode
+* @returns A msgpack byte array encoding of the object
+*/
+function encodeMsgpack(e) {
+	return msgpackRawEncode(e.getEncodingSchema().prepareMsgpack(e.toEncodingData()));
+}
+/**
+* Decode a JSON string to an Encodable object.
+* @param encoded - The JSON string to decode
+* @param c - The class of the object to decode. This class must match the object that was encoded.
+* @returns An instance of the class with the decoded data
+*/
+function decodeJSON(encoded, c) {
+	const decoded = parseJSON(encoded, { intDecoding: intDecoding_default.BIGINT });
+	return c.fromEncodingData(c.encodingSchema.fromPreparedJSON(decoded));
+}
+/**
+* Encode an Encodable object to a JSON string.
+* @param e - The object to encode
+* @param options - Optional encoding options. See {@link EncodeJSONOptions} for more information.
+* @returns A JSON string encoding of the object
+*/
+function encodeJSON(e, options) {
+	const { space, ...prepareJSONOptions } = options ?? {};
+	return stringifyJSON(e.getEncodingSchema().prepareJSON(e.toEncodingData(), prepareJSONOptions), void 0, space);
+}
+
+//#endregion
+export { ERROR_CONTAINS_EMPTY_STRING, MsgpackRawStringProvider, Schema, decodeJSON, decodeMsgpack, decodeObj, encodeJSON, encodeMsgpack, encodeObj, jsonEncodingDataToMsgpackEncodingData, msgpackEncodingDataToJSONEncodingData, msgpackRawDecode, msgpackRawDecodeAsMap, msgpackRawEncode };
+//# sourceMappingURL=encoding.mjs.map

package/packages/sdk/src/encoding/encoding.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.mjs","names":["msgpackEncode","IntDecoding","msgpackDecode","obj: { [key: string]: JSONEncodingData }","parentResolved: MsgpackEncodingData","potentialKeyBytes: Uint8Array | undefined","decoded: JSONEncodingData"],"sources":["../../../../../packages/sdk/src/encoding/encoding.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/**\n * This file is a wrapper of msgpack.js.\n * The wrapper was written in order to ensure correct encoding of Algorand Transaction and other formats.\n * In particular, it matches go-algorand blockchain client, written in go (https://www.github.com/algorand/go-algorand.\n * Algorand's msgpack encoding follows to following rules -\n *  1. Every integer must be encoded to the smallest type possible (0-255-\\>8bit, 256-65535-\\>16bit, etx)\n *  2. All fields names must be sorted\n *  3. All empty and 0 fields should be omitted\n *  4. Every positive number must be encoded as uint\n *  5. Binary blob should be used for binary data and string for strings\n *  */\n\nimport {\n  DecoderOptions,\n  EncoderOptions,\n  IntMode,\n  RawBinaryString,\n  decode as msgpackDecode,\n  encode as msgpackEncode,\n} from 'algorand-msgpack'\nimport IntDecoding from '../types/intDecoding.js'\nimport { arrayEqual, parseJSON, stringifyJSON } from '../utils/utils.js'\nimport { bytesToBase64, coerceToBytes } from './binarydata.js'\n\n// Errors\nexport const ERROR_CONTAINS_EMPTY_STRING = 'The object contains empty or 0 values. First empty or 0 value encountered during encoding: '\n\n/**\n * containsEmpty returns true if any of the object's values are empty, false otherwise.\n * Empty arrays considered empty\n * @param obj - The object to check\n * @returns \\{true, empty key\\} if contains empty, \\{false, undefined\\} otherwise\n */\nfunction containsEmpty(obj: Record<string | number | symbol, any>) {\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      if (!obj[key] || obj[key].length === 0) {\n        return { containsEmpty: true, firstEmptyKey: key }\n      }\n    }\n  }\n  return { containsEmpty: false, firstEmptyKey: undefined }\n}\n\n/**\n * msgpackRawEncode encodes objects using msgpack, regardless of whether there are\n * empty or 0 value fields.\n * @param obj - a dictionary to be encoded. May or may not contain empty or 0 values.\n * @returns msgpack representation of the object\n */\nexport function msgpackRawEncode(obj: unknown) {\n  // enable the canonical option\n  const options: EncoderOptions = { sortKeys: true }\n  return msgpackEncode(obj, options)\n}\n\n/**\n * encodeObj takes a javascript object and returns its msgpack encoding\n * Note that the encoding sorts the fields alphabetically\n * @param o - js object to be encoded. Must not contain empty or 0 values.\n * @returns Uint8Array binary representation\n * @throws Error containing ERROR_CONTAINS_EMPTY_STRING if the object contains empty or zero values\n *\n * @deprecated Use {@link msgpackRawEncode} instead. Note that function does not\n *   check for empty values like this one does.\n */\nexport function encodeObj(obj: Record<string | number | symbol, any>) {\n  // Check for empty values\n  const emptyCheck = containsEmpty(obj)\n  if (emptyCheck.containsEmpty) {\n    throw new Error(ERROR_CONTAINS_EMPTY_STRING + emptyCheck.firstEmptyKey)\n  }\n  return msgpackRawEncode(obj)\n}\n\nfunction intDecodingToIntMode(intDecoding: IntDecoding): IntMode {\n  switch (intDecoding) {\n    case IntDecoding.UNSAFE:\n      return IntMode.UNSAFE_NUMBER\n    case IntDecoding.SAFE:\n      return IntMode.SAFE_NUMBER\n    case IntDecoding.MIXED:\n      return IntMode.MIXED\n    case IntDecoding.BIGINT:\n      return IntMode.BIGINT\n    default:\n      throw new Error(`Invalid intDecoding: ${intDecoding}`)\n  }\n}\n\n/**\n * Decodes msgpack bytes into a plain JavaScript object.\n * @param buffer - The msgpack bytes to decode\n * @param options - Options for decoding, including int decoding mode. See {@link IntDecoding} for more information.\n * @returns The decoded object\n */\nexport function msgpackRawDecode(buffer: ArrayLike<number>, options?: { intDecoding: IntDecoding }) {\n  const decoderOptions: DecoderOptions = {\n    intMode: options?.intDecoding ? intDecodingToIntMode(options?.intDecoding) : IntMode.BIGINT,\n  }\n  return msgpackDecode(buffer, decoderOptions)\n}\n\n/**\n * decodeObj takes a Uint8Array and returns its javascript obj\n * @param o - Uint8Array to decode\n * @returns object\n *\n * @deprecated Use {@link msgpackRawDecode} instead. Note that this function uses `IntDecoding.MIXED`\n *   while `msgpackRawDecode` defaults to `IntDecoding.BIGINT` for int decoding, though it is\n *   configurable.\n */\nexport function decodeObj(o: ArrayLike<number>) {\n  return msgpackRawDecode(o, { intDecoding: IntDecoding.MIXED })\n}\n\n/**\n * Decodes msgpack bytes into a Map object. This supports decoding non-string map keys.\n * @param encoded - The msgpack bytes to decode\n * @param options - Options for decoding, including int decoding mode. See {@link IntDecoding} for more information.\n * @returns The decoded Map object\n */\nexport function msgpackRawDecodeAsMap(encoded: ArrayLike<number>, options?: { intDecoding: IntDecoding }) {\n  const decoderOptions: DecoderOptions = {\n    intMode: options?.intDecoding ? intDecodingToIntMode(options?.intDecoding) : IntMode.BIGINT,\n    useMap: true,\n  }\n  return msgpackDecode(encoded, decoderOptions)\n}\n\nfunction msgpackRawDecodeAsMapWithRawStrings(encoded: ArrayLike<number>, options?: { intDecoding: IntDecoding }) {\n  const decoderOptions: DecoderOptions = {\n    intMode: options?.intDecoding ? intDecodingToIntMode(options?.intDecoding) : IntMode.BIGINT,\n    useMap: true,\n    rawBinaryStringKeys: true,\n    rawBinaryStringValues: true,\n    useRawBinaryStringClass: true,\n  }\n  return msgpackDecode(encoded, decoderOptions)\n}\n\nexport type MsgpackEncodingData =\n  | null\n  | undefined\n  | string\n  | number\n  | bigint\n  | boolean\n  | Uint8Array\n  | MsgpackEncodingData[]\n  | Map<string | number | bigint | Uint8Array, MsgpackEncodingData>\n\nexport type JSONEncodingData =\n  | null\n  | undefined\n  | string\n  | number\n  | bigint\n  | boolean\n  | JSONEncodingData[]\n  | { [key: string]: JSONEncodingData }\n\nexport function msgpackEncodingDataToJSONEncodingData(e: MsgpackEncodingData): JSONEncodingData {\n  if (e === null || e === undefined) {\n    return e as JSONEncodingData\n  }\n  if (e instanceof Uint8Array) {\n    return bytesToBase64(e)\n  }\n  if (Array.isArray(e)) {\n    return e.map(msgpackEncodingDataToJSONEncodingData)\n  }\n  if (e instanceof Map) {\n    const obj: { [key: string]: JSONEncodingData } = {}\n    for (const [k, v] of e) {\n      if (typeof k !== 'string') {\n        throw new Error(`JSON map key must be a string: ${k}`)\n      }\n      obj[k] = msgpackEncodingDataToJSONEncodingData(v)\n    }\n    return obj\n  }\n  return e\n}\n\nexport function jsonEncodingDataToMsgpackEncodingData(e: JSONEncodingData): MsgpackEncodingData {\n  if (e === null || e === undefined) {\n    return e as MsgpackEncodingData\n  }\n  if (\n    typeof e === 'string' || // Note, this will not convert base64 to Uint8Array\n    typeof e === 'number' ||\n    typeof e === 'bigint' ||\n    typeof e === 'boolean'\n  ) {\n    return e\n  }\n  if (Array.isArray(e)) {\n    return e.map(jsonEncodingDataToMsgpackEncodingData)\n  }\n  if (typeof e === 'object') {\n    const obj = new Map<string, MsgpackEncodingData>()\n    for (const [key, value] of Object.entries(e)) {\n      obj.set(key, jsonEncodingDataToMsgpackEncodingData(value))\n    }\n    return obj\n  }\n  throw new Error(`Invalid JSON encoding data: ${e}`)\n}\n\nenum MsgpackObjectPathSegmentKind {\n  MAP_VALUE,\n  ARRAY_ELEMENT,\n}\n\ninterface MsgpackObjectPathSegment {\n  kind: MsgpackObjectPathSegmentKind\n  key: string | number | bigint | Uint8Array | RawBinaryString\n}\n\n/**\n * This class is used to index into an encoded msgpack object and extract raw strings.\n */\nexport class MsgpackRawStringProvider {\n  private readonly parent?: MsgpackRawStringProvider\n\n  private readonly baseObjectBytes?: ArrayLike<number>\n\n  private readonly segment?: MsgpackObjectPathSegment\n\n  private resolvedCache: MsgpackEncodingData = null\n  private resolvedCachePresent = false\n\n  public constructor({\n    parent,\n    segment,\n    baseObjectBytes,\n  }:\n    | {\n        parent: MsgpackRawStringProvider\n        segment: MsgpackObjectPathSegment\n        baseObjectBytes?: undefined\n      }\n    | {\n        parent?: undefined\n        segment?: undefined\n        baseObjectBytes: ArrayLike<number>\n      }) {\n    this.parent = parent\n    this.segment = segment\n    this.baseObjectBytes = baseObjectBytes\n  }\n\n  /**\n   * Create a new provider that resolves to the current provider's map value at the given key.\n   */\n  public withMapValue(key: string | number | bigint | Uint8Array | RawBinaryString): MsgpackRawStringProvider {\n    return new MsgpackRawStringProvider({\n      parent: this,\n      segment: {\n        kind: MsgpackObjectPathSegmentKind.MAP_VALUE,\n        key,\n      },\n    })\n  }\n\n  /**\n   * Create a new provider that resolves to the current provider's array element at the given index.\n   */\n  public withArrayElement(index: number): MsgpackRawStringProvider {\n    return new MsgpackRawStringProvider({\n      parent: this,\n      segment: {\n        kind: MsgpackObjectPathSegmentKind.ARRAY_ELEMENT,\n        key: index,\n      },\n    })\n  }\n\n  /**\n   * Get the raw string at the current location. If the current location is not a raw string, an error is thrown.\n   */\n  public getRawStringAtCurrentLocation(): Uint8Array {\n    const resolved = this.resolve()\n    if (resolved instanceof RawBinaryString) {\n      // Decoded rawBinaryValue will always be a Uint8Array\n      return resolved.rawBinaryValue as Uint8Array\n    }\n    throw new Error(`Invalid type. Expected RawBinaryString, got ${resolved} (${typeof resolved})`)\n  }\n\n  /**\n   * Get the raw string map keys and values at the current location. If the current location is not a map, an error is thrown.\n   */\n  public getRawStringKeysAndValuesAtCurrentLocation(): Map<Uint8Array, MsgpackEncodingData> {\n    const resolved = this.resolve()\n    if (!(resolved instanceof Map)) {\n      throw new Error(`Invalid type. Expected Map, got ${resolved} (${typeof resolved})`)\n    }\n    const keysAndValues = new Map<Uint8Array, MsgpackEncodingData>()\n    for (const [key, value] of resolved) {\n      if (key instanceof RawBinaryString) {\n        // Decoded rawBinaryValue will always be a Uint8Array\n        keysAndValues.set(key.rawBinaryValue as Uint8Array, value)\n      } else {\n        throw new Error(`Invalid type for map key. Expected RawBinaryString, got ${key} (${typeof key})`)\n      }\n    }\n    return keysAndValues\n  }\n\n  /**\n   * Resolve the provider by extracting the value it indicates from the base msgpack object.\n   */\n  private resolve(): MsgpackEncodingData {\n    if (this.resolvedCachePresent) {\n      return this.resolvedCache\n    }\n    let parentResolved: MsgpackEncodingData\n    if (this.parent) {\n      parentResolved = this.parent.resolve()\n    } else {\n      // Need to parse baseObjectBytes\n      parentResolved = msgpackRawDecodeAsMapWithRawStrings(this.baseObjectBytes!) as MsgpackEncodingData\n    }\n    if (!this.segment) {\n      this.resolvedCache = parentResolved\n      this.resolvedCachePresent = true\n      return parentResolved\n    }\n    if (this.segment.kind === MsgpackObjectPathSegmentKind.MAP_VALUE) {\n      if (!(parentResolved instanceof Map)) {\n        throw new Error(`Invalid type. Expected Map, got ${parentResolved} (${typeof parentResolved})`)\n      }\n      // All decoded map keys will be raw strings, and Map objects compare complex values by reference,\n      // so we must check all the values for value-equality.\n      if (typeof this.segment.key === 'string' || this.segment.key instanceof Uint8Array || this.segment.key instanceof RawBinaryString) {\n        const targetBytes =\n          this.segment.key instanceof RawBinaryString\n            ? // Decoded rawBinaryValue will always be a Uint8Array\n              (this.segment.key.rawBinaryValue as Uint8Array)\n            : coerceToBytes(this.segment.key)\n        const targetIsRawString = typeof this.segment.key === 'string' || this.segment.key instanceof RawBinaryString\n        for (const [key, value] of parentResolved) {\n          let potentialKeyBytes: Uint8Array | undefined\n          if (targetIsRawString) {\n            if (key instanceof RawBinaryString) {\n              // Decoded rawBinaryValue will always be a Uint8Array\n              potentialKeyBytes = key.rawBinaryValue as Uint8Array\n            }\n          } else if (key instanceof Uint8Array) {\n            potentialKeyBytes = key\n          }\n          if (potentialKeyBytes && arrayEqual(targetBytes, potentialKeyBytes)) {\n            this.resolvedCache = value\n            break\n          }\n        }\n      } else {\n        this.resolvedCache = parentResolved.get(this.segment.key)\n      }\n      this.resolvedCachePresent = true\n      return this.resolvedCache\n    }\n    if (this.segment.kind === MsgpackObjectPathSegmentKind.ARRAY_ELEMENT) {\n      if (!Array.isArray(parentResolved)) {\n        throw new Error(`Invalid type. Expected Array, got ${parentResolved} (${typeof parentResolved})`)\n      }\n      this.resolvedCache = parentResolved[this.segment.key as number]\n      this.resolvedCachePresent = true\n      return this.resolvedCache\n    }\n    throw new Error(`Invalid segment kind: ${this.segment.kind}`)\n  }\n\n  /**\n   * Get the path string of the current location indicated by the provider. Useful for debugging.\n   */\n  public getPathString(): string {\n    const parentPathString = this.parent ? this.parent.getPathString() : 'root'\n    if (!this.segment) {\n      return parentPathString\n    }\n    if (this.segment.kind === MsgpackObjectPathSegmentKind.MAP_VALUE) {\n      return `${parentPathString} -> map key \"${this.segment.key}\" (${typeof this.segment.key})`\n    }\n    if (this.segment.kind === MsgpackObjectPathSegmentKind.ARRAY_ELEMENT) {\n      return `${parentPathString} -> array index ${this.segment.key} (${typeof this.segment.key})`\n    }\n    return `${parentPathString} -> unknown segment kind ${this.segment.kind}`\n  }\n}\n\n/**\n * Options for {@link Schema.prepareJSON}\n */\nexport interface PrepareJSONOptions {\n  /**\n   * If true, allows invalid UTF-8 binary strings to be converted to JSON strings.\n   *\n   * Otherwise, an error will be thrown if encoding a binary string to a JSON cannot be done losslessly.\n   */\n  lossyBinaryStringConversion?: boolean\n}\n\n/**\n * A Schema is used to prepare objects for encoding and decoding from msgpack and JSON.\n *\n * Schemas represent a specific type.\n */\nexport abstract class Schema {\n  /**\n   * Get the default value for this type.\n   */\n  public abstract defaultValue(): unknown\n\n  /**\n   * Checks if the value is the default value for this type.\n   * @param data - The value to check\n   * @returns True if the value is the default value, false otherwise\n   */\n  public abstract isDefaultValue(data: unknown): boolean\n\n  /**\n   * Prepares the encoding data for encoding to msgpack.\n   * @param data - Encoding data to be prepared.\n   * @returns A value ready to be msgpack encoded.\n   */\n  public abstract prepareMsgpack(data: unknown): MsgpackEncodingData\n\n  /**\n   * Restores the encoding data from a msgpack encoding object.\n   * @param encoded - The msgpack encoding object to restore.\n   * @param rawStringProvider - A provider for raw strings.\n   * @returns The original encoding data.\n   */\n  public abstract fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): unknown\n\n  /**\n   * Prepares the encoding data for encoding to JSON.\n   * @param data - The JSON encoding data to be prepared.\n   * @returns A value ready to be JSON encoded.\n   */\n  public abstract prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData\n\n  /**\n   * Restores the encoding data from a JSON encoding object.\n   * @param encoded - The JSON encoding object to restore.\n   * @returns The original encoding data.\n   */\n  public abstract fromPreparedJSON(encoded: JSONEncodingData): unknown\n}\n\n/**\n * An interface for objects that can be encoded and decoded to/from msgpack and JSON.\n */\nexport interface Encodable {\n  /**\n   * Extract the encoding data for this object. This data, after being prepared by the encoding\n   * Schema, can be encoded to msgpack or JSON.\n   */\n  toEncodingData(): unknown\n  /**\n   * Get the encoding Schema for this object, used to prepare the encoding data for msgpack and JSON.\n   */\n  getEncodingSchema(): Schema\n}\n\n/**\n * A type that represents the class of an Encodable object.\n */\nexport interface EncodableClass<T extends Encodable> {\n  /**\n   * Create a new instance of this class from the given encoding data.\n   * @param data - The encoding data to create the object from\n   */\n  fromEncodingData(data: unknown): T\n  /**\n   * The encoding Schema for this class, used to prepare encoding data from msgpack and JSON.\n   */\n  readonly encodingSchema: Schema\n}\n\n/**\n * Decode a msgpack byte array to an Encodable object.\n * @param encoded - The msgpack bytes to decode\n * @param c - The class of the object to decode. This class must match the object that was encoded.\n * @returns An instance of the class with the decoded data\n */\nexport function decodeMsgpack<T extends Encodable>(encoded: ArrayLike<number>, c: EncodableClass<T>): T {\n  const decoded = msgpackRawDecodeAsMap(encoded) as MsgpackEncodingData\n  const rawStringProvider = new MsgpackRawStringProvider({\n    baseObjectBytes: encoded,\n  })\n  return c.fromEncodingData(c.encodingSchema.fromPreparedMsgpack(decoded, rawStringProvider))\n}\n\n/**\n * Encode an Encodable object to a msgpack byte array.\n * @param e - The object to encode\n * @returns A msgpack byte array encoding of the object\n */\nexport function encodeMsgpack(e: Encodable): Uint8Array {\n  return msgpackRawEncode(e.getEncodingSchema().prepareMsgpack(e.toEncodingData()))\n}\n\n/**\n * Decode a JSON string to an Encodable object.\n * @param encoded - The JSON string to decode\n * @param c - The class of the object to decode. This class must match the object that was encoded.\n * @returns An instance of the class with the decoded data\n */\nexport function decodeJSON<T extends Encodable>(encoded: string, c: EncodableClass<T>): T {\n  const decoded: JSONEncodingData = parseJSON(encoded, {\n    intDecoding: IntDecoding.BIGINT,\n  })\n  return c.fromEncodingData(c.encodingSchema.fromPreparedJSON(decoded) as JSONEncodingData)\n}\n\nexport interface EncodeJSONOptions {\n  /**\n   * Adds indentation, white space, and line break characters to the return-value JSON text to make\n   * it easier to read.\n   */\n  space?: string | number\n\n  /**\n   * If true, allows invalid UTF-8 binary strings to be converted to JSON strings.\n   *\n   * Otherwise, an error will be thrown if encoding a binary string to a JSON cannot be done losslessly.\n   */\n  lossyBinaryStringConversion?: boolean\n}\n\n/**\n * Encode an Encodable object to a JSON string.\n * @param e - The object to encode\n * @param options - Optional encoding options. See {@link EncodeJSONOptions} for more information.\n * @returns A JSON string encoding of the object\n */\nexport function encodeJSON(e: Encodable, options?: EncodeJSONOptions): string {\n  const { space, ...prepareJSONOptions } = options ?? {}\n  const prepared = e.getEncodingSchema().prepareJSON(e.toEncodingData(), prepareJSONOptions)\n  return stringifyJSON(prepared, undefined, space)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA0BA,MAAa,8BAA8B;;;;;;;AAQ3C,SAAS,cAAc,KAA4C;AACjE,MAAK,MAAM,OAAO,IAChB,KAAI,OAAO,UAAU,eAAe,KAAK,KAAK,IAAI,EAChD;MAAI,CAAC,IAAI,QAAQ,IAAI,KAAK,WAAW,EACnC,QAAO;GAAE,eAAe;GAAM,eAAe;GAAK;;AAIxD,QAAO;EAAE,eAAe;EAAO,eAAe;EAAW;;;;;;;;AAS3D,SAAgB,iBAAiB,KAAc;AAG7C,QAAOA,OAAc,KADW,EAAE,UAAU,MAAM,CAChB;;;;;;;;;;;;AAapC,SAAgB,UAAU,KAA4C;CAEpE,MAAM,aAAa,cAAc,IAAI;AACrC,KAAI,WAAW,cACb,OAAM,IAAI,MAAM,8BAA8B,WAAW,cAAc;AAEzE,QAAO,iBAAiB,IAAI;;AAG9B,SAAS,qBAAqB,aAAmC;AAC/D,SAAQ,aAAR;EACE,KAAKC,oBAAY,OACf,QAAO,QAAQ;EACjB,KAAKA,oBAAY,KACf,QAAO,QAAQ;EACjB,KAAKA,oBAAY,MACf,QAAO,QAAQ;EACjB,KAAKA,oBAAY,OACf,QAAO,QAAQ;EACjB,QACE,OAAM,IAAI,MAAM,wBAAwB,cAAc;;;;;;;;;AAU5D,SAAgB,iBAAiB,QAA2B,SAAwC;AAIlG,QAAOC,OAAc,QAHkB,EACrC,SAAS,SAAS,cAAc,qBAAqB,SAAS,YAAY,GAAG,QAAQ,QACtF,CAC2C;;;;;;;;;;;AAY9C,SAAgB,UAAU,GAAsB;AAC9C,QAAO,iBAAiB,GAAG,EAAE,aAAaD,oBAAY,OAAO,CAAC;;;;;;;;AAShE,SAAgB,sBAAsB,SAA4B,SAAwC;AAKxG,QAAOC,OAAc,SAJkB;EACrC,SAAS,SAAS,cAAc,qBAAqB,SAAS,YAAY,GAAG,QAAQ;EACrF,QAAQ;EACT,CAC4C;;AAG/C,SAAS,oCAAoC,SAA4B,SAAwC;AAQ/G,QAAOA,OAAc,SAPkB;EACrC,SAAS,SAAS,cAAc,qBAAqB,SAAS,YAAY,GAAG,QAAQ;EACrF,QAAQ;EACR,qBAAqB;EACrB,uBAAuB;EACvB,yBAAyB;EAC1B,CAC4C;;AAwB/C,SAAgB,sCAAsC,GAA0C;AAC9F,KAAI,MAAM,QAAQ,MAAM,OACtB,QAAO;AAET,KAAI,aAAa,WACf,QAAO,cAAc,EAAE;AAEzB,KAAI,MAAM,QAAQ,EAAE,CAClB,QAAO,EAAE,IAAI,sCAAsC;AAErD,KAAI,aAAa,KAAK;EACpB,MAAMC,MAA2C,EAAE;AACnD,OAAK,MAAM,CAAC,GAAG,MAAM,GAAG;AACtB,OAAI,OAAO,MAAM,SACf,OAAM,IAAI,MAAM,kCAAkC,IAAI;AAExD,OAAI,KAAK,sCAAsC,EAAE;;AAEnD,SAAO;;AAET,QAAO;;AAGT,SAAgB,sCAAsC,GAA0C;AAC9F,KAAI,MAAM,QAAQ,MAAM,OACtB,QAAO;AAET,KACE,OAAO,MAAM,YACb,OAAO,MAAM,YACb,OAAO,MAAM,YACb,OAAO,MAAM,UAEb,QAAO;AAET,KAAI,MAAM,QAAQ,EAAE,CAClB,QAAO,EAAE,IAAI,sCAAsC;AAErD,KAAI,OAAO,MAAM,UAAU;EACzB,MAAM,sBAAM,IAAI,KAAkC;AAClD,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,EAAE,CAC1C,KAAI,IAAI,KAAK,sCAAsC,MAAM,CAAC;AAE5D,SAAO;;AAET,OAAM,IAAI,MAAM,+BAA+B,IAAI;;AAGrD,IAAK,wFAAL;AACE;AACA;;EAFG;;;;AAaL,IAAa,2BAAb,MAAa,yBAAyB;CACpC,AAAiB;CAEjB,AAAiB;CAEjB,AAAiB;CAEjB,AAAQ,gBAAqC;CAC7C,AAAQ,uBAAuB;CAE/B,AAAO,YAAY,EACjB,QACA,SACA,mBAWK;AACL,OAAK,SAAS;AACd,OAAK,UAAU;AACf,OAAK,kBAAkB;;;;;CAMzB,AAAO,aAAa,KAAwF;AAC1G,SAAO,IAAI,yBAAyB;GAClC,QAAQ;GACR,SAAS;IACP,MAAM,6BAA6B;IACnC;IACD;GACF,CAAC;;;;;CAMJ,AAAO,iBAAiB,OAAyC;AAC/D,SAAO,IAAI,yBAAyB;GAClC,QAAQ;GACR,SAAS;IACP,MAAM,6BAA6B;IACnC,KAAK;IACN;GACF,CAAC;;;;;CAMJ,AAAO,gCAA4C;EACjD,MAAM,WAAW,KAAK,SAAS;AAC/B,MAAI,oBAAoB,gBAEtB,QAAO,SAAS;AAElB,QAAM,IAAI,MAAM,+CAA+C,SAAS,IAAI,OAAO,SAAS,GAAG;;;;;CAMjG,AAAO,6CAAmF;EACxF,MAAM,WAAW,KAAK,SAAS;AAC/B,MAAI,EAAE,oBAAoB,KACxB,OAAM,IAAI,MAAM,mCAAmC,SAAS,IAAI,OAAO,SAAS,GAAG;EAErF,MAAM,gCAAgB,IAAI,KAAsC;AAChE,OAAK,MAAM,CAAC,KAAK,UAAU,SACzB,KAAI,eAAe,gBAEjB,eAAc,IAAI,IAAI,gBAA8B,MAAM;MAE1D,OAAM,IAAI,MAAM,2DAA2D,IAAI,IAAI,OAAO,IAAI,GAAG;AAGrG,SAAO;;;;;CAMT,AAAQ,UAA+B;AACrC,MAAI,KAAK,qBACP,QAAO,KAAK;EAEd,IAAIC;AACJ,MAAI,KAAK,OACP,kBAAiB,KAAK,OAAO,SAAS;MAGtC,kBAAiB,oCAAoC,KAAK,gBAAiB;AAE7E,MAAI,CAAC,KAAK,SAAS;AACjB,QAAK,gBAAgB;AACrB,QAAK,uBAAuB;AAC5B,UAAO;;AAET,MAAI,KAAK,QAAQ,SAAS,6BAA6B,WAAW;AAChE,OAAI,EAAE,0BAA0B,KAC9B,OAAM,IAAI,MAAM,mCAAmC,eAAe,IAAI,OAAO,eAAe,GAAG;AAIjG,OAAI,OAAO,KAAK,QAAQ,QAAQ,YAAY,KAAK,QAAQ,eAAe,cAAc,KAAK,QAAQ,eAAe,iBAAiB;IACjI,MAAM,cACJ,KAAK,QAAQ,eAAe,kBAEvB,KAAK,QAAQ,IAAI,iBAClB,cAAc,KAAK,QAAQ,IAAI;IACrC,MAAM,oBAAoB,OAAO,KAAK,QAAQ,QAAQ,YAAY,KAAK,QAAQ,eAAe;AAC9F,SAAK,MAAM,CAAC,KAAK,UAAU,gBAAgB;KACzC,IAAIC;AACJ,SAAI,mBACF;UAAI,eAAe,gBAEjB,qBAAoB,IAAI;gBAEjB,eAAe,WACxB,qBAAoB;AAEtB,SAAI,qBAAqB,WAAW,aAAa,kBAAkB,EAAE;AACnE,WAAK,gBAAgB;AACrB;;;SAIJ,MAAK,gBAAgB,eAAe,IAAI,KAAK,QAAQ,IAAI;AAE3D,QAAK,uBAAuB;AAC5B,UAAO,KAAK;;AAEd,MAAI,KAAK,QAAQ,SAAS,6BAA6B,eAAe;AACpE,OAAI,CAAC,MAAM,QAAQ,eAAe,CAChC,OAAM,IAAI,MAAM,qCAAqC,eAAe,IAAI,OAAO,eAAe,GAAG;AAEnG,QAAK,gBAAgB,eAAe,KAAK,QAAQ;AACjD,QAAK,uBAAuB;AAC5B,UAAO,KAAK;;AAEd,QAAM,IAAI,MAAM,yBAAyB,KAAK,QAAQ,OAAO;;;;;CAM/D,AAAO,gBAAwB;EAC7B,MAAM,mBAAmB,KAAK,SAAS,KAAK,OAAO,eAAe,GAAG;AACrE,MAAI,CAAC,KAAK,QACR,QAAO;AAET,MAAI,KAAK,QAAQ,SAAS,6BAA6B,UACrD,QAAO,GAAG,iBAAiB,eAAe,KAAK,QAAQ,IAAI,KAAK,OAAO,KAAK,QAAQ,IAAI;AAE1F,MAAI,KAAK,QAAQ,SAAS,6BAA6B,cACrD,QAAO,GAAG,iBAAiB,kBAAkB,KAAK,QAAQ,IAAI,IAAI,OAAO,KAAK,QAAQ,IAAI;AAE5F,SAAO,GAAG,iBAAiB,2BAA2B,KAAK,QAAQ;;;;;;;;AAqBvE,IAAsB,SAAtB,MAA6B;;;;;;;AA+E7B,SAAgB,cAAmC,SAA4B,GAAyB;CACtG,MAAM,UAAU,sBAAsB,QAAQ;CAC9C,MAAM,oBAAoB,IAAI,yBAAyB,EACrD,iBAAiB,SAClB,CAAC;AACF,QAAO,EAAE,iBAAiB,EAAE,eAAe,oBAAoB,SAAS,kBAAkB,CAAC;;;;;;;AAQ7F,SAAgB,cAAc,GAA0B;AACtD,QAAO,iBAAiB,EAAE,mBAAmB,CAAC,eAAe,EAAE,gBAAgB,CAAC,CAAC;;;;;;;;AASnF,SAAgB,WAAgC,SAAiB,GAAyB;CACxF,MAAMC,UAA4B,UAAU,SAAS,EACnD,aAAaL,oBAAY,QAC1B,CAAC;AACF,QAAO,EAAE,iBAAiB,EAAE,eAAe,iBAAiB,QAAQ,CAAqB;;;;;;;;AAwB3F,SAAgB,WAAW,GAAc,SAAqC;CAC5E,MAAM,EAAE,OAAO,GAAG,uBAAuB,WAAW,EAAE;AAEtD,QAAO,cADU,EAAE,mBAAmB,CAAC,YAAY,EAAE,gBAAgB,EAAE,mBAAmB,EAC3D,QAAW,MAAM"}

package/packages/sdk/src/encoding/schema/array.js

@@ -0,0 +1,35 @@
+const require_encoding = require('../encoding.js');
+
+//#region packages/sdk/src/encoding/schema/array.ts
+var ArraySchema = class extends require_encoding.Schema {
+	constructor(itemSchema) {
+		super();
+		this.itemSchema = itemSchema;
+	}
+	defaultValue() {
+		return [];
+	}
+	isDefaultValue(data) {
+		return Array.isArray(data) && data.length === 0;
+	}
+	prepareMsgpack(data) {
+		if (Array.isArray(data)) return data.map((item) => this.itemSchema.prepareMsgpack(item));
+		throw new Error("ArraySchema data must be an array");
+	}
+	fromPreparedMsgpack(encoded, rawStringProvider) {
+		if (Array.isArray(encoded)) return encoded.map((item, index) => this.itemSchema.fromPreparedMsgpack(item, rawStringProvider.withArrayElement(index)));
+		throw new Error(`ArraySchema encoded data must be an array: ${encoded} (${typeof encoded})`);
+	}
+	prepareJSON(data, options) {
+		if (Array.isArray(data)) return data.map((item) => this.itemSchema.prepareJSON(item, options));
+		throw new Error("ArraySchema data must be an array");
+	}
+	fromPreparedJSON(encoded) {
+		if (Array.isArray(encoded)) return encoded.map((item) => this.itemSchema.fromPreparedJSON(item));
+		throw new Error(`ArraySchema encoded data must be an array: ${encoded} (${typeof encoded})`);
+	}
+};
+
+//#endregion
+exports.ArraySchema = ArraySchema;
+//# sourceMappingURL=array.js.map

package/packages/sdk/src/encoding/schema/array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","names":["Schema","itemSchema: Schema"],"sources":["../../../../../../packages/sdk/src/encoding/schema/array.ts"],"sourcesContent":["import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js'\n\n/* eslint-disable class-methods-use-this */\n\nexport class ArraySchema extends Schema {\n  constructor(public readonly itemSchema: Schema) {\n    super()\n  }\n\n  public defaultValue(): unknown[] {\n    return []\n  }\n\n  public isDefaultValue(data: unknown): boolean {\n    return Array.isArray(data) && data.length === 0\n  }\n\n  public prepareMsgpack(data: unknown): MsgpackEncodingData {\n    if (Array.isArray(data)) {\n      return data.map((item) => this.itemSchema.prepareMsgpack(item))\n    }\n    throw new Error('ArraySchema data must be an array')\n  }\n\n  public fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): unknown[] {\n    if (Array.isArray(encoded)) {\n      return encoded.map((item, index) => this.itemSchema.fromPreparedMsgpack(item, rawStringProvider.withArrayElement(index)))\n    }\n    throw new Error(`ArraySchema encoded data must be an array: ${encoded} (${typeof encoded})`)\n  }\n\n  public prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData {\n    if (Array.isArray(data)) {\n      return data.map((item) => this.itemSchema.prepareJSON(item, options))\n    }\n    throw new Error('ArraySchema data must be an array')\n  }\n\n  public fromPreparedJSON(encoded: JSONEncodingData): unknown[] {\n    if (Array.isArray(encoded)) {\n      return encoded.map((item) => this.itemSchema.fromPreparedJSON(item))\n    }\n    throw new Error(`ArraySchema encoded data must be an array: ${encoded} (${typeof encoded})`)\n  }\n}\n"],"mappings":";;;AAIA,IAAa,cAAb,cAAiCA,wBAAO;CACtC,YAAY,AAAgBC,YAAoB;AAC9C,SAAO;EADmB;;CAI5B,AAAO,eAA0B;AAC/B,SAAO,EAAE;;CAGX,AAAO,eAAe,MAAwB;AAC5C,SAAO,MAAM,QAAQ,KAAK,IAAI,KAAK,WAAW;;CAGhD,AAAO,eAAe,MAAoC;AACxD,MAAI,MAAM,QAAQ,KAAK,CACrB,QAAO,KAAK,KAAK,SAAS,KAAK,WAAW,eAAe,KAAK,CAAC;AAEjE,QAAM,IAAI,MAAM,oCAAoC;;CAGtD,AAAO,oBAAoB,SAA8B,mBAAwD;AAC/G,MAAI,MAAM,QAAQ,QAAQ,CACxB,QAAO,QAAQ,KAAK,MAAM,UAAU,KAAK,WAAW,oBAAoB,MAAM,kBAAkB,iBAAiB,MAAM,CAAC,CAAC;AAE3H,QAAM,IAAI,MAAM,8CAA8C,QAAQ,IAAI,OAAO,QAAQ,GAAG;;CAG9F,AAAO,YAAY,MAAe,SAA+C;AAC/E,MAAI,MAAM,QAAQ,KAAK,CACrB,QAAO,KAAK,KAAK,SAAS,KAAK,WAAW,YAAY,MAAM,QAAQ,CAAC;AAEvE,QAAM,IAAI,MAAM,oCAAoC;;CAGtD,AAAO,iBAAiB,SAAsC;AAC5D,MAAI,MAAM,QAAQ,QAAQ,CACxB,QAAO,QAAQ,KAAK,SAAS,KAAK,WAAW,iBAAiB,KAAK,CAAC;AAEtE,QAAM,IAAI,MAAM,8CAA8C,QAAQ,IAAI,OAAO,QAAQ,GAAG"}

package/packages/sdk/src/encoding/schema/array.mjs

@@ -0,0 +1,35 @@
+import { Schema } from "../encoding.mjs";
+
+//#region packages/sdk/src/encoding/schema/array.ts
+var ArraySchema = class extends Schema {
+	constructor(itemSchema) {
+		super();
+		this.itemSchema = itemSchema;
+	}
+	defaultValue() {
+		return [];
+	}
+	isDefaultValue(data) {
+		return Array.isArray(data) && data.length === 0;
+	}
+	prepareMsgpack(data) {
+		if (Array.isArray(data)) return data.map((item) => this.itemSchema.prepareMsgpack(item));
+		throw new Error("ArraySchema data must be an array");
+	}
+	fromPreparedMsgpack(encoded, rawStringProvider) {
+		if (Array.isArray(encoded)) return encoded.map((item, index) => this.itemSchema.fromPreparedMsgpack(item, rawStringProvider.withArrayElement(index)));
+		throw new Error(`ArraySchema encoded data must be an array: ${encoded} (${typeof encoded})`);
+	}
+	prepareJSON(data, options) {
+		if (Array.isArray(data)) return data.map((item) => this.itemSchema.prepareJSON(item, options));
+		throw new Error("ArraySchema data must be an array");
+	}
+	fromPreparedJSON(encoded) {
+		if (Array.isArray(encoded)) return encoded.map((item) => this.itemSchema.fromPreparedJSON(item));
+		throw new Error(`ArraySchema encoded data must be an array: ${encoded} (${typeof encoded})`);
+	}
+};
+
+//#endregion
+export { ArraySchema };
+//# sourceMappingURL=array.mjs.map

package/packages/sdk/src/encoding/schema/array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.mjs","names":["itemSchema: Schema"],"sources":["../../../../../../packages/sdk/src/encoding/schema/array.ts"],"sourcesContent":["import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js'\n\n/* eslint-disable class-methods-use-this */\n\nexport class ArraySchema extends Schema {\n  constructor(public readonly itemSchema: Schema) {\n    super()\n  }\n\n  public defaultValue(): unknown[] {\n    return []\n  }\n\n  public isDefaultValue(data: unknown): boolean {\n    return Array.isArray(data) && data.length === 0\n  }\n\n  public prepareMsgpack(data: unknown): MsgpackEncodingData {\n    if (Array.isArray(data)) {\n      return data.map((item) => this.itemSchema.prepareMsgpack(item))\n    }\n    throw new Error('ArraySchema data must be an array')\n  }\n\n  public fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): unknown[] {\n    if (Array.isArray(encoded)) {\n      return encoded.map((item, index) => this.itemSchema.fromPreparedMsgpack(item, rawStringProvider.withArrayElement(index)))\n    }\n    throw new Error(`ArraySchema encoded data must be an array: ${encoded} (${typeof encoded})`)\n  }\n\n  public prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData {\n    if (Array.isArray(data)) {\n      return data.map((item) => this.itemSchema.prepareJSON(item, options))\n    }\n    throw new Error('ArraySchema data must be an array')\n  }\n\n  public fromPreparedJSON(encoded: JSONEncodingData): unknown[] {\n    if (Array.isArray(encoded)) {\n      return encoded.map((item) => this.itemSchema.fromPreparedJSON(item))\n    }\n    throw new Error(`ArraySchema encoded data must be an array: ${encoded} (${typeof encoded})`)\n  }\n}\n"],"mappings":";;;AAIA,IAAa,cAAb,cAAiC,OAAO;CACtC,YAAY,AAAgBA,YAAoB;AAC9C,SAAO;EADmB;;CAI5B,AAAO,eAA0B;AAC/B,SAAO,EAAE;;CAGX,AAAO,eAAe,MAAwB;AAC5C,SAAO,MAAM,QAAQ,KAAK,IAAI,KAAK,WAAW;;CAGhD,AAAO,eAAe,MAAoC;AACxD,MAAI,MAAM,QAAQ,KAAK,CACrB,QAAO,KAAK,KAAK,SAAS,KAAK,WAAW,eAAe,KAAK,CAAC;AAEjE,QAAM,IAAI,MAAM,oCAAoC;;CAGtD,AAAO,oBAAoB,SAA8B,mBAAwD;AAC/G,MAAI,MAAM,QAAQ,QAAQ,CACxB,QAAO,QAAQ,KAAK,MAAM,UAAU,KAAK,WAAW,oBAAoB,MAAM,kBAAkB,iBAAiB,MAAM,CAAC,CAAC;AAE3H,QAAM,IAAI,MAAM,8CAA8C,QAAQ,IAAI,OAAO,QAAQ,GAAG;;CAG9F,AAAO,YAAY,MAAe,SAA+C;AAC/E,MAAI,MAAM,QAAQ,KAAK,CACrB,QAAO,KAAK,KAAK,SAAS,KAAK,WAAW,YAAY,MAAM,QAAQ,CAAC;AAEvE,QAAM,IAAI,MAAM,oCAAoC;;CAGtD,AAAO,iBAAiB,SAAsC;AAC5D,MAAI,MAAM,QAAQ,QAAQ,CACxB,QAAO,QAAQ,KAAK,SAAS,KAAK,WAAW,iBAAiB,KAAK,CAAC;AAEtE,QAAM,IAAI,MAAM,8CAA8C,QAAQ,IAAI,OAAO,QAAQ,GAAG"}

package/packages/sdk/src/encoding/schema/bytearray.js

@@ -0,0 +1,49 @@
+const require_binarydata = require('../binarydata.js');
+const require_encoding = require('../encoding.js');
+
+//#region packages/sdk/src/encoding/schema/bytearray.ts
+var FixedLengthByteArraySchema = class extends require_encoding.Schema {
+	constructor(length) {
+		super();
+		this.length = length;
+	}
+	defaultValue() {
+		return new Uint8Array(this.length);
+	}
+	isDefaultValue(data) {
+		return data instanceof Uint8Array && data.byteLength === this.length && data.every((byte) => byte === 0);
+	}
+	prepareMsgpack(data) {
+		if (data instanceof Uint8Array) {
+			if (data.byteLength === this.length) return data;
+			throw new Error(`Invalid byte array length: wanted ${this.length}, got ${data.byteLength}`);
+		}
+		throw new Error("Invalid byte array");
+	}
+	fromPreparedMsgpack(encoded, _rawStringProvider) {
+		if (encoded instanceof Uint8Array) {
+			if (encoded.byteLength === this.length) return encoded;
+			throw new Error(`Invalid byte array length: wanted ${this.length}, got ${encoded.byteLength}`);
+		}
+		throw new Error("Invalid byte array");
+	}
+	prepareJSON(data) {
+		if (data instanceof Uint8Array) {
+			if (data.byteLength === this.length) return require_binarydata.bytesToBase64(data);
+			throw new Error(`Invalid byte array length: wanted ${this.length}, got ${data.byteLength}`);
+		}
+		throw new Error("Invalid byte array");
+	}
+	fromPreparedJSON(encoded) {
+		if (typeof encoded === "string") {
+			const bytes = require_binarydata.base64ToBytes(encoded);
+			if (bytes.byteLength === this.length) return bytes;
+			throw new Error(`Invalid byte array length: wanted ${this.length}, got ${bytes.byteLength}`);
+		}
+		throw new Error("Invalid base64 byte array");
+	}
+};
+
+//#endregion
+exports.FixedLengthByteArraySchema = FixedLengthByteArraySchema;
+//# sourceMappingURL=bytearray.js.map

package/packages/sdk/src/encoding/schema/bytearray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytearray.js","names":["Schema","length: number","bytesToBase64","base64ToBytes"],"sources":["../../../../../../packages/sdk/src/encoding/schema/bytearray.ts"],"sourcesContent":["import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js'\nimport { base64ToBytes, bytesToBase64 } from '../binarydata.js'\n\n/* eslint-disable class-methods-use-this */\n\nexport class ByteArraySchema extends Schema {\n  public defaultValue(): Uint8Array {\n    return new Uint8Array()\n  }\n\n  public isDefaultValue(data: unknown): boolean {\n    return data instanceof Uint8Array && data.byteLength === 0\n  }\n\n  public prepareMsgpack(data: unknown): MsgpackEncodingData {\n    if (data instanceof Uint8Array) {\n      return data\n    }\n    throw new Error(`Invalid byte array: (${typeof data}) ${data}`)\n  }\n\n  public fromPreparedMsgpack(\n    encoded: MsgpackEncodingData,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _rawStringProvider: MsgpackRawStringProvider,\n  ): Uint8Array {\n    if (encoded instanceof Uint8Array) {\n      return encoded\n    }\n    throw new Error(`Invalid byte array: (${typeof encoded}) ${encoded}`)\n  }\n\n  public prepareJSON(\n    data: unknown,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _options: PrepareJSONOptions,\n  ): JSONEncodingData {\n    if (data instanceof Uint8Array) {\n      return bytesToBase64(data)\n    }\n    throw new Error(`Invalid byte array: (${typeof data}) ${data}`)\n  }\n\n  public fromPreparedJSON(encoded: JSONEncodingData): Uint8Array {\n    if (encoded === null || encoded === undefined) {\n      return this.defaultValue()\n    }\n    if (typeof encoded === 'string') {\n      return base64ToBytes(encoded)\n    }\n    throw new Error(`Invalid byte array: (${typeof encoded}) ${encoded}`)\n  }\n}\n\nexport class FixedLengthByteArraySchema extends Schema {\n  constructor(public readonly length: number) {\n    super()\n  }\n\n  public defaultValue(): Uint8Array {\n    return new Uint8Array(this.length)\n  }\n\n  public isDefaultValue(data: unknown): boolean {\n    return data instanceof Uint8Array && data.byteLength === this.length && data.every((byte) => byte === 0)\n  }\n\n  public prepareMsgpack(data: unknown): MsgpackEncodingData {\n    if (data instanceof Uint8Array) {\n      if (data.byteLength === this.length) {\n        return data\n      }\n      throw new Error(`Invalid byte array length: wanted ${this.length}, got ${data.byteLength}`)\n    }\n    throw new Error('Invalid byte array')\n  }\n\n  public fromPreparedMsgpack(\n    encoded: MsgpackEncodingData,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _rawStringProvider: MsgpackRawStringProvider,\n  ): Uint8Array {\n    if (encoded instanceof Uint8Array) {\n      if (encoded.byteLength === this.length) {\n        return encoded\n      }\n      throw new Error(`Invalid byte array length: wanted ${this.length}, got ${encoded.byteLength}`)\n    }\n    throw new Error('Invalid byte array')\n  }\n\n  public prepareJSON(data: unknown): JSONEncodingData {\n    if (data instanceof Uint8Array) {\n      if (data.byteLength === this.length) {\n        return bytesToBase64(data)\n      }\n      throw new Error(`Invalid byte array length: wanted ${this.length}, got ${data.byteLength}`)\n    }\n    throw new Error('Invalid byte array')\n  }\n\n  public fromPreparedJSON(encoded: JSONEncodingData): Uint8Array {\n    if (typeof encoded === 'string') {\n      const bytes = base64ToBytes(encoded)\n      if (bytes.byteLength === this.length) {\n        return bytes\n      }\n      throw new Error(`Invalid byte array length: wanted ${this.length}, got ${bytes.byteLength}`)\n    }\n    throw new Error('Invalid base64 byte array')\n  }\n}\n"],"mappings":";;;;AAsDA,IAAa,6BAAb,cAAgDA,wBAAO;CACrD,YAAY,AAAgBC,QAAgB;AAC1C,SAAO;EADmB;;CAI5B,AAAO,eAA2B;AAChC,SAAO,IAAI,WAAW,KAAK,OAAO;;CAGpC,AAAO,eAAe,MAAwB;AAC5C,SAAO,gBAAgB,cAAc,KAAK,eAAe,KAAK,UAAU,KAAK,OAAO,SAAS,SAAS,EAAE;;CAG1G,AAAO,eAAe,MAAoC;AACxD,MAAI,gBAAgB,YAAY;AAC9B,OAAI,KAAK,eAAe,KAAK,OAC3B,QAAO;AAET,SAAM,IAAI,MAAM,qCAAqC,KAAK,OAAO,QAAQ,KAAK,aAAa;;AAE7F,QAAM,IAAI,MAAM,qBAAqB;;CAGvC,AAAO,oBACL,SAEA,oBACY;AACZ,MAAI,mBAAmB,YAAY;AACjC,OAAI,QAAQ,eAAe,KAAK,OAC9B,QAAO;AAET,SAAM,IAAI,MAAM,qCAAqC,KAAK,OAAO,QAAQ,QAAQ,aAAa;;AAEhG,QAAM,IAAI,MAAM,qBAAqB;;CAGvC,AAAO,YAAY,MAAiC;AAClD,MAAI,gBAAgB,YAAY;AAC9B,OAAI,KAAK,eAAe,KAAK,OAC3B,QAAOC,iCAAc,KAAK;AAE5B,SAAM,IAAI,MAAM,qCAAqC,KAAK,OAAO,QAAQ,KAAK,aAAa;;AAE7F,QAAM,IAAI,MAAM,qBAAqB;;CAGvC,AAAO,iBAAiB,SAAuC;AAC7D,MAAI,OAAO,YAAY,UAAU;GAC/B,MAAM,QAAQC,iCAAc,QAAQ;AACpC,OAAI,MAAM,eAAe,KAAK,OAC5B,QAAO;AAET,SAAM,IAAI,MAAM,qCAAqC,KAAK,OAAO,QAAQ,MAAM,aAAa;;AAE9F,QAAM,IAAI,MAAM,4BAA4B"}

package/packages/sdk/src/encoding/schema/bytearray.mjs

@@ -0,0 +1,49 @@
+import { base64ToBytes, bytesToBase64 } from "../binarydata.mjs";
+import { Schema } from "../encoding.mjs";
+
+//#region packages/sdk/src/encoding/schema/bytearray.ts
+var FixedLengthByteArraySchema = class extends Schema {
+	constructor(length) {
+		super();
+		this.length = length;
+	}
+	defaultValue() {
+		return new Uint8Array(this.length);
+	}
+	isDefaultValue(data) {
+		return data instanceof Uint8Array && data.byteLength === this.length && data.every((byte) => byte === 0);
+	}
+	prepareMsgpack(data) {
+		if (data instanceof Uint8Array) {
+			if (data.byteLength === this.length) return data;
+			throw new Error(`Invalid byte array length: wanted ${this.length}, got ${data.byteLength}`);
+		}
+		throw new Error("Invalid byte array");
+	}
+	fromPreparedMsgpack(encoded, _rawStringProvider) {
+		if (encoded instanceof Uint8Array) {
+			if (encoded.byteLength === this.length) return encoded;
+			throw new Error(`Invalid byte array length: wanted ${this.length}, got ${encoded.byteLength}`);
+		}
+		throw new Error("Invalid byte array");
+	}
+	prepareJSON(data) {
+		if (data instanceof Uint8Array) {
+			if (data.byteLength === this.length) return bytesToBase64(data);
+			throw new Error(`Invalid byte array length: wanted ${this.length}, got ${data.byteLength}`);
+		}
+		throw new Error("Invalid byte array");
+	}
+	fromPreparedJSON(encoded) {
+		if (typeof encoded === "string") {
+			const bytes = base64ToBytes(encoded);
+			if (bytes.byteLength === this.length) return bytes;
+			throw new Error(`Invalid byte array length: wanted ${this.length}, got ${bytes.byteLength}`);
+		}
+		throw new Error("Invalid base64 byte array");
+	}
+};
+
+//#endregion
+export { FixedLengthByteArraySchema };
+//# sourceMappingURL=bytearray.mjs.map

package/packages/sdk/src/encoding/schema/bytearray.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytearray.mjs","names":["length: number"],"sources":["../../../../../../packages/sdk/src/encoding/schema/bytearray.ts"],"sourcesContent":["import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js'\nimport { base64ToBytes, bytesToBase64 } from '../binarydata.js'\n\n/* eslint-disable class-methods-use-this */\n\nexport class ByteArraySchema extends Schema {\n  public defaultValue(): Uint8Array {\n    return new Uint8Array()\n  }\n\n  public isDefaultValue(data: unknown): boolean {\n    return data instanceof Uint8Array && data.byteLength === 0\n  }\n\n  public prepareMsgpack(data: unknown): MsgpackEncodingData {\n    if (data instanceof Uint8Array) {\n      return data\n    }\n    throw new Error(`Invalid byte array: (${typeof data}) ${data}`)\n  }\n\n  public fromPreparedMsgpack(\n    encoded: MsgpackEncodingData,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _rawStringProvider: MsgpackRawStringProvider,\n  ): Uint8Array {\n    if (encoded instanceof Uint8Array) {\n      return encoded\n    }\n    throw new Error(`Invalid byte array: (${typeof encoded}) ${encoded}`)\n  }\n\n  public prepareJSON(\n    data: unknown,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _options: PrepareJSONOptions,\n  ): JSONEncodingData {\n    if (data instanceof Uint8Array) {\n      return bytesToBase64(data)\n    }\n    throw new Error(`Invalid byte array: (${typeof data}) ${data}`)\n  }\n\n  public fromPreparedJSON(encoded: JSONEncodingData): Uint8Array {\n    if (encoded === null || encoded === undefined) {\n      return this.defaultValue()\n    }\n    if (typeof encoded === 'string') {\n      return base64ToBytes(encoded)\n    }\n    throw new Error(`Invalid byte array: (${typeof encoded}) ${encoded}`)\n  }\n}\n\nexport class FixedLengthByteArraySchema extends Schema {\n  constructor(public readonly length: number) {\n    super()\n  }\n\n  public defaultValue(): Uint8Array {\n    return new Uint8Array(this.length)\n  }\n\n  public isDefaultValue(data: unknown): boolean {\n    return data instanceof Uint8Array && data.byteLength === this.length && data.every((byte) => byte === 0)\n  }\n\n  public prepareMsgpack(data: unknown): MsgpackEncodingData {\n    if (data instanceof Uint8Array) {\n      if (data.byteLength === this.length) {\n        return data\n      }\n      throw new Error(`Invalid byte array length: wanted ${this.length}, got ${data.byteLength}`)\n    }\n    throw new Error('Invalid byte array')\n  }\n\n  public fromPreparedMsgpack(\n    encoded: MsgpackEncodingData,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _rawStringProvider: MsgpackRawStringProvider,\n  ): Uint8Array {\n    if (encoded instanceof Uint8Array) {\n      if (encoded.byteLength === this.length) {\n        return encoded\n      }\n      throw new Error(`Invalid byte array length: wanted ${this.length}, got ${encoded.byteLength}`)\n    }\n    throw new Error('Invalid byte array')\n  }\n\n  public prepareJSON(data: unknown): JSONEncodingData {\n    if (data instanceof Uint8Array) {\n      if (data.byteLength === this.length) {\n        return bytesToBase64(data)\n      }\n      throw new Error(`Invalid byte array length: wanted ${this.length}, got ${data.byteLength}`)\n    }\n    throw new Error('Invalid byte array')\n  }\n\n  public fromPreparedJSON(encoded: JSONEncodingData): Uint8Array {\n    if (typeof encoded === 'string') {\n      const bytes = base64ToBytes(encoded)\n      if (bytes.byteLength === this.length) {\n        return bytes\n      }\n      throw new Error(`Invalid byte array length: wanted ${this.length}, got ${bytes.byteLength}`)\n    }\n    throw new Error('Invalid base64 byte array')\n  }\n}\n"],"mappings":";;;;AAsDA,IAAa,6BAAb,cAAgD,OAAO;CACrD,YAAY,AAAgBA,QAAgB;AAC1C,SAAO;EADmB;;CAI5B,AAAO,eAA2B;AAChC,SAAO,IAAI,WAAW,KAAK,OAAO;;CAGpC,AAAO,eAAe,MAAwB;AAC5C,SAAO,gBAAgB,cAAc,KAAK,eAAe,KAAK,UAAU,KAAK,OAAO,SAAS,SAAS,EAAE;;CAG1G,AAAO,eAAe,MAAoC;AACxD,MAAI,gBAAgB,YAAY;AAC9B,OAAI,KAAK,eAAe,KAAK,OAC3B,QAAO;AAET,SAAM,IAAI,MAAM,qCAAqC,KAAK,OAAO,QAAQ,KAAK,aAAa;;AAE7F,QAAM,IAAI,MAAM,qBAAqB;;CAGvC,AAAO,oBACL,SAEA,oBACY;AACZ,MAAI,mBAAmB,YAAY;AACjC,OAAI,QAAQ,eAAe,KAAK,OAC9B,QAAO;AAET,SAAM,IAAI,MAAM,qCAAqC,KAAK,OAAO,QAAQ,QAAQ,aAAa;;AAEhG,QAAM,IAAI,MAAM,qBAAqB;;CAGvC,AAAO,YAAY,MAAiC;AAClD,MAAI,gBAAgB,YAAY;AAC9B,OAAI,KAAK,eAAe,KAAK,OAC3B,QAAO,cAAc,KAAK;AAE5B,SAAM,IAAI,MAAM,qCAAqC,KAAK,OAAO,QAAQ,KAAK,aAAa;;AAE7F,QAAM,IAAI,MAAM,qBAAqB;;CAGvC,AAAO,iBAAiB,SAAuC;AAC7D,MAAI,OAAO,YAAY,UAAU;GAC/B,MAAM,QAAQ,cAAc,QAAQ;AACpC,OAAI,MAAM,eAAe,KAAK,OAC5B,QAAO;AAET,SAAM,IAAI,MAAM,qCAAqC,KAAK,OAAO,QAAQ,MAAM,aAAa;;AAE9F,QAAM,IAAI,MAAM,4BAA4B"}

package/packages/sdk/src/encoding/schema/map.d.ts

@@ -0,0 +1,58 @@
+import { JSONEncodingData, MsgpackEncodingData, MsgpackRawStringProvider, PrepareJSONOptions, Schema } from "../encoding.js";
+
+//#region packages/sdk/src/encoding/schema/map.d.ts
+
+/**
+ * Describes a key-value entry in a NamedMapSchema.
+ */
+interface NamedMapEntry {
+  /**
+   * Key of the entry. Must be unique for this map.
+   */
+  key: string;
+  /**
+   * The Schema for the entry's value.
+   */
+  valueSchema: Schema;
+  /**
+   * If true, the entry will be omitted from the encoding if the value is the default value.
+   */
+  omitEmpty: boolean;
+  /**
+   * If true, valueSchema must be a NamedMapSchema and key must be the empty string. The fields of
+   * valueSchema will be embedded directly in the parent map.
+   *
+   * omitEmpty is ignored for embedded entries. Instead, the individual omitEmpty values of the
+   * embedded fields are used.
+   */
+  embedded?: boolean;
+}
+/**
+ * Schema for a map/struct with a fixed set of known string fields.
+ */
+declare class NamedMapSchema extends Schema {
+  private readonly entries;
+  constructor(entries: NamedMapEntry[]);
+  /**
+   * Adds new entries to the map schema. WARNING: this is a mutable operation, and you should be very
+   * careful when using it. Any error that happens here is non-recoverable and will corrupt the
+   * NamedMapSchema object;
+   * @param entries - The entries to add.
+   */
+  pushEntries(...entries: NamedMapEntry[]): void;
+  private checkEntries;
+  /**
+   * Returns all top-level entries, properly accounting for fields from embedded entries.
+   * @returns An array of all top-level entries for this map.
+   */
+  getEntries(): NamedMapEntry[];
+  defaultValue(): Map<string, unknown>;
+  isDefaultValue(data: unknown): boolean;
+  prepareMsgpack(data: unknown): MsgpackEncodingData;
+  fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): Map<string, unknown>;
+  prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+  fromPreparedJSON(encoded: JSONEncodingData): Map<string, unknown>;
+}
+//#endregion
+export { NamedMapSchema };
+//# sourceMappingURL=map.d.ts.map