algosdk 2.9.0 → 3.0.0-beta.2

package/dist/types/encoding/address.d.ts

@@ -1,12 +1,45 @@
-import { Address } from '../types/address';
-import { MultisigMetadata } from '../types/multisig';
+export declare const ALGORAND_ADDRESS_BYTE_LENGTH = 36;
+export declare const ALGORAND_CHECKSUM_BYTE_LENGTH = 4;
+export declare const ALGORAND_ADDRESS_LENGTH = 58;
 export declare const ALGORAND_ZERO_ADDRESS_STRING = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ";
 export declare const MALFORMED_ADDRESS_ERROR_MSG = "address seems to be malformed";
 export declare const CHECKSUM_ADDRESS_ERROR_MSG = "wrong checksum for address";
-export declare const INVALID_MSIG_VERSION_ERROR_MSG = "invalid multisig version";
-export declare const INVALID_MSIG_THRESHOLD_ERROR_MSG = "bad multisig threshold";
-export declare const INVALID_MSIG_PK_ERROR_MSG = "bad multisig public key - wrong length";
-export declare const UNEXPECTED_PK_LEN_ERROR_MSG = "nacl public key length is not 32 bytes";
+/**
+ * Represents an Algorand address
+ */
+export declare class Address {
+    /**
+     * The binary form of the address. For standard accounts, this is the public key.
+     */
+    readonly publicKey: Uint8Array;
+    /**
+     * Create a new Address object from its binary form.
+     * @param publicKey - The binary form of the address. Must be 32 bytes.
+     */
+    constructor(publicKey: Uint8Array);
+    /**
+     * Check if the address is equal to another address.
+     */
+    equals(other: Address): boolean;
+    /**
+     * Compute the 4 byte checksum of the address.
+     */
+    checksum(): Uint8Array;
+    /**
+     * Encode the address into a string form.
+     */
+    toString(): string;
+    /**
+     * Decode an address from a string.
+     * @param address - The address to decode. Must be 58 bytes long.
+     * @returns An Address object corresponding to the input string.
+     */
+    static fromString(address: string): Address;
+    /**
+     * Get the zero address.
+     */
+    static zeroAddress(): Address;
+}
 /**
  * decodeAddress takes an Algorand address in string form and decodes it into a Uint8Array.
  * @param address - an Algorand address with checksum.
@@ -25,33 +58,9 @@ export declare function isValidAddress(address: string): boolean;
  * @returns the address and checksum encoded as a string.
  */
 export declare function encodeAddress(address: Uint8Array): string;
-/**
- * fromMultisigPreImg takes multisig parameters and returns a 32 byte typed array public key,
- * representing an address that identifies the "exact group, version, and public keys" that are required for signing.
- * Hash("MultisigAddr" || version uint8 || threshold uint8 || PK1 || PK2 || ...)
- * Encoding this output yields a human readable address.
- * @param version - multisig version
- * @param threshold - multisig threshold
- * @param pks - array of typed array public keys
- */
-export declare function fromMultisigPreImg({ version, threshold, pks, }: Omit<MultisigMetadata, 'addrs'> & {
-    pks: Uint8Array[];
-}): Uint8Array;
-/**
- * fromMultisigPreImgAddrs takes multisig parameters and returns a human readable Algorand address.
- * This is equivalent to fromMultisigPreImg, but interfaces with encoded addresses.
- * @param version - multisig version
- * @param threshold - multisig threshold
- * @param addrs - array of encoded addresses
- */
-export declare function fromMultisigPreImgAddrs({ version, threshold, addrs, }: {
-    version: number;
-    threshold: number;
-    addrs: string[];
-}): string;
 /**
  * Get the escrow address of an application.
  * @param appID - The ID of the application.
  * @returns The address corresponding to that application's escrow account.
  */
-export declare function getApplicationAddress(appID: number | bigint): string;
+export declare function getApplicationAddress(appID: number | bigint): Address;

