@wishknish/knishio-client-ts 0.7.4 → 0.7.6

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { TypedDocumentNode } from '@urql/core';
 
-declare const ISOTOPES: readonly ["C", "V", "U", "T", "M", "I", "R", "B", "F"];
+declare const ISOTOPES: readonly ["C", "V", "U", "T", "M", "I", "R", "B", "F", "P", "A"];
 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];
@@ -163,8 +163,8 @@ interface AtomMetaData$1 extends MetaData {
 interface AtomParams {
     position?: string | null;
     walletAddress?: WalletAddress | null;
-    isotope?: AtomIsotope;
-    token?: TokenSlug | string;
+    isotope?: AtomIsotope | null;
+    token?: TokenSlug | string | null;
     value?: string | number | null;
     batchId?: BatchId | string | null;
     metaType?: MetaType | string | null;
@@ -173,7 +173,7 @@ interface AtomParams {
     otsFragment?: string | null;
     index?: number | null;
     createdAt?: string | null;
-    version?: number | null;
+    version?: string | number | null | undefined;
 }
 interface WalletParams {
     secret?: string | null;
@@ -329,78 +329,10 @@ 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;
+    value: string | null;
+    [props: string]: unknown;
 }
 interface MetaItem {
     key: string;
@@ -410,7 +342,7 @@ interface MetaItem {
 interface AggregatedMetaResult {
     [key: string]: unknown;
 }
-declare class Meta {
+declare class Meta$1 {
     static normalizeMeta(meta: MetaData | MetaItem[] | null): NormalizedMeta[];
     static aggregateMeta(metaItems: NormalizedMeta[] | MetaItem[] | null): AggregatedMetaResult;
     static mergeMeta(...metaArrays: (NormalizedMeta[] | MetaItem[] | null)[]): NormalizedMeta[];
@@ -455,9 +387,85 @@ declare class AtomMeta {
     clone(): AtomMeta;
 }
 
+interface AtomMetaData {
+    readonly key: string;
+    readonly value: string | null;
+    readonly [props: string]: unknown;
+}
+interface AtomCreationParams extends AtomParams {
+    version?: string | number | null | undefined;
+}
+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;
+    version?: string | number | null;
+}
+declare class Atom {
+    position: string | null;
+    walletAddress: WalletAddress | string | null;
+    isotope: AtomIsotope | null;
+    token: TokenSlug | string | null;
+    value: string | null;
+    batchId: BatchId | string | null;
+    metaType: MetaType | string | null;
+    metaId: MetaId | string | null;
+    meta: AtomMetaData[];
+    otsFragment: string | null;
+    index: number | null;
+    createdAt: string;
+    version: string | undefined;
+    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;
+        includeValidationContext?: boolean;
+        validateFields?: boolean;
+    }): Record<string, unknown>;
+    clone(): Atom;
+    isValid(): boolean;
+    static getHashableProps(): string[];
+    static getUnclaimedProps(): string[];
+    static create({ isotope, wallet, value, metaType, metaId, meta, batchId }: {
+        isotope: AtomIsotope | string;
+        wallet?: any | null;
+        value?: string | number | null;
+        metaType?: string | null;
+        metaId?: string | null;
+        meta?: AtomMeta | any[] | Record<string, any> | null;
+        batchId?: string | null;
+    }): 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 | null): boolean;
+    static getUniqueIsotopes(atoms: Atom[]): AtomIsotope[];
+    static calculateTotalValue(atoms: Atom[]): number;
+    static groupByIsotope(atoms: Atom[]): Record<AtomIsotope, Atom[]>;
+}
+
 declare class Wallet {
     token: string;
-    balance: number;
+    balance: string;
     address: string | null;
     position: string | null;
     bundle: string | null;
@@ -522,6 +530,116 @@ declare class Wallet {
     deserializeKey(serializedKey: string): Uint8Array;
 }
 
+declare class Meta<T extends MetaData = MetaData> {
+    private readonly __data;
+    constructor(args?: T);
+    static toObject<U extends MetaData>(object: U): Meta<U>;
+    get<K extends keyof T>(key: K): T[K] | undefined;
+    set<K extends keyof T>(key: K, value: T[K]): void;
+    has<K extends keyof T>(key: K): boolean;
+    keys(): string[];
+    toJSON(): T;
+    clone(): Meta<T>;
+    merge<U extends MetaData>(other: Meta<U>): Meta<T & U>;
+    forEach<K extends keyof T>(callback: (value: T[K], key: K) => void): void;
+    get size(): number;
+    clear(): void;
+}
+
+type CallbackAction = 'reject' | 'meta' | 'collect' | 'buffer' | 'remit' | 'burn';
+interface CallbackParams {
+    action: CallbackAction | string;
+    metaType?: MetaType | string | null;
+    metaId?: MetaId | string | null;
+    meta?: Meta<MetaData> | MetaData | null;
+    address?: WalletAddress | string | null;
+    token?: TokenSlug | string | null;
+    amount?: string | null;
+    comparison?: string | null;
+}
+interface CallbackJSON {
+    action: string;
+    metaType?: string;
+    metaId?: string;
+    meta?: MetaData;
+    address?: string;
+    token?: string;
+    amount?: string;
+    comparison?: string;
+}
+declare class Callback {
+    private __action;
+    private __metaType?;
+    private __metaId?;
+    private __meta?;
+    private __address?;
+    private __token?;
+    private __amount?;
+    private __comparison?;
+    constructor(params: CallbackParams);
+    set comparison(comparison: string);
+    set amount(amount: string);
+    set token(token: string);
+    set address(address: string);
+    set meta(meta: Meta<MetaData> | MetaData);
+    set metaType(metaType: string);
+    set metaId(metaId: string);
+    static toObject(object: CallbackParams): Callback;
+    toJSON(): CallbackJSON;
+    isReject(): this is Callback & {
+        __action: 'reject';
+    };
+    isMeta(): this is Callback & {
+        __action: 'meta';
+    };
+    isCollect(): this is Callback & {
+        __action: 'collect';
+    };
+    isBuffer(): this is Callback & {
+        __action: 'buffer';
+    };
+    isRemit(): this is Callback & {
+        __action: 'remit';
+    };
+    isBurn(): this is Callback & {
+        __action: 'burn';
+    };
+    private _is;
+    get action(): string;
+}
+
+interface ConditionParams {
+    key: string;
+    value: any;
+    comparison: string;
+}
+declare class Condition {
+    private __key;
+    private __value;
+    private __comparison;
+    constructor({ key, value, comparison }: ConditionParams);
+    static toObject(object: ConditionParams): Condition;
+    toJSON(): ConditionParams;
+}
+
+interface RuleParams {
+    condition?: Condition[];
+    callback?: Callback[];
+}
+interface RuleJSON {
+    condition: Condition[];
+    callback: Callback[];
+}
+declare class Rule {
+    private __condition;
+    private __callback;
+    constructor({ condition, callback }: RuleParams);
+    set comparison(condition: Condition | Record<string, any>);
+    set callback(callback: Callback | Record<string, any>);
+    static toObject(object: any): Rule;
+    toJSON(): RuleJSON;
+}
+
 declare class Molecule {
     status: string | null;
     molecularHash: string | null;
@@ -533,7 +651,8 @@ declare class Molecule {
     sourceWallet: Wallet | null;
     remainderWallet: Wallet | null;
     atoms: Atom[];
-    version: string | null;
+    version: string | null | undefined;
+    parentHashes: string[];
     local?: number;
     constructor({ secret, bundle, sourceWallet, remainderWallet, cellSlug, version }?: {
         secret?: string | null;
@@ -550,6 +669,12 @@ declare class Molecule {
     generateIndex(): number;
     addAtom(atom: Atom): Molecule;
     addContinuIdAtom(): Molecule;
+    addPolicyAtom({ metaType, metaId, meta, policy }: {
+        metaType: string;
+        metaId: string;
+        meta?: any;
+        policy?: Record<string, any>;
+    }): Molecule;
     initValue({ recipientWallet, amount }: {
         recipientWallet: Wallet;
         amount: number;
@@ -574,10 +699,13 @@ declare class Molecule {
         amount: number;
         meta: any;
     }): Molecule;
-    burnToken({ amount, walletBundle }: {
+    burnToken({ amount, walletBundle: _walletBundle }: {
         amount: number;
         walletBundle?: string | null;
     }): Molecule;
+    initAuthorization({ meta }: {
+        meta: Record<string, any>;
+    }): Molecule;
     initMeta({ meta, metaType, metaId, policy }: {
         meta: any;
         metaType: string;
@@ -585,12 +713,49 @@ declare class Molecule {
         policy?: any;
     }): Molecule;
     initWalletCreation(wallet: Wallet, atomMeta?: AtomMeta | null): Molecule;
+    createRule({ metaType, metaId, rule, policy }: {
+        metaType: string;
+        metaId: string;
+        rule: Rule[] | any[] | any;
+        policy?: Record<string, any>;
+    }): Molecule;
+    initTokenRequest({ token, amount, metaType, metaId, meta, batchId }: {
+        token: string;
+        amount: number;
+        metaType: string;
+        metaId: string;
+        meta?: Record<string, any>;
+        batchId?: string | null;
+    }): Molecule;
     static fromJSON(json: string | any, options?: {
         includeValidationContext?: boolean;
         validateStructure?: boolean;
         strictMode?: boolean;
     }): Molecule;
     static jsonToObject(json: string): Molecule;
+    initPeering({ host }: {
+        host: string;
+    }): Molecule;
+    initAppendRequest({ metaType, metaId, action, meta }: {
+        metaType: string;
+        metaId: string;
+        action: string;
+        meta?: Record<string, any>;
+    }): Molecule;
+    initDepositBuffer({ amount, tradeRates }: {
+        amount: number;
+        tradeRates?: Record<string, any>;
+    }): Molecule;
+    initWithdrawBuffer({ recipients, signingWallet }: {
+        recipients: Record<string, number>;
+        signingWallet?: any | null;
+    }): Molecule;
+    initShadowWalletClaim(wallet: Wallet): Molecule;
+    initIdentifierCreation({ type, contact, code }: {
+        type: string;
+        contact: string;
+        code: string;
+    }): Molecule;
 }
 
 interface MoleculeStructure {
@@ -619,6 +784,19 @@ declare class CheckMolecule {
     isotopeV(senderWallet?: Wallet | null): boolean;
     molecularHash(): boolean;
     ots(): boolean;
+    static fromServerData({ molecularHash, bundleHash, cellSlug, status, createdAt, atoms }: {
+        molecularHash: string;
+        bundleHash: string;
+        cellSlug?: string | null;
+        status?: string | null;
+        createdAt?: string | null;
+        atoms?: any[];
+    }): Molecule;
+    static verifyFromServerData(moleculeData: any): {
+        molecularHash: string | null;
+        verified: boolean;
+        error: string | null;
+    };
 }
 
 declare class Dot {
@@ -723,6 +901,7 @@ declare class AuthToken {
     getExpiresAt(): number;
     getPubkey(): string;
     isEncrypted(): boolean;
+    getExpireInterval(): number;
     isExpired(): boolean;
     getAuthData(): {
         token: string;
@@ -877,6 +1056,30 @@ declare class Mutation extends Query {
     }): Promise<Response | null>;
 }
 
+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 class ResponseRequestAuthorization extends ResponseProposeMolecule {
+    payloadKey(key: string): any;
+    token(): string;
+    time(): string;
+    expiresAt(): number;
+    encrypt(): string;
+    pubKey(): string;
+}
+
 declare class KnishIOClient {
     private $__secret;
     private $__bundle;
@@ -888,6 +1091,7 @@ declare class KnishIOClient {
     private $__logging;
     private $__authTokenObjects;
     private $__authToken;
+    private $__authInProcess;
     private $__remainderWallet;
     private lastMoleculeQuery;
     private abortControllers;
@@ -952,7 +1156,7 @@ declare class KnishIOClient {
         batchId?: string | null;
         sourceWallet?: Wallet | null;
     }): Promise<Response | null>;
-    requestAuthToken({ secret: _secret, seed: _seed, cellSlug: _cellSlug, encrypt: _encrypt }?: {
+    requestAuthToken({ secret, seed, cellSlug, encrypt }?: {
         secret?: string | null;
         seed?: string | null;
         cellSlug?: string | null;
@@ -988,7 +1192,7 @@ declare class KnishIOClient {
     queryContinuId({ bundle }: {
         bundle: BundleHash | string;
     }): Promise<Response>;
-    queryMeta({ metaType, metaId, key, value, latest, fields: _fields, filter, queryArgs, count, countBy, throughAtom, values, keys, atomValues }: {
+    queryMeta({ metaType, metaId, key, value, latest, fields: _fields, filter, queryArgs, count, countBy, throughAtom, throughMolecule, values, keys, atomValues }: {
         metaType: MetaType | string;
         metaId?: MetaId | string | null;
         key?: string | null;
@@ -1000,6 +1204,22 @@ declare class KnishIOClient {
         count?: number | null;
         countBy?: string | null;
         throughAtom?: boolean | null;
+        throughMolecule?: boolean | null;
+        values?: any[] | null;
+        keys?: string[] | null;
+        atomValues?: any[] | null;
+    }): Promise<Response>;
+    queryMetaVerified(params: {
+        metaType: MetaType | string;
+        metaId?: MetaId | string | null;
+        key?: string | null;
+        value?: string | null;
+        latest?: boolean | null;
+        fields?: string[] | null;
+        filter?: MetaFilter[] | null;
+        queryArgs?: Record<string, any> | null;
+        count?: number | null;
+        countBy?: string | null;
         values?: any[] | null;
         keys?: string[] | null;
         atomValues?: any[] | null;
@@ -1184,6 +1404,15 @@ declare class KnishIOClient {
     requestProfileAuthToken({ secret, encrypt }: {
         secret: string;
         encrypt?: boolean;
+    }): Promise<ResponseRequestAuthorization>;
+    registerPeer({ host }: {
+        host: string;
+    }): Promise<Response>;
+    appendRequest({ metaType, metaId, action, meta }: {
+        metaType: string;
+        metaId: string;
+        action: string;
+        meta?: Record<string, any>;
     }): Promise<Response>;
     cellSlug(): string | null;
     uri(): string[];
@@ -1285,6 +1514,7 @@ declare class ResponseMetaType extends Response {
         query: Query;
         json: any;
     });
+    private extractPayload;
     payload(): any | null;
 }
 
@@ -1342,6 +1572,7 @@ declare class ResponseContinuId extends Response {
 
 declare class QueryContinuId extends Query {
     constructor(graphQLClient: GraphQLClient$1, knishIOClient: KnishIOClient);
+    createQueryContext(): Record<string, any>;
     createResponse(json: any): ResponseContinuId;
 }
 
@@ -1351,21 +1582,6 @@ declare class QueryBatch extends Query {
     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;
@@ -1403,14 +1619,6 @@ declare class MutationCreateWallet extends MutationProposeMolecule {
     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;
@@ -1458,6 +1666,29 @@ declare class MutationRequestTokens extends MutationProposeMolecule {
     createResponse(json: any): ResponseRequestTokens;
 }
 
+declare class ResponsePeering extends ResponseProposeMolecule {
+}
+
+declare class MutationPeering extends MutationProposeMolecule {
+    fillMolecule({ host }: {
+        host: string;
+    }): void;
+    createResponse(json: any): ResponsePeering;
+}
+
+declare class ResponseAppendRequest extends ResponseProposeMolecule {
+}
+
+declare class MutationAppendRequest extends MutationProposeMolecule {
+    fillMolecule({ metaType, metaId, action, meta }: {
+        metaType: string;
+        metaId: string;
+        action: string;
+        meta?: Record<string, any>;
+    }): void;
+    createResponse(json: any): ResponseAppendRequest;
+}
+
 declare class TokenUnit {
     id: string;
     name: string;
@@ -1520,7 +1751,7 @@ declare const CRYPTO_CONSTANTS: {
 };
 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 generateBundleHash(secret: string, _source?: string | null): BundleHash;
 declare function generatePosition(): Position;
 declare function generateBatchId({ molecularHash, index }?: {
     molecularHash?: string | null;
@@ -1835,4 +2066,4 @@ declare const KnishIO: {
     };
 };
 
-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, 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 };
+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$1 as Meta, type MetaData, type MetaId, type MetaQueryParams, type MetaType, type MolecularHash, MolecularHashMismatchException, Molecule, type MoleculeParams, Mutation, MutationAppendRequest, MutationCreateMeta, MutationCreateToken, MutationCreateWallet, type MutationOperation, MutationPeering, MutationProposeMolecule, MutationRequestAuthorization, MutationRequestTokens, MutationTransferTokens, PolicyMeta, type Position, type PositionGenerationOptions, Query, QueryAtom, QueryBalance, QueryBatch, QueryContinuId, QueryMetaType, QueryMetaTypeViaAtom, type QueryOperation, QueryWalletBundle, QueryWalletList, type RequestTokensParams, Response, ResponseAppendRequest, ResponseAtom, ResponseBalance, ResponseContinuId, ResponseCreateMeta, ResponseCreateToken, ResponseCreateWallet, ResponseMetaType, ResponseMetaTypeViaAtom, ResponsePeering, 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, 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 };