@wishknish/knishio-client-ts 0.7.0 → 0.7.1

package/dist/index.d.ts

@@ -0,0 +1,1833 @@
+import { TypedDocumentNode } from '@urql/core';
+
+declare const ISOTOPES: readonly ["C", "V", "U", "T", "M", "I", "R", "B", "F"];
+type AtomIsotope = typeof ISOTOPES[number];
+declare const ERROR_TYPES: readonly ["ATOM_INDEX_ERROR", "ATOMS_MISSING_ERROR", "AUTHORIZATION_REJECTED_ERROR", "BALANCE_INSUFFICIENT_ERROR", "BATCH_ID_ERROR", "CODE_ERROR", "DECRYPTION_KEY_ERROR", "INVALID_RESPONSE_ERROR", "META_MISSING_ERROR", "MOLECULAR_HASH_MISMATCH_ERROR", "MOLECULAR_HASH_MISSING_ERROR", "NEGATIVE_AMOUNT_ERROR", "POLICY_INVALID_ERROR", "RULE_ARGUMENT_ERROR", "SIGNATURE_MALFORMED_ERROR", "SIGNATURE_MISMATCH_ERROR", "STACKABLE_UNIT_AMOUNT_ERROR", "STACKABLE_UNIT_DECIMALS_ERROR", "TRANSFER_BALANCE_ERROR", "TRANSFER_MALFORMED_ERROR", "TRANSFER_MISMATCHED_ERROR", "TRANSFER_REMAINDER_ERROR", "TRANSFER_TO_SELF_ERROR", "TRANSFER_UNBALANCED_ERROR", "UNAUTHENTICATED_ERROR", "WALLET_CREDENTIAL_ERROR", "WALLET_SHADOW_ERROR", "WRONG_TOKEN_TYPE_ERROR"];
+type KnishIOErrorType = typeof ERROR_TYPES[number];
+declare const HEX_CHARS: readonly ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
+type HexChar = typeof HEX_CHARS[number];
+declare const BASE17_CHARS: readonly ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "g"];
+type Base17Char = typeof BASE17_CHARS[number];
+type HexPattern = `${HexChar}${string}`;
+type Base17Pattern = `${Base17Char}${string}`;
+type WalletAddressPattern = `${HexChar}${HexChar}${string}` & {
+    length: 64;
+};
+type BundleHashPattern = `${HexChar}${HexChar}${string}` & {
+    length: 64;
+};
+type PositionPattern = `${HexChar}${HexChar}${string}` & {
+    length: 64;
+};
+type TokenSlugPattern = `${Uppercase<string>}`;
+
+type HashAlgorithm = 'SHAKE256' | 'SHA3-256' | 'BLAKE2B';
+type SignatureAlgorithm = 'XMSS' | 'ML-KEM768' | 'SPHINCS+';
+interface SHAKE256Options {
+    input: string | Uint8Array;
+    outputLength: number;
+    encoding?: 'hex' | 'base64' | 'bytes';
+}
+interface KeyGenerationOptions {
+    secret?: string | null;
+    token?: TokenSlug | string | null;
+    position?: Position | string | null;
+    algorithm?: SignatureAlgorithm;
+    keyLength?: number;
+}
+interface PrivateKey {
+    readonly key: string;
+    readonly algorithm: SignatureAlgorithm;
+    readonly length: number;
+    readonly createdAt: number;
+}
+interface PublicKey {
+    readonly key: string;
+    readonly address: WalletAddress;
+    readonly algorithm: SignatureAlgorithm;
+    readonly length: number;
+    readonly createdAt: number;
+}
+interface SignatureOptions {
+    message: string | Uint8Array;
+    privateKey: PrivateKey | string;
+    algorithm?: SignatureAlgorithm;
+    oneTimeUse?: boolean;
+}
+interface VerificationOptions {
+    message: string | Uint8Array;
+    signature: string;
+    publicKey: PublicKey | string;
+    algorithm?: SignatureAlgorithm;
+}
+interface BundleHashOptions {
+    secret: string;
+    source?: string | null;
+    algorithm?: HashAlgorithm;
+}
+interface PositionGenerationOptions {
+    entropy?: Uint8Array | null;
+    algorithm?: HashAlgorithm;
+    length?: number;
+}
+interface SecretGenerationOptions {
+    seed?: string | null;
+    length?: number;
+    algorithm?: HashAlgorithm;
+}
+
+interface GraphQLRequest$1 {
+    query: string;
+    variables?: Record<string, unknown>;
+    operationName?: string | null;
+}
+interface GraphQLResponse$1<T = unknown> {
+    data?: T | null;
+    errors?: GraphQLError[] | null;
+    extensions?: Record<string, unknown> | null;
+}
+interface GraphQLError {
+    message: string;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: Array<string | number>;
+    extensions?: Record<string, unknown>;
+}
+interface GraphQLVariables {
+    [key: string]: unknown;
+}
+interface QueryOperation<TVariables = GraphQLVariables, TResult = unknown> {
+    query(): string;
+    variables: TVariables;
+    createResponse(data: unknown): TResult;
+    getVariables(): TVariables;
+}
+interface MutationOperation<TVariables = GraphQLVariables, TResult = unknown> {
+    createRequest(variables: TVariables): GraphQLRequest$1;
+    createResponse(data: unknown): TResult;
+    fillMolecule?(variables: TVariables): Promise<void>;
+}
+interface GraphQLClient$1 {
+    query<TResult = unknown, TVariables = GraphQLVariables>(request: GraphQLRequest$1, variables?: TVariables): Promise<GraphQLResponse$1<TResult>>;
+    mutation<TResult = unknown, TVariables = GraphQLVariables>(request: GraphQLRequest$1, variables?: TVariables): Promise<GraphQLResponse$1<TResult>>;
+    mutate<TResult = unknown, TVariables = GraphQLVariables>(request: GraphQLRequest$1, variables?: TVariables): Promise<GraphQLResponse$1<TResult>>;
+    subscription<TResult = unknown, TVariables = GraphQLVariables>(request: GraphQLRequest$1, variables?: TVariables): AsyncIterableIterator<GraphQLResponse$1<TResult>>;
+    getUri(): string;
+}
+
+type WalletAddress = WalletAddressPattern & {
+    readonly __brand: 'WalletAddress';
+};
+type BundleHash = BundleHashPattern & {
+    readonly __brand: 'BundleHash';
+};
+type Position = PositionPattern & {
+    readonly __brand: 'Position';
+};
+type MolecularHash = Base17Pattern & {
+    readonly __brand: 'MolecularHash';
+};
+type TokenSlug = TokenSlugPattern & {
+    readonly __brand: 'TokenSlug';
+};
+type MetaType = string & {
+    readonly __brand: 'MetaType';
+};
+type MetaId = string & {
+    readonly __brand: 'MetaId';
+};
+type BatchId = string & {
+    readonly __brand: 'BatchId';
+};
+type CellSlug = string & {
+    readonly __brand: 'CellSlug';
+};
+type HexString = HexPattern & {
+    readonly __hex: true;
+};
+type Base17Hash = Base17Pattern & {
+    readonly __base17: true;
+};
+
+type HttpUrl = `http://${string}`;
+type HttpsUrl = `https://${string}`;
+interface MetaData {
+    [key: string]: string | number | boolean | null | MetaData | MetaData[];
+}
+interface AtomMetaData$1 extends MetaData {
+    readonly key: string;
+    readonly value: string | number | boolean | null;
+}
+interface AtomParams {
+    position?: string | null;
+    walletAddress?: WalletAddress | null;
+    isotope?: AtomIsotope;
+    token?: TokenSlug | string;
+    value?: string | number | null;
+    batchId?: BatchId | string | null;
+    metaType?: MetaType | string | null;
+    metaId?: MetaId | string | null;
+    meta?: AtomMetaData$1[] | null;
+    otsFragment?: string | null;
+    index?: number | null;
+    createdAt?: string | null;
+    version?: number | null;
+}
+interface WalletParams {
+    secret?: string | null;
+    bundle?: BundleHash | string | null;
+    token?: TokenSlug | string;
+    address?: WalletAddress | string | null;
+    position?: Position | string | null;
+    batchId?: BatchId | string | null;
+    characters?: string | null;
+}
+interface MoleculeParams {
+    secret?: string | null;
+    bundle?: BundleHash | string | null;
+    sourceWallet?: WalletParams | null;
+    remainderWallet?: WalletParams | null;
+    cellSlug?: CellSlug | string | null;
+    version?: number;
+}
+interface KnishIOClientConfig {
+    readonly uri?: HttpUrl | HttpsUrl | readonly (HttpUrl | HttpsUrl)[];
+    readonly cellSlug?: CellSlug | string | null;
+    readonly client?: unknown | null;
+    readonly socket?: unknown | null;
+    readonly serverSdkVersion?: 3 | 4 | 5;
+    readonly logging?: boolean;
+    readonly timeout?: number;
+    readonly retryAttempts?: number;
+}
+interface AuthParams {
+    cellSlug?: CellSlug | string | null;
+    encrypt?: boolean;
+    callback?: (response: unknown) => void;
+}
+interface TransferParams {
+    recipient: WalletAddress | string;
+    amount: number | string;
+    token?: TokenSlug | string;
+    callbackUrl?: string | null;
+    metaType?: MetaType | string | null;
+    metaId?: MetaId | string | null;
+    meta?: MetaData | null;
+}
+interface CreateTokenParams {
+    token: TokenSlug | string;
+    amount: number | string;
+    metaType?: MetaType | string | null;
+    metaId?: MetaId | string | null;
+    meta?: MetaData | null;
+    fungible?: boolean;
+    splittable?: number;
+    supplyToken?: TokenSlug | string | null;
+}
+interface RequestTokensParams {
+    amount: number | string;
+    token?: TokenSlug | string;
+    metaType?: MetaType | string | null;
+    metaId?: MetaId | string | null;
+    meta?: MetaData | null;
+}
+interface BalanceQueryParams {
+    address?: WalletAddress | string | null;
+    bundleHash?: BundleHash | string | null;
+    token?: TokenSlug | string | null;
+    type?: 'token' | 'user' | null;
+}
+interface MetaQueryParams {
+    metaType: MetaType | string;
+    metaId?: MetaId | string | null;
+    key?: string | null;
+    value?: string | null;
+    latest?: boolean | null;
+    filter?: string | null;
+    queryArgs?: Record<string, unknown> | null;
+    count?: number | null;
+    countBy?: string | null;
+    cellSlug?: CellSlug | string | null;
+}
+interface WalletQueryParams {
+    bundleHash?: BundleHash | string | null;
+    tokenSlug?: TokenSlug | string | null;
+    unspent?: boolean | null;
+}
+interface BaseResponse<T = unknown> {
+    success(): boolean;
+    reason(): string | null;
+    data(): T | null;
+    payload(): Record<string, unknown> | null;
+}
+interface ValidationResult$1 {
+    valid: boolean;
+    error?: string | null;
+    expected?: string;
+    actual?: unknown;
+}
+interface GraphQLRequest {
+    query: string;
+    variables?: Record<string, unknown>;
+    operationName?: string | null;
+}
+interface GraphQLResponse<T = unknown> {
+    data?: T | null;
+    errors?: Array<{
+        message: string;
+        locations?: Array<{
+            line: number;
+            column: number;
+        }>;
+        path?: Array<string | number>;
+        extensions?: Record<string, unknown>;
+    }> | null;
+    extensions?: Record<string, unknown>;
+}
+interface ErrorContext {
+    readonly operation?: string;
+    readonly parameters?: Record<string, unknown>;
+    readonly timestamp?: number;
+    readonly stack?: string;
+    readonly reason?: string;
+    readonly expiresAt?: number;
+    readonly credentialType?: string;
+    readonly field?: string;
+    readonly value?: unknown;
+    readonly expected?: string;
+    readonly actual?: unknown;
+    readonly code?: string;
+    readonly severity?: 'low' | 'medium' | 'high';
+    readonly recoverable?: boolean;
+    readonly retryable?: boolean;
+    readonly [key: string]: unknown;
+}
+
+declare global {
+    interface String {
+        toCamelCase(): string;
+        toSnakeCase(): string;
+    }
+}
+declare function isHexString(value: string): value is HexString;
+declare function isWalletAddress(value: string): value is WalletAddress;
+declare function isBundleHash(value: string): value is BundleHash;
+declare function isPosition(value: string): value is Position;
+declare function isMolecularHash(value: string): value is MolecularHash;
+declare function isAtomIsotope(value: string): value is AtomIsotope;
+declare function createWalletAddress(value: string): WalletAddress;
+declare function createBundleHash(value: string): BundleHash;
+declare function createPosition(value: string): Position;
+declare function createTokenSlug(value: string): TokenSlug;
+declare function createMolecularHash(value: string): MolecularHash;
+
+interface AtomMetaData {
+    readonly key: string;
+    readonly value: string | number | boolean | null;
+    readonly [additionalProps: string]: unknown;
+}
+interface AtomCreationParams extends AtomParams {
+    version?: number;
+}
+interface AtomHashableData {
+    position: string;
+    walletAddress: string;
+    isotope: AtomIsotope;
+    token: string;
+    value: string | null;
+    batchId: string | null;
+    metaType: string | null;
+    metaId: string | null;
+    meta: AtomMetaData[] | null;
+    createdAt: string;
+    index: number;
+}
+declare class Atom {
+    position: string;
+    walletAddress: WalletAddress | string;
+    isotope: AtomIsotope;
+    token: TokenSlug | string;
+    value: string | number | null;
+    batchId: BatchId | string | null;
+    metaType: MetaType | string | null;
+    metaId: MetaId | string | null;
+    meta: AtomMetaData[];
+    otsFragment: string | null;
+    index: number | null;
+    createdAt: string;
+    version: number;
+    constructor({ position, walletAddress, isotope, token, value, batchId, metaType, metaId, meta, otsFragment, index, createdAt, version }?: AtomCreationParams);
+    aggregatedMeta(): Record<string, unknown>;
+    getHashableValues(): string[];
+    getStructuredData(): AtomHashableData;
+    toJSON(options?: {
+        includeOtsFragments?: boolean;
+        validateFields?: boolean;
+    }): AtomHashableData & {
+        otsFragment?: string | null;
+    };
+    clone(): Atom;
+    isValid(): boolean;
+    static getHashableProps(): string[];
+    static getUnclaimedProps(): string[];
+    static create(params: AtomCreationParams): Atom;
+    static fromJSON(json: string | Record<string, unknown>, options?: {
+        validateStructure?: boolean;
+        strictMode?: boolean;
+    }): Atom;
+    static jsonToObject(jsonData: Record<string, unknown>): Atom;
+    static hashAtoms({ atoms }: {
+        atoms: Atom[];
+    }): string;
+    static sortAtoms(atoms: Atom[]): Atom[];
+    static generateNextAtomIndex(atoms: Atom[]): number;
+    static isotopeFilter(isotopes: AtomIsotope | AtomIsotope[], atoms: Atom[]): Atom[];
+    static validateAtom(atom: unknown): atom is Atom;
+    static isIsotope(atom: Atom, isotope: AtomIsotope): boolean;
+    static getUniqueIsotopes(atoms: Atom[]): AtomIsotope[];
+    static calculateTotalValue(atoms: Atom[]): number;
+    static groupByIsotope(atoms: Atom[]): Record<AtomIsotope, Atom[]>;
+}
+
+interface NormalizedMeta {
+    key: string;
+    value: string | number | boolean | null;
+    [additionalProps: string]: unknown;
+}
+interface MetaItem {
+    key: string;
+    value: unknown;
+    [props: string]: unknown;
+}
+interface AggregatedMetaResult {
+    [key: string]: unknown;
+}
+declare class Meta {
+    static normalizeMeta(meta: MetaData | MetaItem[] | null): NormalizedMeta[];
+    static aggregateMeta(metaItems: NormalizedMeta[] | MetaItem[] | null): AggregatedMetaResult;
+    static mergeMeta(...metaArrays: (NormalizedMeta[] | MetaItem[] | null)[]): NormalizedMeta[];
+    static filterMeta(metaItems: NormalizedMeta[] | MetaItem[] | null, filter: string | RegExp | ((item: NormalizedMeta) => boolean)): NormalizedMeta[];
+    static findMeta(metaItems: NormalizedMeta[] | MetaItem[] | null, key: string): NormalizedMeta | null;
+    static getMetaValue(metaItems: NormalizedMeta[] | MetaItem[] | null, key: string, defaultValue?: unknown): unknown;
+    static setMeta(metaItems: NormalizedMeta[] | MetaItem[] | null, key: string, value: unknown): NormalizedMeta[];
+    static removeMeta(metaItems: NormalizedMeta[] | MetaItem[] | null, key: string): NormalizedMeta[];
+    static toJSON(metaItems: NormalizedMeta[] | MetaItem[] | null): Record<string, unknown>;
+    static fromJSON(jsonData: Record<string, unknown>): NormalizedMeta[];
+    static validateMeta(metaItems: unknown): metaItems is NormalizedMeta[];
+    static getKeys(metaItems: NormalizedMeta[] | MetaItem[] | null): string[];
+    static hasKey(metaItems: NormalizedMeta[] | MetaItem[] | null, key: string): boolean;
+    static getStats(metaItems: NormalizedMeta[] | MetaItem[] | null): {
+        totalItems: number;
+        uniqueKeys: number;
+        keys: string[];
+        valueTypes: Record<string, number>;
+    };
+    static clone(metaItems: NormalizedMeta[] | MetaItem[] | null): NormalizedMeta[];
+    static sort(metaItems: NormalizedMeta[] | MetaItem[] | null, descending?: boolean): NormalizedMeta[];
+}
+
+declare class AtomMeta {
+    private meta;
+    constructor(meta?: Record<string, any> | NormalizedMeta[] | null);
+    merge(meta: Record<string, any> | NormalizedMeta[]): AtomMeta;
+    addContext(context?: string | null): AtomMeta;
+    setAtomWallet(wallet: any): AtomMeta;
+    setMetaWallet(wallet: any): AtomMeta;
+    setShadowWalletClaim(shadowWalletClaim: boolean | number): AtomMeta;
+    setSigningWallet(signingWallet: any): AtomMeta;
+    addPolicy(policy: Record<string, any>): AtomMeta;
+    get(): NormalizedMeta[];
+    toObject(): Record<string, any>;
+    toJSON(): string;
+    getValue(key: string, defaultValue?: any): any;
+    hasKey(key: string): boolean;
+    remove(key: string): AtomMeta;
+    clear(): AtomMeta;
+    count(): number;
+    clone(): AtomMeta;
+}
+
+declare class Wallet {
+    token: string;
+    balance: number;
+    address: string | null;
+    position: string | null;
+    bundle: string | null;
+    batchId: string | null;
+    characters: string | null;
+    key: string | null;
+    privkey: any;
+    pubkey: any;
+    tokenUnits: any[];
+    tradeRates: Record<string, any>;
+    molecules: Record<string, any>;
+    tokenName?: string;
+    tokenAmount?: string;
+    tokenSupply?: string;
+    tokenFungibility?: string;
+    createdAt?: string;
+    constructor({ secret, bundle, token, address, position, batchId, characters }?: {
+        secret?: string | null;
+        bundle?: string | null;
+        token?: string;
+        address?: string | null;
+        position?: string | null;
+        batchId?: string | null;
+        characters?: string | null;
+    });
+    static create({ secret, bundle, token, batchId, characters }: {
+        secret?: string | null;
+        bundle?: string | null;
+        token?: string;
+        batchId?: string | null;
+        characters?: string | null;
+    }): Wallet;
+    static generateKey({ secret, token, position }: {
+        secret: string;
+        token: string;
+        position: string;
+    }): string;
+    static generateAddress(key: string): string;
+    static generatePosition(saltLength?: number): string;
+    static isBundleHash(maybeBundleHash: unknown): maybeBundleHash is string;
+    static getTokenUnits(unitsData: any[]): any[];
+    createRemainder(secret: string): Wallet;
+    initBatchId({ sourceWallet, isRemainder }: {
+        sourceWallet: Wallet;
+        isRemainder?: boolean;
+    }): void;
+    splitUnits(units: string[], remainderWallet: Wallet, recipientWallet?: Wallet | null): void;
+    getTokenUnitsData(): any[];
+    isShadow(): boolean;
+    initializeMLKEM(): void;
+    encryptMessage(message: any, recipientPubkey: string): Promise<{
+        cipherText: string;
+        encryptedMessage: string;
+    }>;
+    decryptMessage(encryptedData: {
+        cipherText: string;
+        encryptedMessage: string;
+    }): Promise<any>;
+    private encryptWithSharedSecret;
+    private decryptWithSharedSecret;
+    serializeKey(key: Uint8Array): string;
+    deserializeKey(serializedKey: string): Uint8Array;
+}
+
+declare class Molecule {
+    status: string | null;
+    molecularHash: string | null;
+    createdAt: string;
+    cellSlugOrigin: string | null;
+    cellSlug: string | null;
+    secret: string | null;
+    bundle: string | null;
+    sourceWallet: Wallet | null;
+    remainderWallet: Wallet | null;
+    atoms: Atom[];
+    version: string | null;
+    local?: number;
+    constructor({ secret, bundle, sourceWallet, remainderWallet, cellSlug, version }?: {
+        secret?: string | null;
+        bundle?: string | null;
+        sourceWallet?: Wallet | null;
+        remainderWallet?: Wallet | null;
+        cellSlug?: string | null;
+        version?: string | number | null;
+    });
+    get cellSlugDelimiter(): string;
+    getIsotopes(isotopes: AtomIsotope | AtomIsotope[]): Atom[];
+    static isotopeFilter(isotopes: AtomIsotope | AtomIsotope[], atoms: Atom[]): Atom[];
+    static generateNextAtomIndex(atoms: Atom[]): number;
+    generateIndex(): number;
+    addAtom(atom: Atom): Molecule;
+    addContinuIdAtom(): Molecule;
+    initValue({ recipientWallet, amount }: {
+        recipientWallet: Wallet;
+        amount: number;
+    }): Molecule;
+    sign({ bundle, anonymous, compressed }?: {
+        bundle?: string | null;
+        anonymous?: boolean;
+        compressed?: boolean;
+    }): string | null;
+    check(senderWallet?: Wallet | null): boolean;
+    normalizedHash(): number[];
+    static enumerate(hash: string): number[];
+    static normalize(mappedHashArray: number[]): number[];
+    toJSON(options?: {
+        includeValidationContext?: boolean;
+        includeOtsFragments?: boolean;
+        secureMode?: boolean;
+    }): any;
+    cellSlugBase(): string;
+    initTokenCreation({ recipientWallet, amount, meta }: {
+        recipientWallet: Wallet;
+        amount: number;
+        meta: any;
+    }): Molecule;
+    burnToken({ amount, walletBundle }: {
+        amount: number;
+        walletBundle?: string | null;
+    }): Molecule;
+    initMeta({ meta, metaType, metaId, policy }: {
+        meta: any;
+        metaType: string;
+        metaId: string;
+        policy?: any;
+    }): Molecule;
+    initWalletCreation(wallet: Wallet, atomMeta?: AtomMeta | null): Molecule;
+    static fromJSON(json: string | any, options?: {
+        includeValidationContext?: boolean;
+        validateStructure?: boolean;
+        strictMode?: boolean;
+    }): Molecule;
+    static jsonToObject(json: string): Molecule;
+}
+
+interface MoleculeStructure {
+    molecularHash: string | null;
+    atoms: Atom[];
+    status?: string | null;
+    createdAt?: string;
+    cellSlug?: string | null;
+    cellSlugOrigin?: string | null;
+    bundle?: string | null;
+    getIsotopes(isotope: string): Atom[];
+    normalizedHash(): number[];
+}
+declare class CheckMolecule {
+    private molecule;
+    constructor(molecule: MoleculeStructure);
+    verify(senderWallet?: Wallet | null): boolean;
+    continuId(): boolean;
+    batchId(): boolean;
+    isotopeI(): boolean;
+    isotopeU(): boolean;
+    isotopeM(): boolean;
+    isotopeC(): boolean;
+    isotopeT(): boolean;
+    isotopeR(): boolean;
+    isotopeV(senderWallet?: Wallet | null): boolean;
+    molecularHash(): boolean;
+    ots(): boolean;
+}
+
+declare class Dot {
+    private static arr;
+    private static key;
+    private static __nextKey;
+    private static __next;
+    private static __init;
+    private static __tic;
+    static has(obj: any, keys: string): boolean;
+    static get(obj: any, keys: string, defaultValue?: any): any;
+    static set(obj: any, keys: string, value: any): any;
+    static delete(obj: any, keys: string): boolean;
+    static flatten(obj: any, prefix?: string): Record<string, any>;
+    static expand(obj: Record<string, any>): any;
+}
+
+declare function deepCloning<T>(o: T, h?: any[]): T;
+declare function chunkArray<T>(arr: T[], size: number): T[][];
+declare function diff<T>(...arrays: T[][]): T[];
+declare function intersect<T>(...arrays: T[][]): T[];
+
+declare class GraphQLClient implements GraphQLClient$1 {
+    private $__client;
+    private $__authToken;
+    private $__pubkey;
+    private $__wallet;
+    private serverUri;
+    private socketUri;
+    private cipherLink;
+    private $__subscriptionManager;
+    constructor({ serverUri, socket, encrypt }: {
+        serverUri: string;
+        socket?: {
+            socketUri: string | null;
+            appKey?: string;
+        } | null;
+        encrypt?: boolean;
+    });
+    private createUrqlClient;
+    setAuthData({ token, pubkey, wallet }: {
+        token: string;
+        pubkey: string;
+        wallet?: Wallet;
+    }): void;
+    query<TResult = unknown, TVariables = GraphQLVariables>(request: GraphQLRequest, variables?: TVariables): Promise<GraphQLResponse<TResult>>;
+    mutation<TResult = unknown, TVariables = GraphQLVariables>(request: GraphQLRequest, variables?: TVariables): Promise<GraphQLResponse<TResult>>;
+    mutate<TResult = unknown, TVariables = GraphQLVariables>(request: GraphQLRequest, variables?: TVariables): Promise<GraphQLResponse<TResult>>;
+    subscription<TResult = unknown, TVariables = GraphQLVariables>(request: GraphQLRequest, variables?: TVariables): AsyncIterableIterator<GraphQLResponse<TResult>>;
+    subscribe(request: {
+        query: string;
+        variables?: Record<string, any>;
+        operationName?: string;
+    }, callback: (result: any) => void): {
+        unsubscribe: () => void;
+    };
+    private formatResponse;
+    unsubscribe(operationName: string): void;
+    unsubscribeAll(): void;
+    setEncryption(encrypt?: boolean): void;
+    getAuthToken(): string;
+    getPubKey(): string | null;
+    getWallet(): Wallet | null;
+    getServerUri(): string;
+    getSocketUri(): string | null;
+    getUri(): string;
+    setUri(uri: string): void;
+    socketDisconnect(): void;
+}
+
+declare class AuthToken {
+    private $__token;
+    private $__expiresAt;
+    private $__pubkey;
+    private $__encrypt;
+    private $__wallet?;
+    constructor({ token, expiresAt, encrypt, pubkey }: {
+        token: string;
+        expiresAt: number;
+        encrypt: boolean;
+        pubkey: string;
+    });
+    static create(data: {
+        token: string;
+        expiresAt: number;
+        encrypt: boolean;
+        pubkey: string;
+    }, wallet: Wallet): AuthToken;
+    static restore(snapshot: {
+        token: string;
+        expiresAt: number;
+        pubkey: string;
+        encrypt: boolean;
+        wallet: {
+            position: string;
+            characters: string | null;
+        };
+    }, secret: string): AuthToken;
+    setWallet(wallet: Wallet): void;
+    getWallet(): Wallet | undefined;
+    getToken(): string;
+    getExpiresAt(): number;
+    getPubkey(): string;
+    isEncrypted(): boolean;
+    isExpired(): boolean;
+    getAuthData(): {
+        token: string;
+        pubkey: string;
+        wallet: Wallet | undefined;
+    };
+    toSnapshot(): {
+        token: string;
+        expiresAt: number;
+        pubkey: string;
+        encrypt: boolean;
+        wallet?: {
+            position: string | null;
+            characters: string | null;
+        };
+    };
+}
+
+interface UniversalResponse<T> {
+    success(): boolean;
+    payload(): T | null;
+    reason(): string | null;
+    data(): any;
+}
+interface ValidationResult<T> {
+    success: boolean;
+    data?: T;
+    error?: {
+        message: string;
+        details?: string[];
+        code?: string;
+        context?: Record<string, any>;
+        timestamp?: string;
+        operation?: string;
+    };
+    warnings?: string[];
+}
+interface ResponseError {
+    message: string;
+    code?: string | undefined;
+    details?: any;
+    context?: string | Record<string, any> | undefined;
+    timestamp?: string | undefined;
+    operation?: string | undefined;
+}
+interface EnhancedResponse<T> extends UniversalResponse<T> {
+    toValidationResult(): ValidationResult<T>;
+    map<U>(mapper: (value: T) => U): EnhancedResponse<U>;
+    flatMap<U>(mapper: (value: T) => EnhancedResponse<U>): EnhancedResponse<U>;
+    filter(predicate: (value: T) => boolean): EnhancedResponse<T>;
+    onSuccess(callback: (payload: T) => void): EnhancedResponse<T>;
+    onFailure(callback: (error: string) => void): EnhancedResponse<T>;
+    toPromise(): Promise<T>;
+    debug(label?: string): EnhancedResponse<T>;
+}
+interface ResponseMetadata {
+    timestamp: string;
+    operation: string;
+    duration?: number | undefined;
+    requestId?: string | undefined;
+    serverVersion?: string | undefined;
+    clientVersion: string;
+    warnings?: string[] | undefined;
+    error?: ResponseError | undefined;
+}
+
+declare class StandardResponse<T> implements EnhancedResponse<T> {
+    private readonly _successful;
+    private readonly _payload;
+    private readonly _errorMessage;
+    private readonly _rawData;
+    private readonly _metadata;
+    constructor(successful: boolean, payload?: T | null, errorMessage?: string | null, rawData?: any, metadata?: Partial<ResponseMetadata>);
+    success(): boolean;
+    payload(): T | null;
+    reason(): string | null;
+    data(): any;
+    toValidationResult(): ValidationResult<T>;
+    map<U>(mapper: (value: T) => U): EnhancedResponse<U>;
+    flatMap<U>(mapper: (value: T) => EnhancedResponse<U>): EnhancedResponse<U>;
+    filter(predicate: (value: T) => boolean): EnhancedResponse<T>;
+    onSuccess(callback: (payload: T) => void): EnhancedResponse<T>;
+    onFailure(callback: (error: string) => void): EnhancedResponse<T>;
+    toPromise(): Promise<T>;
+    debug(label?: string): EnhancedResponse<T>;
+    static success<T>(payload: T, rawData?: any, metadata?: Partial<ResponseMetadata>): StandardResponse<T>;
+    static failure<T>(errorMessage: string | ResponseError, rawData?: any, metadata?: Partial<ResponseMetadata>): StandardResponse<T>;
+    static fromValidationResult<T>(result: ValidationResult<T>, rawData?: any, metadata?: Partial<ResponseMetadata>): StandardResponse<T>;
+    getErrorDetails(): ResponseError | null;
+    getMetadata(): ResponseMetadata;
+    validate(): ValidationResult<T>;
+}
+
+declare class Response implements UniversalResponse<any> {
+    dataKey: string | null;
+    protected errorKey: string;
+    protected $__payload: any;
+    protected $__query: Query;
+    protected $__originResponse: any;
+    protected $__response: any;
+    constructor({ query, json, dataKey }: {
+        query: Query;
+        json: any;
+        dataKey?: string | null;
+    });
+    protected init(): void;
+    data(): any;
+    response(): any;
+    payload(): any;
+    success(): boolean;
+    error(): string | null;
+    reason(): string | null;
+    toEnhanced<T>(): StandardResponse<T>;
+    toValidationResult<T>(): ValidationResult<T>;
+    onSuccess(callback: (payload: any) => void): Response;
+    onFailure(callback: (error: string) => void): Response;
+    debug(label?: string): Response;
+    toPromise<T>(): Promise<T>;
+}
+
+declare class Query {
+    protected client: GraphQLClient$1;
+    protected knishIOClient: any;
+    protected $__variables: Record<string, any> | null;
+    protected $__query: string | TypedDocumentNode<any, any> | null;
+    protected $__response: Response | null;
+    protected $__request: any;
+    constructor(graphQLClient: GraphQLClient$1, knishIOClient: any);
+    response(): Response | null;
+    createResponseRaw(response: any): Promise<Response>;
+    createResponse(json: any): Response;
+    compiledVariables(variables?: Record<string, any> | null): Record<string, any>;
+    variables(): Record<string, any> | null;
+    uri(): string;
+    createQuery({ variables }: {
+        variables?: Record<string, any> | null;
+    }): any;
+    createQueryContext(): Record<string, any>;
+    execute({ variables, context }?: {
+        variables?: Record<string, any>;
+        context?: Record<string, any>;
+    }): Promise<Response | null>;
+}
+
+declare class Mutation extends Query {
+    createQuery({ variables }: {
+        variables?: Record<string, any> | null;
+    }): any;
+    execute({ variables, context }?: {
+        variables?: Record<string, any>;
+        context?: Record<string, any>;
+    }): Promise<Response | null>;
+}
+
+declare class KnishIOClient {
+    private $__secret;
+    private $__bundle;
+    private $__cellSlug;
+    private $__encrypt;
+    private $__uris;
+    private $__client;
+    private $__serverSdkVersion;
+    private $__logging;
+    private $__authTokenObjects;
+    private $__authToken;
+    private $__remainderWallet;
+    private lastMoleculeQuery;
+    private abortControllers;
+    constructor(config: {
+        uri: string | string[];
+        cellSlug?: string | null;
+        client?: GraphQLClient | null;
+        socket?: {
+            socketUri: string | null;
+            appKey?: string;
+        } | null;
+        serverSdkVersion?: number;
+        logging?: boolean;
+    });
+    initialize({ uri, cellSlug, socket, client, serverSdkVersion, logging }: {
+        uri: string | string[];
+        cellSlug?: string | null;
+        socket?: {
+            socketUri: string | null;
+            appKey?: string;
+        } | null;
+        client?: GraphQLClient | null;
+        serverSdkVersion?: number;
+        logging?: boolean;
+    }): void;
+    getRandomUri(): string;
+    switchEncryption(encrypt: boolean): boolean;
+    deinitialize(): void;
+    subscribe(): GraphQLClient;
+    getServerSdkVersion(): number;
+    reset(): void;
+    client(): GraphQLClient;
+    setUri(uri: string | string[]): void;
+    getUri(): string[];
+    setCellSlug(cellSlug: string | null): void;
+    getCellSlug(): string | null;
+    hasSecret(): boolean;
+    getSecret(): string;
+    hasBundle(): boolean;
+    getBundle(): string;
+    setRemainderWallet(remainderWallet: Wallet): void;
+    getRemainderWallet(): Wallet | null;
+    createMolecule({ secret, bundle, sourceWallet, remainderWallet }?: {
+        secret?: string | null;
+        bundle?: string | null;
+        sourceWallet?: Wallet | null;
+        remainderWallet?: Wallet | null;
+    }): Promise<Molecule>;
+    createMoleculeMutation<T extends Mutation>({ mutationClass, molecule }: {
+        mutationClass: new (client: GraphQLClient, knishIOClient: KnishIOClient, molecule: Molecule) => T;
+        molecule?: Molecule | null;
+    }): Promise<T>;
+    executeQuery(query: Query | Mutation, variables?: Record<string, any> | null): Promise<Response | null>;
+    setSecret(secret: string): void;
+    setAuthToken(authToken: AuthToken): void;
+    getSourceWallet(): Promise<Wallet>;
+    transferToken({ bundleHash, token, amount, units, batchId, sourceWallet }: {
+        bundleHash: string;
+        token: string;
+        amount?: number | null;
+        units?: string[];
+        batchId?: string | null;
+        sourceWallet?: Wallet | null;
+    }): Promise<Response | null>;
+    requestAuthToken({ secret: _secret, seed: _seed, cellSlug: _cellSlug, encrypt: _encrypt }?: {
+        secret?: string | null;
+        seed?: string | null;
+        cellSlug?: string | null;
+        encrypt?: boolean;
+    }): Promise<Response | null>;
+    log(level: 'info' | 'warn' | 'error', message: string): void;
+    createQuery<T extends Query>(QueryClass: new (client: GraphQLClient, knishIOClient: KnishIOClient) => T): T;
+    createSubscribe<T>(SubscribeClass: new (client: GraphQLClient) => T): T;
+    hashSecret(secret: string, source?: string | null): string;
+    getAuthToken(): AuthToken | null;
+    cancelQuery(query: Query | Mutation, variables?: Record<string, any> | null): void;
+    cancelAllQueries(): void;
+    queryBalance({ token, bundle, type }: {
+        token: TokenSlug | string;
+        bundle?: BundleHash | string | null;
+        type?: 'regular' | 'stackable';
+    }): Promise<Response>;
+    querySourceWallet({ token, amount, type }: {
+        token: TokenSlug | string;
+        amount: number | string;
+        type?: 'regular' | 'stackable';
+    }): Promise<Wallet>;
+    queryWallets({ bundle, token, unspent }?: {
+        bundle?: BundleHash | string | null;
+        token?: TokenSlug | string | null;
+        unspent?: boolean;
+    }): Promise<Wallet[]>;
+    queryBundle({ bundle, fields: _fields, raw }?: {
+        bundle?: BundleHash | string | string[] | null;
+        fields?: string[] | null;
+        raw?: boolean;
+    }): Promise<any>;
+    queryContinuId({ bundle }: {
+        bundle: BundleHash | string;
+    }): Promise<Response>;
+    queryMeta({ metaType, metaId, key, value, latest, fields: _fields, filter, queryArgs, count, countBy, throughAtom, values, keys, atomValues }: {
+        metaType: MetaType | string;
+        metaId?: MetaId | string | null;
+        key?: string | null;
+        value?: string | null;
+        latest?: boolean | null;
+        fields?: string[] | null;
+        filter?: string | null;
+        queryArgs?: Record<string, any> | null;
+        count?: number | null;
+        countBy?: string | null;
+        throughAtom?: boolean | null;
+        values?: any[] | null;
+        keys?: string[] | null;
+        atomValues?: any[] | null;
+    }): Promise<Response>;
+    queryBatch({ batchId }: {
+        batchId: BatchId | string;
+    }): Promise<Response>;
+    queryBatchHistory({ batchId }: {
+        batchId: BatchId | string;
+    }): Promise<Response>;
+    queryAtom({ molecularHashes, molecularHash, bundleHashes, bundleHash, positions, position, walletAddresses, walletAddress, isotopes, isotope, tokenSlugs, tokenSlug, cellSlugs, cellSlug, batchIds, batchId, values, value, metaTypes, metaType, metaIds, metaId, indexes, index, filter, latest, queryArgs }?: {
+        molecularHashes?: string[] | null;
+        molecularHash?: string | null;
+        bundleHashes?: string[] | null;
+        bundleHash?: string | null;
+        positions?: string[] | null;
+        position?: string | null;
+        walletAddresses?: string[] | null;
+        walletAddress?: string | null;
+        isotopes?: string[] | null;
+        isotope?: string | null;
+        tokenSlugs?: string[] | null;
+        tokenSlug?: string | null;
+        cellSlugs?: string[] | null;
+        cellSlug?: string | null;
+        batchIds?: string[] | null;
+        batchId?: string | null;
+        values?: any[] | null;
+        value?: any | null;
+        metaTypes?: string[] | null;
+        metaType?: string | null;
+        metaIds?: string[] | null;
+        metaId?: string | null;
+        indexes?: number[] | null;
+        index?: number | null;
+        filter?: string | null;
+        latest?: boolean | null;
+        queryArgs?: Record<string, any> | null;
+    }): Promise<Response>;
+    queryPolicy({ metaType, metaId }: {
+        metaType: MetaType | string;
+        metaId: MetaId | string;
+    }): Promise<Response>;
+    queryActiveSession({ bundleHash, metaType, metaId }: {
+        bundleHash: BundleHash | string;
+        metaType: MetaType | string;
+        metaId: MetaId | string;
+    }): Promise<Response>;
+    queryUserActivity({ bundleHash, metaType, metaId, ipAddress, browser, osCpu, resolution, timeZone, countBy, interval }: {
+        bundleHash: BundleHash | string;
+        metaType: MetaType | string;
+        metaId: MetaId | string;
+        ipAddress?: string | null;
+        browser?: string | null;
+        osCpu?: string | null;
+        resolution?: string | null;
+        timeZone?: string | null;
+        countBy?: string | null;
+        interval?: string | null;
+    }): Promise<Response>;
+    queryToken({ token }: {
+        token: TokenSlug | string;
+    }): Promise<Response>;
+    subscribeCreateMolecule({ bundle, closure }: {
+        bundle: BundleHash | string | null;
+        closure: (result: any) => void;
+    }): Promise<string>;
+    subscribeWalletStatus({ bundle, token, closure }: {
+        bundle: BundleHash | string | null;
+        token: TokenSlug | string;
+        closure: (result: any) => void;
+    }): Promise<string>;
+    subscribeActiveWallet({ bundle, closure }: {
+        bundle: BundleHash | string | null;
+        closure: (result: any) => void;
+    }): Promise<string>;
+    subscribeActiveSession({ metaType, metaId, closure }: {
+        metaType: MetaType | string;
+        metaId: MetaId | string;
+        closure: (result: any) => void;
+    }): Promise<string>;
+    unsubscribe(operationName: string): void;
+    unsubscribeAll(): void;
+    createToken({ token, amount, meta, batchId, units: _units }: {
+        token: TokenSlug | string;
+        amount?: number | string | null;
+        meta?: Record<string, any> | null;
+        batchId?: BatchId | string | null;
+        units?: string[] | null;
+    }): Promise<Response>;
+    requestTokens({ token, to, amount, units: _units, meta, batchId }: {
+        token: TokenSlug | string;
+        to?: WalletAddress | string | null;
+        amount?: number | string | null;
+        units?: string[] | null;
+        meta?: Record<string, any> | null;
+        batchId?: BatchId | string | null;
+    }): Promise<Response>;
+    burnTokens({ token, amount, units: _units, sourceWallet }: {
+        token: TokenSlug | string;
+        amount?: number | string | null;
+        units?: string[] | null;
+        sourceWallet?: Wallet | null;
+    }): Promise<Response>;
+    replenishToken({ token, amount, units, sourceWallet: _sourceWallet }: {
+        token: TokenSlug | string;
+        amount?: number | string | null;
+        units?: string[] | null;
+        sourceWallet?: Wallet | null;
+    }): Promise<Response>;
+    fuseToken({ bundleHash: _bundleHash, tokenSlug, newTokenUnit: _newTokenUnit, fusedTokenUnitIds: _fusedTokenUnitIds, sourceWallet: _sourceWallet }: {
+        bundleHash: BundleHash | string;
+        tokenSlug: TokenSlug | string;
+        newTokenUnit: string;
+        fusedTokenUnitIds: string[];
+        sourceWallet?: Wallet | null;
+    }): Promise<Response>;
+    createWallet({ token }: {
+        token: TokenSlug | string;
+    }): Promise<Response>;
+    claimShadowWallet({ token, batchId, molecule: _molecule }: {
+        token: TokenSlug | string;
+        batchId?: BatchId | string | null;
+        molecule?: Molecule | null;
+    }): Promise<Response>;
+    claimShadowWallets({ token }: {
+        token: TokenSlug | string;
+    }): Promise<Response[]>;
+    createMeta({ metaType, metaId, meta, policy }: {
+        metaType: MetaType | string;
+        metaId: MetaId | string;
+        meta?: Record<string, any> | null;
+        policy?: any | null;
+    }): Promise<Response>;
+    createRule({ metaType, metaId, rule, policy }: {
+        metaType: MetaType | string;
+        metaId: MetaId | string;
+        rule: any;
+        policy?: any | null;
+    }): Promise<Response>;
+    createPolicy({ metaType, metaId, policy }: {
+        metaType: MetaType | string;
+        metaId: MetaId | string;
+        policy?: any | null;
+    }): Promise<Response>;
+    createIdentifier({ type, contact, code }: {
+        type: string;
+        contact: string;
+        code: string;
+    }): Promise<Response>;
+    linkIdentifier({ type, contact }: {
+        type: string;
+        contact: string;
+    }): Promise<Response>;
+    activeSession({ bundle, metaType, metaId, ipAddress, browser, osCpu, resolution, timeZone, json }: {
+        bundle: BundleHash | string;
+        metaType: MetaType | string;
+        metaId: MetaId | string;
+        ipAddress: string;
+        browser: string;
+        osCpu: string;
+        resolution: string;
+        timeZone: string;
+        json?: any | null;
+    }): Promise<Response>;
+    depositBufferToken({ tokenSlug, amount, tradeRates, sourceWallet }: {
+        tokenSlug: TokenSlug | string;
+        amount: number | string;
+        tradeRates: Record<string, number>;
+        sourceWallet?: Wallet | null;
+    }): Promise<Response>;
+    withdrawBufferToken({ tokenSlug, amount, sourceWallet, signingWallet }: {
+        tokenSlug: TokenSlug | string;
+        amount: number | string;
+        sourceWallet?: Wallet | null;
+        signingWallet?: Wallet | null;
+    }): Promise<Response>;
+    requestGuestAuthToken({ cellSlug, encrypt }?: {
+        cellSlug?: CellSlug | string | null;
+        encrypt?: boolean;
+    }): Promise<Response>;
+    requestProfileAuthToken({ secret, encrypt }: {
+        secret: string;
+        encrypt?: boolean;
+    }): Promise<Response>;
+    cellSlug(): string | null;
+    uri(): string[];
+}
+
+declare class ResponseBalance extends Response {
+    constructor({ query, json }: {
+        query: Query;
+        json: Record<string, unknown>;
+    });
+    payload(): Wallet | null;
+    static toClientWallet({ data, secret }: {
+        data: any;
+        secret?: string | null;
+    }): Wallet;
+}
+
+declare class QueryBalance extends Query {
+    constructor(graphQLClient: GraphQLClient, knishIOClient: KnishIOClient);
+    createResponse(json: Record<string, unknown>): ResponseBalance;
+}
+
+declare class ResponseWalletBundle extends Response {
+    constructor({ query, json }: {
+        query: Query;
+        json: Record<string, unknown>;
+    });
+    payload(): Record<string, any> | null;
+}
+
+declare class QueryWalletBundle extends Query {
+    constructor(graphQLClient: GraphQLClient, knishIOClient: KnishIOClient);
+    createResponse(json: Record<string, unknown>): ResponseWalletBundle;
+}
+
+declare class ResponseWalletList extends Response {
+    constructor({ query, json }: {
+        query: Query;
+        json: any;
+    });
+    static toClientWallet({ data, secret }: {
+        data: any;
+        secret?: string | null;
+    }): Wallet;
+    getWallets(secret?: string | null): Wallet[] | null;
+    payload(): Wallet[] | null;
+}
+
+declare class QueryWalletList extends Query {
+    constructor(graphQLClient: GraphQLClient$1, knishIOClient: KnishIOClient);
+    createResponse(json: any): ResponseWalletList;
+}
+
+declare class ResponseAtom extends Response {
+    constructor({ query, json }: {
+        query: Query;
+        json: any;
+    });
+    payload(): any | null;
+    metas(): any[];
+}
+
+declare class QueryAtom extends Query {
+    constructor(graphQLClient: GraphQLClient$1, knishIOClient: KnishIOClient);
+    static createVariables({ molecularHashes, molecularHash, bundleHashes, bundleHash, positions, position, walletAddresses, walletAddress, isotopes, isotope, tokenSlugs, tokenSlug, cellSlugs, cellSlug, batchIds, batchId, values, value, metaTypes, metaType, metaIds, metaId, indexes, index, filter, latest, queryArgs }: {
+        molecularHashes?: string[];
+        molecularHash?: string;
+        bundleHashes?: string[];
+        bundleHash?: string;
+        positions?: string[];
+        position?: string;
+        walletAddresses?: string[];
+        walletAddress?: string;
+        isotopes?: string[];
+        isotope?: string;
+        tokenSlugs?: string[];
+        tokenSlug?: string;
+        cellSlugs?: string[];
+        cellSlug?: string;
+        batchIds?: string[];
+        batchId?: string;
+        values?: string[];
+        value?: string | number;
+        metaTypes?: string[];
+        metaType?: string;
+        metaIds?: string[];
+        metaId?: string;
+        indexes?: number[];
+        index?: number;
+        filter?: object[];
+        latest?: boolean;
+        queryArgs?: object;
+    }): Record<string, any>;
+    createResponse(json: any): ResponseAtom;
+}
+
+declare class ResponseMetaType extends Response {
+    constructor({ query, json }: {
+        query: Query;
+        json: any;
+    });
+    payload(): any | null;
+}
+
+declare class QueryMetaType extends Query {
+    constructor(graphQLClient: GraphQLClient$1, knishIOClient: KnishIOClient);
+    static createVariables({ metaType, metaId, key, value, latest, filter, queryArgs, count, countBy, cellSlug }?: {
+        metaType?: string | string[] | null;
+        metaId?: string | string[] | null;
+        key?: string | string[] | null;
+        value?: string | string[] | null;
+        latest?: boolean | null;
+        filter?: any | null;
+        queryArgs?: any | null;
+        count?: string | null;
+        countBy?: string | null;
+        cellSlug?: string | null;
+    }): Record<string, any>;
+    createResponse(json: any): ResponseMetaType;
+}
+
+declare class ResponseMetaTypeViaAtom extends Response {
+    constructor({ query, json }: {
+        query: Query;
+        json: any;
+    });
+    payload(): any | null;
+}
+
+declare class QueryMetaTypeViaAtom extends Query {
+    constructor(graphQLClient: GraphQLClient$1, knishIOClient: KnishIOClient);
+    static createVariables({ metaType, metaId, key, value, keys, values, atomValues, latest, filter, queryArgs, countBy, cellSlug }?: {
+        metaType?: string | string[] | null;
+        metaId?: string | string[] | null;
+        key?: string | null;
+        value?: string | null;
+        keys?: string[] | null;
+        values?: string[] | null;
+        atomValues?: string[] | null;
+        latest?: boolean | null;
+        filter?: any[] | null;
+        queryArgs?: any | null;
+        countBy?: string | null;
+        cellSlug?: string | string[] | null;
+    }): Record<string, any>;
+    createResponse(json: any): ResponseMetaTypeViaAtom;
+}
+
+declare class ResponseContinuId extends Response {
+    constructor({ query, json }: {
+        query: Query;
+        json: any;
+    });
+    payload(): Wallet | null;
+}
+
+declare class QueryContinuId extends Query {
+    constructor(graphQLClient: GraphQLClient$1, knishIOClient: KnishIOClient);
+    createResponse(json: any): ResponseContinuId;
+}
+
+declare class QueryBatch extends Query {
+    constructor(graphQLClient: GraphQLClient$1, knishIOClient: KnishIOClient);
+    static getFields(): string;
+    createResponse(json: any): Response;
+}
+
+declare class ResponseProposeMolecule extends Response {
+    private $__clientMolecule;
+    constructor({ query, json }: {
+        query: Query;
+        json: Record<string, unknown>;
+    });
+    init(): void;
+    clientMolecule(): any;
+    molecule(): Molecule | null;
+    success(): boolean;
+    status(): string;
+    reason(): string;
+    payload(): any;
+}
+
+declare abstract class MutationProposeMolecule extends Mutation {
+    protected $__molecule: Molecule;
+    protected $__remainderWallet: any | null;
+    constructor(graphQLClient: GraphQLClient, knishIOClient: KnishIOClient, molecule: Molecule);
+    compiledVariables(variables?: Record<string, any> | null): Record<string, any>;
+    createResponse(json: Record<string, unknown>): ResponseProposeMolecule;
+    execute({ variables }?: {
+        variables?: Record<string, any> | null;
+    }): Promise<ResponseProposeMolecule | null>;
+    remainderWallet(): any | null;
+    molecule(): any;
+    abstract fillMolecule(params: any): void;
+}
+
+declare class ResponseTransferTokens extends ResponseProposeMolecule {
+    payload(): {
+        reason: string | null;
+        status: string | null;
+    };
+}
+
+declare class MutationTransferTokens extends MutationProposeMolecule {
+    fillMolecule({ recipientWallet, amount }: {
+        recipientWallet: Wallet;
+        amount: number | string;
+    }): void;
+    createResponse(json: Record<string, unknown>): ResponseTransferTokens;
+}
+
+declare class ResponseCreateWallet extends ResponseProposeMolecule {
+}
+
+declare class MutationCreateWallet extends MutationProposeMolecule {
+    fillMolecule(wallet: Wallet): void;
+    createResponse(json: any): ResponseCreateWallet;
+}
+
+declare class ResponseRequestAuthorization extends ResponseProposeMolecule {
+    payloadKey(key: string): any;
+    token(): string;
+    time(): string;
+    encrypt(): string;
+    pubKey(): string;
+}
+
+declare class MutationRequestAuthorization extends MutationProposeMolecule {
+    fillMolecule({ meta }: {
+        meta: any;
+    }): void;
+    createResponse(json: any): ResponseRequestAuthorization;
+}
+
+declare class ResponseCreateMeta extends ResponseProposeMolecule {
+}
+
+declare class MutationCreateMeta extends MutationProposeMolecule {
+    fillMolecule({ metaType, metaId, meta, policy }: {
+        metaType: string;
+        metaId: string;
+        meta: any[] | any;
+        policy: any;
+    }): void;
+    createResponse(json: any): ResponseCreateMeta;
+}
+
+declare class ResponseCreateToken extends ResponseProposeMolecule {
+}
+
+declare class MutationCreateToken extends MutationProposeMolecule {
+    fillMolecule({ recipientWallet, amount, meta }: {
+        recipientWallet: Wallet;
+        amount: number | string;
+        meta?: any | null;
+    }): void;
+    createResponse(json: any): ResponseCreateToken;
+}
+
+declare class ResponseRequestTokens extends ResponseProposeMolecule {
+}
+
+declare class MutationRequestTokens extends MutationProposeMolecule {
+    fillMolecule({ token, amount, metaType, metaId, meta, batchId }: {
+        token: string;
+        amount: number | string;
+        metaType: string;
+        metaId: string;
+        meta?: any | null;
+        batchId?: string | null;
+    }): void;
+    createResponse(json: any): ResponseRequestTokens;
+}
+
+declare class TokenUnit {
+    id: string;
+    name: string;
+    metas: Record<string, any>;
+    constructor(id: string, name: string, metas?: Record<string, any>);
+    static createFromGraphQL(data: {
+        id: string;
+        name: string;
+        metas?: any;
+    }): TokenUnit;
+    static createFromDB(data: [string, string, Record<string, any>?]): TokenUnit;
+    getFragmentZone(): any | null;
+    getFusedTokenUnits(): any | null;
+    toData(): [string, string, Record<string, any>];
+    toGraphQLResponse(): {
+        id: string;
+        name: string;
+        metas: string;
+    };
+}
+
+declare class PolicyMeta {
+    policy: Record<string, any>;
+    constructor(policy?: Record<string, any>, metaKeys?: string[]);
+    static normalizePolicy(policy?: Record<string, any>): Record<string, any>;
+    fillDefault(metaKeys?: string[]): void;
+    get(): Record<string, any>;
+    toJson(): string;
+}
+
+declare function chunkSubstr(str: string, size: number): string[];
+declare function randomString(length?: number, alphabet?: string): string;
+declare function charsetBaseConvert(src: string, fromBase: number, toBase: number, srcSymbolTable?: string, destSymbolTable?: string): string | number | boolean;
+declare function bufferToHexString(byteArray: Uint8Array | ArrayBuffer | number[]): string;
+declare function hexStringToBuffer(hexString: string): Uint8Array;
+declare function hexToBase64(hexString: string): string;
+declare function base64ToHex(base64String: string): string;
+declare function isHex(str: string): boolean;
+declare function isNumeric(str: string): boolean;
+declare function toCamelCase(str: string): string;
+declare function toSnakeCase(str: string): string;
+declare function capitalize(str: string): string;
+declare function truncate(str: string, length: number, ellipsis?: string): string;
+declare global {
+    interface String {
+        toCamelCase(): string;
+        toSnakeCase(): string;
+    }
+}
+
+declare const CRYPTO_CONSTANTS: {
+    readonly SECRET_LENGTH: 2048;
+    readonly BUNDLE_HASH_LENGTH: 64;
+    readonly POSITION_LENGTH: 64;
+    readonly ADDRESS_LENGTH: 64;
+    readonly MOLECULAR_HASH_OUTPUT_LENGTH: 256;
+    readonly SHAKE256_OUTPUT_LENGTH: 256;
+    readonly KEY_FRAGMENT_SIZE: 128;
+    readonly HASH_ITERATIONS: 16;
+};
+declare function shake256(input: string, outputLength: number): string;
+declare function generateSecret(seed?: string | null, length?: number): string;
+declare function generateBundleHash(secret: string, source?: string | null): BundleHash;
+declare function generatePosition(): Position;
+declare function generateBatchId({ molecularHash, index }?: {
+    molecularHash?: string | null;
+    index?: number | null;
+}): string;
+declare function generateWalletKey({ secret, token, position }: {
+    secret: string;
+    token: string | null;
+    position: string;
+}): string;
+declare function generateWalletAddress(key: string): string;
+declare function validateSecret(secret: string): boolean;
+declare function validateBundleHash(bundleHash: string): boolean;
+declare function validatePosition(position: string): boolean;
+declare function validateWalletAddress(address: string): boolean;
+declare function runCompatibilityTests(): {
+    passed: boolean;
+    results: Array<{
+        test: string;
+        passed: boolean;
+        expected: string;
+        actual: string;
+    }>;
+};
+declare function convertToBase17(hexHash: string): string;
+declare function enumerateMolecularHash(hash: string): number[];
+declare function normalizeMolecularHash(mappedHashArray: number[]): number[];
+declare function generateOTSSignature(privateKey: string, molecularHash: string): string;
+declare function verifyOTSSignature(otsFragments: string, molecularHash: string, signingAddress: string): boolean;
+declare function validateOTSSignature(signature: string): boolean;
+declare function validateMolecularHashForSignature(hash: string): boolean;
+declare const EXTENDED_COMPATIBILITY_TEST_VECTORS: {
+    readonly base17Conversion: readonly [{
+        readonly input: "0000000000000000000000000000000000000000000000000000000000000000";
+        readonly expected: "0000000000000000000000000000000000000000000000000000000000000000";
+    }];
+    readonly molecularEnumeration: readonly [{
+        readonly input: "0000000000000000000000000000000000000000000000000000000000000000";
+        readonly expected: readonly [-8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8];
+    }];
+    readonly shake256: readonly [{
+        readonly input: "test";
+        readonly outputLength: 256;
+        readonly expected: "b54ff7255705a71ee2925e4a3e30e41aed489a579d5595e0df13e32e1e4dd202";
+    }, {
+        readonly input: "KnishIO";
+        readonly outputLength: 256;
+        readonly expected: "35e3c3f33aefb940baaf430855ccb441c24b7b0542f682b8543f4c9d3a077c6e";
+    }];
+};
+declare function runExtendedCompatibilityTests(): {
+    passed: boolean;
+    results: Array<{
+        test: string;
+        passed: boolean;
+        expected: any;
+        actual: any;
+    }>;
+};
+
+interface BaseExceptionOptions {
+    message?: string;
+    cause?: Error | unknown;
+    context?: ErrorContext;
+    code?: string;
+    details?: Record<string, unknown>;
+}
+declare class BaseException extends Error {
+    readonly type: KnishIOErrorType;
+    readonly context: ErrorContext | null;
+    readonly code: string | null;
+    readonly details: Record<string, unknown> | null;
+    readonly timestamp: number;
+    constructor(type: KnishIOErrorType, message: string, options?: BaseExceptionOptions);
+    getFullMessage(): string;
+    toJSON(): Record<string, unknown>;
+    isType(type: KnishIOErrorType): boolean;
+    getContextValue(key: keyof ErrorContext): unknown;
+    withContext(additionalContext: Partial<ErrorContext>): this;
+    static create<T extends BaseException>(this: new (type: KnishIOErrorType, message: string, options?: BaseExceptionOptions) => T, type: KnishIOErrorType, message: string, options?: BaseExceptionOptions): T;
+    static isKnishIOException(error: unknown): error is BaseException;
+    static getErrorType(error: unknown): KnishIOErrorType | null;
+    static fromError(error: Error | unknown, type?: KnishIOErrorType, additionalContext?: Partial<ErrorContext>): BaseException;
+}
+
+declare class AtomIndexException extends BaseException {
+    constructor(message?: string, options?: BaseExceptionOptions);
+    static indexConflict(index: number, existingIndex: number): AtomIndexException;
+    static indexOutOfRange(index: number, maxIndex: number): AtomIndexException;
+    static missingIndex(): AtomIndexException;
+}
+
+declare class AtomsMissingException extends BaseException {
+    constructor(message?: string, options?: BaseExceptionOptions);
+    static emptyMolecule(): AtomsMissingException;
+    static missingIsotope(isotope: string): AtomsMissingException;
+    static missingRemainder(expectedCount: number, actualCount: number): AtomsMissingException;
+    static missingValueAtoms(): AtomsMissingException;
+}
+
+declare class MolecularHashMismatchException extends BaseException {
+    constructor(message?: string, options?: BaseExceptionOptions);
+    static hashMismatch(expected: string, actual: string): MolecularHashMismatchException;
+    static invalidFormat(hash: string): MolecularHashMismatchException;
+    static crossPlatformMismatch(sdk: string, expectedHash: string, actualHash: string): MolecularHashMismatchException;
+    static atomIntegrityFailure(atomIndex: number): MolecularHashMismatchException;
+}
+
+declare class SignatureMismatchException extends BaseException {
+    constructor(message?: string, options?: BaseExceptionOptions);
+    static verificationFailed(publicKey: string, signature: string): SignatureMismatchException;
+    static otsVerificationFailed(fragmentIndex: number): SignatureMismatchException;
+    static crossPlatformMismatch(sdk: string): SignatureMismatchException;
+}
+
+declare class TransferBalanceException extends BaseException {
+    constructor(message?: string, options?: BaseExceptionOptions);
+    static insufficientBalance(required: string, available: string): TransferBalanceException;
+    static negativeBalance(balance: string): TransferBalanceException;
+    static calculationError(operation: string, details?: Record<string, unknown>): TransferBalanceException;
+}
+
+declare class WalletCredentialException extends BaseException {
+    constructor(message?: string, options?: BaseExceptionOptions);
+    static invalidSecret(): WalletCredentialException;
+    static missingCredentials(): WalletCredentialException;
+    static credentialsExpired(): WalletCredentialException;
+    static bundleMismatch(expected: string, actual: string): WalletCredentialException;
+}
+
+declare class InvalidResponseException extends BaseException {
+    constructor(message?: string, options?: BaseExceptionOptions);
+    static malformedJson(error: string): InvalidResponseException;
+    static graphqlError(errors: Array<{
+        message: string;
+    }>): InvalidResponseException;
+    static missingData(operation: string): InvalidResponseException;
+    static networkError(statusCode: number, statusText: string): InvalidResponseException;
+}
+
+declare class ExceptionFactory {
+    static atomIndex: {
+        indexConflict: typeof AtomIndexException.indexConflict;
+        indexOutOfRange: typeof AtomIndexException.indexOutOfRange;
+        missingIndex: typeof AtomIndexException.missingIndex;
+    };
+    static atomsMissing: {
+        emptyMolecule: typeof AtomsMissingException.emptyMolecule;
+        missingIsotope: typeof AtomsMissingException.missingIsotope;
+        missingRemainder: typeof AtomsMissingException.missingRemainder;
+        missingValueAtoms: typeof AtomsMissingException.missingValueAtoms;
+    };
+    static molecularHashMismatch: {
+        hashMismatch: typeof MolecularHashMismatchException.hashMismatch;
+        invalidFormat: typeof MolecularHashMismatchException.invalidFormat;
+        crossPlatformMismatch: typeof MolecularHashMismatchException.crossPlatformMismatch;
+        atomIntegrityFailure: typeof MolecularHashMismatchException.atomIntegrityFailure;
+    };
+    static signatureMismatch: {
+        verificationFailed: typeof SignatureMismatchException.verificationFailed;
+        otsVerificationFailed: typeof SignatureMismatchException.otsVerificationFailed;
+        crossPlatformMismatch: typeof SignatureMismatchException.crossPlatformMismatch;
+    };
+    static transferBalance: {
+        insufficientBalance: typeof TransferBalanceException.insufficientBalance;
+        negativeBalance: typeof TransferBalanceException.negativeBalance;
+        calculationError: typeof TransferBalanceException.calculationError;
+    };
+    static walletCredential: {
+        invalidSecret: typeof WalletCredentialException.invalidSecret;
+        missingCredentials: typeof WalletCredentialException.missingCredentials;
+        credentialsExpired: typeof WalletCredentialException.credentialsExpired;
+        bundleMismatch: typeof WalletCredentialException.bundleMismatch;
+    };
+    static invalidResponse: {
+        malformedJson: typeof InvalidResponseException.malformedJson;
+        graphqlError: typeof InvalidResponseException.graphqlError;
+        missingData: typeof InvalidResponseException.missingData;
+        networkError: typeof InvalidResponseException.networkError;
+    };
+    static fromError: typeof BaseException.fromError;
+}
+declare const EXCEPTION_TYPES: {
+    readonly ATOM_INDEX_ERROR: "ATOM_INDEX_ERROR";
+    readonly ATOMS_MISSING_ERROR: "ATOMS_MISSING_ERROR";
+    readonly AUTHORIZATION_REJECTED_ERROR: "AUTHORIZATION_REJECTED_ERROR";
+    readonly BALANCE_INSUFFICIENT_ERROR: "BALANCE_INSUFFICIENT_ERROR";
+    readonly BATCH_ID_ERROR: "BATCH_ID_ERROR";
+    readonly CODE_ERROR: "CODE_ERROR";
+    readonly DECRYPTION_KEY_ERROR: "DECRYPTION_KEY_ERROR";
+    readonly INVALID_RESPONSE_ERROR: "INVALID_RESPONSE_ERROR";
+    readonly META_MISSING_ERROR: "META_MISSING_ERROR";
+    readonly MOLECULAR_HASH_MISMATCH_ERROR: "MOLECULAR_HASH_MISMATCH_ERROR";
+    readonly MOLECULAR_HASH_MISSING_ERROR: "MOLECULAR_HASH_MISSING_ERROR";
+    readonly NEGATIVE_AMOUNT_ERROR: "NEGATIVE_AMOUNT_ERROR";
+    readonly POLICY_INVALID_ERROR: "POLICY_INVALID_ERROR";
+    readonly SIGNATURE_MALFORMED_ERROR: "SIGNATURE_MALFORMED_ERROR";
+    readonly SIGNATURE_MISMATCH_ERROR: "SIGNATURE_MISMATCH_ERROR";
+    readonly STACKABLE_UNIT_AMOUNT_ERROR: "STACKABLE_UNIT_AMOUNT_ERROR";
+    readonly STACKABLE_UNIT_DECIMALS_ERROR: "STACKABLE_UNIT_DECIMALS_ERROR";
+    readonly TRANSFER_BALANCE_ERROR: "TRANSFER_BALANCE_ERROR";
+    readonly TRANSFER_MALFORMED_ERROR: "TRANSFER_MALFORMED_ERROR";
+    readonly TRANSFER_MISMATCHED_ERROR: "TRANSFER_MISMATCHED_ERROR";
+    readonly TRANSFER_REMAINDER_ERROR: "TRANSFER_REMAINDER_ERROR";
+    readonly TRANSFER_TO_SELF_ERROR: "TRANSFER_TO_SELF_ERROR";
+    readonly TRANSFER_UNBALANCED_ERROR: "TRANSFER_UNBALANCED_ERROR";
+    readonly UNAUTHENTICATED_ERROR: "UNAUTHENTICATED_ERROR";
+    readonly WALLET_CREDENTIAL_ERROR: "WALLET_CREDENTIAL_ERROR";
+    readonly WALLET_SHADOW_ERROR: "WALLET_SHADOW_ERROR";
+    readonly WRONG_TOKEN_TYPE_ERROR: "WRONG_TOKEN_TYPE_ERROR";
+};
+declare const EXCEPTION_CODES: {
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+    readonly VALIDATION_FAILED: "VALIDATION_FAILED";
+    readonly OPERATION_FAILED: "OPERATION_FAILED";
+    readonly INDEX_CONFLICT: "INDEX_CONFLICT";
+    readonly INDEX_OUT_OF_RANGE: "INDEX_OUT_OF_RANGE";
+    readonly INDEX_MISSING: "INDEX_MISSING";
+    readonly EMPTY_MOLECULE: "EMPTY_MOLECULE";
+    readonly MISSING_ISOTOPE: "MISSING_ISOTOPE";
+    readonly MISSING_REMAINDER: "MISSING_REMAINDER";
+    readonly MISSING_VALUE_ATOMS: "MISSING_VALUE_ATOMS";
+    readonly HASH_MISMATCH: "HASH_MISMATCH";
+    readonly INVALID_FORMAT: "INVALID_FORMAT";
+    readonly CROSS_PLATFORM_MISMATCH: "CROSS_PLATFORM_MISMATCH";
+    readonly ATOM_INTEGRITY_FAILURE: "ATOM_INTEGRITY_FAILURE";
+    readonly VERIFICATION_FAILED: "VERIFICATION_FAILED";
+    readonly OTS_VERIFICATION_FAILED: "OTS_VERIFICATION_FAILED";
+    readonly INSUFFICIENT_BALANCE: "INSUFFICIENT_BALANCE";
+    readonly NEGATIVE_BALANCE: "NEGATIVE_BALANCE";
+    readonly CALCULATION_ERROR: "CALCULATION_ERROR";
+    readonly INVALID_SECRET: "INVALID_SECRET";
+    readonly MISSING_CREDENTIALS: "MISSING_CREDENTIALS";
+    readonly CREDENTIALS_EXPIRED: "CREDENTIALS_EXPIRED";
+    readonly BUNDLE_MISMATCH: "BUNDLE_MISMATCH";
+    readonly MALFORMED_JSON: "MALFORMED_JSON";
+    readonly GRAPHQL_ERROR: "GRAPHQL_ERROR";
+    readonly MISSING_DATA: "MISSING_DATA";
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+};
+
+declare const SDK_VERSION = "1.0.0";
+declare const SDK_NAME = "KnishIO-Client-TS";
+declare const COMPATIBLE_SERVER_VERSIONS: number[];
+declare const SDK_INFO: {
+    readonly name: "KnishIO-Client-TS";
+    readonly version: "1.0.0";
+    readonly description: "TypeScript SDK for Knish.IO post-blockchain distributed ledger";
+    readonly compatibleServerVersions: number[];
+    readonly features: readonly ["Post-quantum cryptography (XMSS, ML-KEM768)", "Cross-platform compatibility", "Type-safe APIs", "DAG-based transaction processing", "GraphQL integration", "Real-time subscriptions", "Cellular architecture support"];
+    readonly build: {
+        readonly target: "ES2022";
+        readonly formats: readonly ["esm", "cjs", "iife"];
+        readonly typescript: true;
+        readonly strictMode: true;
+    };
+};
+interface SDKConfig {
+    defaultUri?: string | string[];
+    defaultCellSlug?: string | null;
+    logging?: boolean;
+    cryptoValidation?: boolean;
+    compatibilityChecks?: boolean;
+}
+declare function configureSDK(config: Partial<SDKConfig>): void;
+declare function getSDKConfig(): SDKConfig;
+declare const DevUtils: {
+    validateInstallation(): boolean;
+    runFullCompatibilityTests: typeof runCompatibilityTests;
+    getBuildInfo(): {
+        buildTime: string;
+        nodeVersion: string;
+        environment: string;
+        name: "KnishIO-Client-TS";
+        version: "1.0.0";
+        description: "TypeScript SDK for Knish.IO post-blockchain distributed ledger";
+        compatibleServerVersions: number[];
+        features: readonly ["Post-quantum cryptography (XMSS, ML-KEM768)", "Cross-platform compatibility", "Type-safe APIs", "DAG-based transaction processing", "GraphQL integration", "Real-time subscriptions", "Cellular architecture support"];
+        build: {
+            readonly target: "ES2022";
+            readonly formats: readonly ["esm", "cjs", "iife"];
+            readonly typescript: true;
+            readonly strictMode: true;
+        };
+    };
+} | {
+    validateInstallation?: never;
+    runFullCompatibilityTests?: never;
+    getBuildInfo?: never;
+};
+
+declare const KnishIO: {
+    shake256: typeof shake256;
+    generateSecret: typeof generateSecret;
+    generateBundleHash: typeof generateBundleHash;
+    generateBatchId: typeof generateBatchId;
+    chunkSubstr: typeof chunkSubstr;
+    randomString: typeof randomString;
+    isHex: typeof isHex;
+    SDK_VERSION: string;
+    SDK_INFO: {
+        readonly name: "KnishIO-Client-TS";
+        readonly version: "1.0.0";
+        readonly description: "TypeScript SDK for Knish.IO post-blockchain distributed ledger";
+        readonly compatibleServerVersions: number[];
+        readonly features: readonly ["Post-quantum cryptography (XMSS, ML-KEM768)", "Cross-platform compatibility", "Type-safe APIs", "DAG-based transaction processing", "GraphQL integration", "Real-time subscriptions", "Cellular architecture support"];
+        readonly build: {
+            readonly target: "ES2022";
+            readonly formats: readonly ["esm", "cjs", "iife"];
+            readonly typescript: true;
+            readonly strictMode: true;
+        };
+    };
+};
+
+export { Atom, AtomIndexException, type AtomIsotope, AtomMeta, type AtomParams, AtomsMissingException, type AuthParams, AuthToken, type BalanceQueryParams, type Base17Hash, BaseException, type BaseResponse, type BundleHash, type BundleHashOptions, COMPATIBLE_SERVER_VERSIONS, CRYPTO_CONSTANTS, type CellSlug, CheckMolecule, type CreateTokenParams, DevUtils, Dot, EXCEPTION_CODES, EXCEPTION_TYPES, EXTENDED_COMPATIBILITY_TEST_VECTORS, ExceptionFactory, GraphQLClient, type GraphQLError, type GraphQLRequest, type GraphQLResponse, type HexString, InvalidResponseException, type KeyGenerationOptions, KnishIO, KnishIOClient, type KnishIOClientConfig, Meta, type MetaData, type MetaId, type MetaQueryParams, type MetaType, type MolecularHash, MolecularHashMismatchException, Molecule, type MoleculeParams, Mutation, MutationCreateMeta, MutationCreateToken, MutationCreateWallet, type MutationOperation, MutationProposeMolecule, MutationRequestAuthorization, MutationRequestTokens, MutationTransferTokens, PolicyMeta, type Position, type PositionGenerationOptions, Query, QueryAtom, QueryBalance, QueryBatch, QueryContinuId, QueryMetaType, QueryMetaTypeViaAtom, type QueryOperation, QueryWalletBundle, QueryWalletList, type RequestTokensParams, Response, ResponseAtom, ResponseBalance, ResponseContinuId, ResponseCreateMeta, ResponseCreateToken, ResponseCreateWallet, ResponseMetaType, ResponseMetaTypeViaAtom, ResponseProposeMolecule, ResponseRequestAuthorization, ResponseRequestTokens, ResponseTransferTokens, ResponseWalletBundle, ResponseWalletList, type SDKConfig, SDK_INFO, SDK_NAME, SDK_VERSION, type SHAKE256Options, type SecretGenerationOptions, SignatureMismatchException, type SignatureOptions, type TokenSlug, TokenUnit, TransferBalanceException, type TransferParams, type ValidationResult$1 as ValidationResult, type VerificationOptions, Wallet, type WalletAddress, WalletCredentialException, type WalletParams, type WalletQueryParams, base64ToHex, bufferToHexString, capitalize, charsetBaseConvert, chunkArray, chunkSubstr, configureSDK, convertToBase17, createBundleHash, createMolecularHash, createPosition, createTokenSlug, createWalletAddress, deepCloning, shake256 as default, diff, enumerateMolecularHash, generateBatchId, generateBundleHash, generateOTSSignature, generatePosition, generateSecret, generateWalletAddress, generateWalletKey, getSDKConfig, hexStringToBuffer, hexToBase64, intersect, isAtomIsotope, isBundleHash, isHex, isHexString, isMolecularHash, isNumeric, isPosition, isWalletAddress, normalizeMolecularHash, randomString, runCompatibilityTests, runExtendedCompatibilityTests, shake256, toCamelCase, toSnakeCase, truncate, validateBundleHash, validateMolecularHashForSignature, validateOTSSignature, validatePosition, validateSecret, validateWalletAddress, verifyOTSSignature };