package/dist/types/encoding/binarydata.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Convert a base64 string to a Uint8Array for Node.js and browser environments.
+ * @returns A Uint8Array
+ */
+export declare function base64ToBytes(base64String: string): Uint8Array;
+/**
+ * Convert a Uint8Array to a base64 string for Node.js and browser environments.
+ * @returns A base64 string
+ */
+export declare function bytesToBase64(byteArray: Uint8Array): string;
+/**
+ * Convert a byte array to a UTF-8 string. Warning: not all byte arrays are valid UTF-8.
+ * @returns A decoded string
+ */
+export declare function bytesToString(byteArray: Uint8Array): string;
+/**
+ * Returns a Uint8Array given an input string or Uint8Array.
+ * @returns A base64 string
+ */
+export declare function coerceToBytes(input: Uint8Array | string): Uint8Array;
+/**
+ * Convert a Uint8Array to a hex string for Node.js and browser environments.
+ * @returns A hex string
+ */
+export declare function bytesToHex(byteArray: Uint8Array): string;
+/**
+ * Convert a hex string to Uint8Array for Node.js and browser environments.
+ * @returns A Uint8Array
+ */
+export declare function hexToBytes(hexString: string): Uint8Array;

package/dist/types/encoding/encoding.d.ts

@@ -9,19 +9,231 @@
  *  4. Every positive number must be encoded as uint
  *  5. Binary blob should be used for binary data and string for strings
  *  */
+import { RawBinaryString } from 'algorand-msgpack';
+import IntDecoding from '../types/intDecoding.js';
 export declare const ERROR_CONTAINS_EMPTY_STRING = "The object contains empty or 0 values. First empty or 0 value encountered during encoding: ";
 /**
- * rawEncode encodes objects using msgpack, regardless of whether there are
+ * 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
  */
-export declare function rawEncode(obj: Record<string | number | symbol, any>): Uint8Array;
+export declare function msgpackRawEncode(obj: unknown): Uint8Array;
 /**
- * encode encodes objects using msgpack
- * @param obj - a dictionary to be encoded. Must not contain empty or 0 values.
- * @returns msgpack representation of the object
+ * 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.
+ */
+export declare function encodeObj(obj: Record<string | number | symbol, any>): Uint8Array;
+/**
+ * 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
+ */
+export declare function msgpackRawDecode(buffer: ArrayLike<number>, options?: {
+    intDecoding: IntDecoding;
+}): unknown;
+/**
+ * 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.
+ */
+export declare function decodeObj(o: ArrayLike<number>): unknown;
+/**
+ * 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
+ */
+export declare function msgpackRawDecodeAsMap(encoded: ArrayLike<number>, options?: {
+    intDecoding: IntDecoding;
+}): unknown;
+export type MsgpackEncodingData = null | undefined | string | number | bigint | boolean | Uint8Array | MsgpackEncodingData[] | Map<string | number | bigint | Uint8Array, MsgpackEncodingData>;
+export type JSONEncodingData = null | undefined | string | number | bigint | boolean | JSONEncodingData[] | {
+    [key: string]: JSONEncodingData;
+};
+export declare function msgpackEncodingDataToJSONEncodingData(e: MsgpackEncodingData): JSONEncodingData;
+export declare function jsonEncodingDataToMsgpackEncodingData(e: JSONEncodingData): MsgpackEncodingData;
+declare enum MsgpackObjectPathSegmentKind {
+    MAP_VALUE = 0,
+    ARRAY_ELEMENT = 1
+}
+interface MsgpackObjectPathSegment {
+    kind: MsgpackObjectPathSegmentKind;
+    key: string | number | bigint | Uint8Array | RawBinaryString;
+}
+/**
+ * This class is used to index into an encoded msgpack object and extract raw strings.
+ */
+export declare class MsgpackRawStringProvider {
+    private readonly parent?;
+    private readonly baseObjectBytes?;
+    private readonly segment?;
+    private resolvedCache;
+    private resolvedCachePresent;
+    constructor({ parent, segment, baseObjectBytes, }: {
+        parent: MsgpackRawStringProvider;
+        segment: MsgpackObjectPathSegment;
+        baseObjectBytes?: undefined;
+    } | {
+        parent?: undefined;
+        segment?: undefined;
+        baseObjectBytes: ArrayLike<number>;
+    });
+    /**
+     * Create a new provider that resolves to the current provider's map value at the given key.
+     */
+    withMapValue(key: string | number | bigint | Uint8Array | RawBinaryString): MsgpackRawStringProvider;
+    /**
+     * Create a new provider that resolves to the current provider's array element at the given index.
+     */
+    withArrayElement(index: number): MsgpackRawStringProvider;
+    /**
+     * Get the raw string at the current location. If the current location is not a raw string, an error is thrown.
+     */
+    getRawStringAtCurrentLocation(): Uint8Array;
+    /**
+     * 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(): Map<Uint8Array, MsgpackEncodingData>;
+    /**
+     * Resolve the provider by extracting the value it indicates from the base msgpack object.
+     */
+    private resolve;
+    /**
+     * Get the path string of the current location indicated by the provider. Useful for debugging.
+     */
+    getPathString(): string;
+}
+/**
+ * Options for {@link Schema.prepareJSON}
+ */
+export interface PrepareJSONOptions {
+    /**
+     * If true, allows invalid UTF-8 binary strings to be converted to JSON strings.
+     *
+     * Otherwise, an error will be thrown if encoding a binary string to a JSON cannot be done losslessly.
+     */
+    lossyBinaryStringConversion?: boolean;
+}
+/**
+ * A Schema is used to prepare objects for encoding and decoding from msgpack and JSON.
+ *
+ * Schemas represent a specific type.
+ */
+export declare abstract class Schema {
+    /**
+     * Get the default value for this type.
+     */
+    abstract defaultValue(): unknown;
+    /**
+     * Checks if the value is the default value for this type.
+     * @param data - The value to check
+     * @returns True if the value is the default value, false otherwise
+     */
+    abstract isDefaultValue(data: unknown): boolean;
+    /**
+     * Prepares the encoding data for encoding to msgpack.
+     * @param data - Encoding data to be prepared.
+     * @returns A value ready to be msgpack encoded.
+     */
+    abstract prepareMsgpack(data: unknown): MsgpackEncodingData;
+    /**
+     * Restores the encoding data from a msgpack encoding object.
+     * @param encoded - The msgpack encoding object to restore.
+     * @param rawStringProvider - A provider for raw strings.
+     * @returns The original encoding data.
+     */
+    abstract fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): unknown;
+    /**
+     * Prepares the encoding data for encoding to JSON.
+     * @param data - The JSON encoding data to be prepared.
+     * @returns A value ready to be JSON encoded.
+     */
+    abstract prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    /**
+     * Restores the encoding data from a JSON encoding object.
+     * @param encoded - The JSON encoding object to restore.
+     * @returns The original encoding data.
+     */
+    abstract fromPreparedJSON(encoded: JSONEncodingData): unknown;
+}
+/**
+ * An interface for objects that can be encoded and decoded to/from msgpack and JSON.
+ */
+export interface Encodable {
+    /**
+     * Extract the encoding data for this object. This data, after being prepared by the encoding
+     * Schema, can be encoded to msgpack or JSON.
+     */
+    toEncodingData(): unknown;
+    /**
+     * Get the encoding Schema for this object, used to prepare the encoding data for msgpack and JSON.
+     */
+    getEncodingSchema(): Schema;
+}
+/**
+ * A type that represents the class of an Encodable object.
+ */
+export interface EncodableClass<T extends Encodable> {
+    /**
+     * Create a new instance of this class from the given encoding data.
+     * @param data - The encoding data to create the object from
+     */
+    fromEncodingData(data: unknown): T;
+    /**
+     * The encoding Schema for this class, used to prepare encoding data from msgpack and JSON.
+     */
+    readonly encodingSchema: Schema;
+}
+/**
+ * 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
+ */
+export declare function decodeMsgpack<T extends Encodable>(encoded: ArrayLike<number>, c: EncodableClass<T>): T;
+/**
+ * Encode an Encodable object to a msgpack byte array.
+ * @param e - The object to encode
+ * @returns A msgpack byte array encoding of the object
+ */
+export declare function encodeMsgpack(e: Encodable): Uint8Array;
+/**
+ * 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
+ */
+export declare function decodeJSON<T extends Encodable>(encoded: string, c: EncodableClass<T>): T;
+export interface EncodeJSONOptions {
+    /**
+     * Adds indentation, white space, and line break characters to the return-value JSON text to make
+     * it easier to read.
+     */
+    space?: string | number;
+    /**
+     * If true, allows invalid UTF-8 binary strings to be converted to JSON strings.
+     *
+     * Otherwise, an error will be thrown if encoding a binary string to a JSON cannot be done losslessly.
+     */
+    lossyBinaryStringConversion?: boolean;
+}
+/**
+ * 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
  */
-export declare function encode(obj: Record<string | number | symbol, any>): Uint8Array;
-export declare function decode(buffer: ArrayLike<number>): unknown;
+export declare function encodeJSON(e: Encodable, options?: EncodeJSONOptions): string;
+export {};

package/dist/types/encoding/schema/address.d.ts

@@ -0,0 +1,10 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+import { Address } from '../address.js';
+export declare class AddressSchema extends Schema {
+    defaultValue(): Address;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): Address;
+    prepareJSON(data: unknown, _options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Address;
+}

package/dist/types/encoding/schema/array.d.ts

@@ -0,0 +1,11 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+export declare class ArraySchema extends Schema {
+    readonly itemSchema: Schema;
+    constructor(itemSchema: Schema);
+    defaultValue(): unknown[];
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): unknown[];
+    prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): unknown[];
+}

package/dist/types/encoding/schema/binarystring.d.ts

@@ -0,0 +1,18 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+/**
+ * SpecialCaseBinaryStringSchema is a schema for byte arrays which are encoded
+ * as strings in msgpack and JSON.
+ *
+ * This schema allows lossless conversion between the in memory representation
+ * and the msgpack encoded representation, but NOT between the in memory and
+ * JSON encoded representations if the byte array contains invalid UTF-8
+ * sequences.
+ */
+export declare class SpecialCaseBinaryStringSchema extends Schema {
+    defaultValue(): Uint8Array;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(_encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): Uint8Array;
+    prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Uint8Array;
+}

package/dist/types/encoding/schema/blockhash.d.ts

@@ -0,0 +1,16 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+/**
+ * BlockHashSchema is a schema for block hashes.
+ *
+ * In msgapck, these types are encoded as 32-byte binary strings. In JSON, they
+ * are encoded as strings prefixed with "blk-" followed by the base32 encoding
+ * of the 32-byte block hash without any padding.
+ */
+export declare class BlockHashSchema extends Schema {
+    defaultValue(): Uint8Array;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): Uint8Array;
+    prepareJSON(data: unknown, _options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Uint8Array;
+}

package/dist/types/encoding/schema/boolean.d.ts

@@ -0,0 +1,10 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+export declare class BooleanSchema extends Schema {
+    defaultValue(): boolean;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): boolean;
+    prepareJSON(data: unknown, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): boolean;
+}

package/dist/types/encoding/schema/bytearray.d.ts

@@ -0,0 +1,19 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+export declare class ByteArraySchema extends Schema {
+    defaultValue(): Uint8Array;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): Uint8Array;
+    prepareJSON(data: unknown, _options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Uint8Array;
+}
+export declare class FixedLengthByteArraySchema extends Schema {
+    readonly length: number;
+    constructor(length: number);
+    defaultValue(): Uint8Array;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): Uint8Array;
+    prepareJSON(data: unknown): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Uint8Array;
+}

package/dist/types/encoding/schema/index.d.ts

@@ -0,0 +1,11 @@
+export { BooleanSchema } from './boolean.js';
+export { StringSchema } from './string.js';
+export { Uint64Schema } from './uint64.js';
+export { AddressSchema } from './address.js';
+export { ByteArraySchema, FixedLengthByteArraySchema } from './bytearray.js';
+export { BlockHashSchema } from './blockhash.js';
+export { SpecialCaseBinaryStringSchema } from './binarystring.js';
+export { ArraySchema } from './array.js';
+export { NamedMapSchema, NamedMapEntry, allOmitEmpty, combineMaps, convertMap, Uint64MapSchema, StringMapSchema, ByteArrayMapSchema, SpecialCaseBinaryStringMapSchema, } from './map.js';
+export { OptionalSchema } from './optional.js';
+export { UntypedSchema } from './untyped.js';

package/dist/types/encoding/schema/map.d.ts

@@ -0,0 +1,125 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+/**
+ * Describes a key-value entry in a NamedMapSchema.
+ */
+export 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;
+}
+/**
+ * Applies the omitEmpty flag to all entries in the array.
+ * @param entries - The entries to apply the flag to.
+ * @returns A new array with the omitEmpty flag applied to all entries.
+ */
+export declare function allOmitEmpty(entries: Array<Omit<NamedMapEntry, 'omitEmpty'>>): NamedMapEntry[];
+/**
+ * Schema for a map/struct with a fixed set of known string fields.
+ */
+export 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>;
+}
+/**
+ * Combines multiple maps into a single map. Throws an error if any of the maps have duplicate keys.
+ * @param maps - The maps to combine.
+ * @returns A new map with all the entries from the input maps.
+ */
+export declare function combineMaps<K, V>(...maps: Array<Map<K, V>>): Map<K, V>;
+/**
+ * Converts a map to a new map with different keys and values.
+ * @param map - The map to convert.
+ * @param func - The function to convert each entry.
+ * @returns A new map with the converted entries.
+ */
+export declare function convertMap<K1, V1, K2, V2>(map: Map<K1, V1>, func: (k: K1, v: V1) => [K2, V2]): Map<K2, V2>;
+/**
+ * Schema for a map with a variable number of uint64 keys.
+ */
+export declare class Uint64MapSchema extends Schema {
+    readonly valueSchema: Schema;
+    constructor(valueSchema: Schema);
+    defaultValue(): Map<bigint, unknown>;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): Map<bigint, unknown>;
+    prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Map<bigint, unknown>;
+}
+/**
+ * Schema for a map with a variable number of string keys.
+ */
+export declare class StringMapSchema extends Schema {
+    readonly valueSchema: Schema;
+    constructor(valueSchema: Schema);
+    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>;
+}
+/**
+ * Schema for a map with a variable number of byte array keys.
+ */
+export declare class ByteArrayMapSchema extends Schema {
+    readonly valueSchema: Schema;
+    constructor(valueSchema: Schema);
+    defaultValue(): Map<Uint8Array, unknown>;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): Map<Uint8Array, unknown>;
+    prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Map<Uint8Array, unknown>;
+}
+/**
+ * Schema for a map with a variable number of binary string keys.
+ *
+ * See SpecialCaseBinaryStringSchema for more information about the key type.
+ */
+export declare class SpecialCaseBinaryStringMapSchema extends Schema {
+    readonly valueSchema: Schema;
+    constructor(valueSchema: Schema);
+    defaultValue(): Map<Uint8Array, unknown>;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(_encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): Map<Uint8Array, unknown>;
+    prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): Map<Uint8Array, unknown>;
+}

package/dist/types/encoding/schema/optional.d.ts

@@ -0,0 +1,24 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+/**
+ * OptionalSchema allows for another schema-defined value to be optional.
+ *
+ * This expands the set of values which can be represented by the given schema to include `undefined`.
+ *
+ * Note that this schema considers `undefined` _and_ any default values from the underlying schema
+ * to all be default values. This means that when using NamedMapSchema to omit default values, an
+ * `undefined` value is indistinguishable from the given schema's default value; in this respect,
+ * OptionalSchema does not affect the encoding of NamedMapSchema values, but rather allows the
+ * application to restore omitted values as `undefined` instead of their default value.
+ *
+ * Upon decoding, this schema also allows null/undefined values to be acceptable as values.
+ */
+export declare class OptionalSchema extends Schema {
+    readonly valueSchema: Schema;
+    constructor(valueSchema: Schema);
+    defaultValue(): undefined;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): unknown;
+    prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): unknown;
+}

package/dist/types/encoding/schema/string.d.ts

@@ -0,0 +1,9 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+export declare class StringSchema extends Schema {
+    defaultValue(): string;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): string;
+    prepareJSON(data: unknown, _options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): string;
+}

package/dist/types/encoding/schema/uint64.d.ts

@@ -0,0 +1,9 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+export declare class Uint64Schema extends Schema {
+    defaultValue(): bigint;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): bigint;
+    prepareJSON(data: unknown, _options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): bigint;
+}

package/dist/types/encoding/schema/untyped.d.ts

@@ -0,0 +1,9 @@
+import { Schema, MsgpackEncodingData, MsgpackRawStringProvider, JSONEncodingData, PrepareJSONOptions } from '../encoding.js';
+export declare class UntypedSchema extends Schema {
+    defaultValue(): undefined;
+    isDefaultValue(data: unknown): boolean;
+    prepareMsgpack(data: unknown): MsgpackEncodingData;
+    fromPreparedMsgpack(encoded: MsgpackEncodingData, _rawStringProvider: MsgpackRawStringProvider): MsgpackEncodingData;
+    prepareJSON(data: unknown, _options: PrepareJSONOptions): JSONEncodingData;
+    fromPreparedJSON(encoded: JSONEncodingData): MsgpackEncodingData;
+}

package/dist/types/encoding/uint64.d.ts

@@ -27,3 +27,4 @@ export declare function encodeUint64(num: number | bigint): Uint8Array;
 export declare function decodeUint64(data: Uint8Array, decodingMode: 'safe'): number;
 export declare function decodeUint64(data: Uint8Array, decodingMode: 'mixed'): number | bigint;
 export declare function decodeUint64(data: Uint8Array, decodingMode: 'bigint'): bigint;
+export declare function decodeUint64(data: Uint8Array): number;