@attocash/commons-js 6.2.1 → 6.3.1

package/commons-commons-js.d.mts

@@ -0,0 +1,1244 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare interface KtMap<K, V> {
+    asJsReadonlyMapView(): ReadonlyMap<K, V>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "kotlin.collections.KtMap": unique symbol;
+    };
+}
+export declare namespace KtMap {
+    function fromJsMap<K, V>(map: ReadonlyMap<K, V>): KtMap<K, V>;
+}
+export declare class AttoAccount implements HeightSupport, AddressSupport {
+    constructor(publicKey: AttoPublicKey, network: AttoNetwork, version: AttoVersion, algorithm: AttoAlgorithm, height: AttoHeight, balance: AttoAmount, lastTransactionHash: AttoHash, lastTransactionTimestamp: AttoInstant, representativeAlgorithm: AttoAlgorithm, representativePublicKey: AttoPublicKey);
+    get publicKey(): AttoPublicKey;
+    get network(): AttoNetwork;
+    get version(): AttoVersion;
+    get algorithm(): AttoAlgorithm;
+    get height(): AttoHeight;
+    get balance(): AttoAmount;
+    get lastTransactionHash(): AttoHash;
+    get lastTransactionTimestamp(): AttoInstant;
+    get representativeAlgorithm(): AttoAlgorithm;
+    get representativePublicKey(): AttoPublicKey;
+    get address(): AttoAddress;
+    get representativeAddress(): AttoAddress;
+    copy(publicKey?: AttoPublicKey, network?: AttoNetwork, version?: AttoVersion, algorithm?: AttoAlgorithm, height?: AttoHeight, balance?: AttoAmount, lastTransactionHash?: AttoHash, lastTransactionTimestamp?: AttoInstant, representativeAlgorithm?: AttoAlgorithm, representativePublicKey?: AttoPublicKey): AttoAccount;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    readonly __doNotUseOrImplementIt: HeightSupport["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"];
+}
+export declare namespace AttoAccount {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoAccount;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare class AttoAccountEntry implements HeightSupport, AddressSupport {
+    constructor(hash: AttoHash, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, height: AttoHeight, blockType: AttoBlockType, subjectAlgorithm: AttoAlgorithm, subjectPublicKey: AttoPublicKey, previousBalance: AttoAmount, balance: AttoAmount, timestamp: AttoInstant);
+    get hash(): AttoHash;
+    get algorithm(): AttoAlgorithm;
+    get publicKey(): AttoPublicKey;
+    get height(): AttoHeight;
+    get blockType(): AttoBlockType;
+    get subjectAlgorithm(): AttoAlgorithm;
+    get subjectPublicKey(): AttoPublicKey;
+    get previousBalance(): AttoAmount;
+    get balance(): AttoAmount;
+    get timestamp(): AttoInstant;
+    get address(): AttoAddress;
+    get subjectAddress(): AttoAddress;
+    copy(hash?: AttoHash, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, height?: AttoHeight, blockType?: AttoBlockType, subjectAlgorithm?: AttoAlgorithm, subjectPublicKey?: AttoPublicKey, previousBalance?: AttoAmount, balance?: AttoAmount, timestamp?: AttoInstant): AttoAccountEntry;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    readonly __doNotUseOrImplementIt: HeightSupport["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"];
+}
+export declare namespace AttoAccountEntry {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoAccountEntry;
+    }
+}
+export declare class AttoAddress {
+    constructor(algorithm: AttoAlgorithm, publicKey: AttoPublicKey);
+    get algorithm(): AttoAlgorithm;
+    get publicKey(): AttoPublicKey;
+    get schema(): string;
+    get path(): string;
+    get value(): string;
+    toString(): string;
+    copy(algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey): AttoAddress;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    static parse(value: string): AttoAddress;
+}
+export declare namespace AttoAddress {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoAddress;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                isValid(value: string): boolean;
+                isValidPath(path: string): boolean;
+                toAddressPath(algorithm: AttoAlgorithm, publicKey: AttoPublicKey): string;
+                parseSerialized(serialized: Int8Array): AttoAddress;
+                /** @deprecated Use parse instead */
+                parsePath(path: string): AttoAddress;
+                private constructor();
+            }
+        }
+    }
+}
+export declare function toAddress(_this_: AttoPublicKey, algorithm: AttoAlgorithm): AttoAddress;
+export declare abstract class AttoAlgorithm {
+    private constructor();
+    static get V1(): AttoAlgorithm & {
+        get name(): "V1";
+        get ordinal(): 0;
+    };
+    get name(): "V1";
+    get ordinal(): 0;
+    get code(): any/* UByte */;
+    get privateKeySize(): number;
+    get publicKeySize(): number;
+    get hashSize(): number;
+    static values(): Array<AttoAlgorithm>;
+    static valueOf(value: string): AttoAlgorithm;
+}
+export declare namespace AttoAlgorithm {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoAlgorithm;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                private constructor();
+            }
+        }
+    }
+}
+export declare abstract class AttoUnit {
+    private constructor();
+    static get ATTO(): AttoUnit & {
+        get name(): "ATTO";
+        get ordinal(): 0;
+    };
+    static get RAW(): AttoUnit & {
+        get name(): "RAW";
+        get ordinal(): 1;
+    };
+    get name(): "ATTO" | "RAW";
+    get ordinal(): 0 | 1;
+    get prefix(): string;
+    static values(): Array<AttoUnit>;
+    static valueOf(value: string): AttoUnit;
+}
+export declare namespace AttoUnit {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoUnit;
+    }
+}
+export declare class AttoAmount /* implements Comparable<AttoAmount> */ {
+    private constructor();
+    toFormattedString(unit: AttoUnit): string;
+    plus(amount: AttoAmount): AttoAmount;
+    minus(amount: AttoAmount): AttoAmount;
+    toString(): string;
+    copy(raw?: bigint): AttoAmount;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    static get MAX(): AttoAmount;
+    static get MIN(): AttoAmount;
+    static from(unit: AttoUnit, string: string): AttoAmount;
+}
+export declare namespace AttoAmount {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoAmount;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare function toAttoAmount(_this_: string): AttoAmount;
+export declare abstract class AttoBlockType {
+    private constructor();
+    static get UNKNOWN(): AttoBlockType & {
+        get name(): "UNKNOWN";
+        get ordinal(): 0;
+    };
+    static get OPEN(): AttoBlockType & {
+        get name(): "OPEN";
+        get ordinal(): 1;
+    };
+    static get RECEIVE(): AttoBlockType & {
+        get name(): "RECEIVE";
+        get ordinal(): 2;
+    };
+    static get SEND(): AttoBlockType & {
+        get name(): "SEND";
+        get ordinal(): 3;
+    };
+    static get CHANGE(): AttoBlockType & {
+        get name(): "CHANGE";
+        get ordinal(): 4;
+    };
+    get name(): "UNKNOWN" | "OPEN" | "RECEIVE" | "SEND" | "CHANGE";
+    get ordinal(): 0 | 1 | 2 | 3 | 4;
+    static values(): Array<AttoBlockType>;
+    static valueOf(value: string): AttoBlockType;
+}
+export declare namespace AttoBlockType {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoBlockType;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare interface HeightSupport {
+    readonly height: AttoHeight;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.HeightSupport": unique symbol;
+    };
+}
+export declare interface AddressSupport {
+    readonly address: AttoAddress;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.AddressSupport": unique symbol;
+    };
+}
+export declare interface AttoBlock extends HeightSupport, AddressSupport, AttoHashable, AttoSerializable {
+    readonly hash: AttoHash;
+    readonly type: AttoBlockType;
+    readonly network: AttoNetwork;
+    readonly version: AttoVersion;
+    readonly algorithm: AttoAlgorithm;
+    readonly publicKey: AttoPublicKey;
+    readonly height: AttoHeight;
+    readonly balance: AttoAmount;
+    readonly timestamp: AttoInstant;
+    validate(): AttoValidation;
+    isValid(): boolean;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.AttoBlock": unique symbol;
+    } & HeightSupport["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"] & AttoHashable["__doNotUseOrImplementIt"] & AttoSerializable["__doNotUseOrImplementIt"];
+}
+export declare namespace AttoBlock {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                private constructor();
+            }
+        }
+    }
+}
+export declare interface PreviousSupport {
+    readonly height: AttoHeight;
+    readonly previous: AttoHash;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.PreviousSupport": unique symbol;
+    };
+}
+export declare interface ReceiveSupport {
+    readonly sendHashAlgorithm: AttoAlgorithm;
+    readonly sendHash: AttoHash;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.ReceiveSupport": unique symbol;
+    };
+}
+export declare interface RepresentativeSupport {
+    readonly representativeAlgorithm: AttoAlgorithm;
+    readonly representativePublicKey: AttoPublicKey;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.RepresentativeSupport": unique symbol;
+    };
+}
+export declare class AttoSendBlock implements AttoBlock, PreviousSupport {
+    constructor(network: AttoNetwork, version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, height: AttoHeight, balance: AttoAmount, timestamp: AttoInstant, previous: AttoHash, receiverAlgorithm: AttoAlgorithm, receiverPublicKey: AttoPublicKey, amount: AttoAmount);
+    get network(): AttoNetwork;
+    get version(): AttoVersion;
+    get algorithm(): AttoAlgorithm;
+    get publicKey(): AttoPublicKey;
+    get height(): AttoHeight;
+    get balance(): AttoAmount;
+    get timestamp(): AttoInstant;
+    get previous(): AttoHash;
+    get receiverAlgorithm(): AttoAlgorithm;
+    get receiverPublicKey(): AttoPublicKey;
+    get amount(): AttoAmount;
+    get type(): AttoBlockType;
+    get hash(): AttoHash;
+    get address(): AttoAddress;
+    get receiverAddress(): AttoAddress;
+    validate(): AttoValidation;
+    copy(network?: AttoNetwork, version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, height?: AttoHeight, balance?: AttoAmount, timestamp?: AttoInstant, previous?: AttoHash, receiverAlgorithm?: AttoAlgorithm, receiverPublicKey?: AttoPublicKey, amount?: AttoAmount): AttoSendBlock;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    isValid(): boolean;
+    toByteArray(): Int8Array;
+    readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"];
+}
+export declare namespace AttoSendBlock {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoSendBlock;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare class AttoReceiveBlock implements AttoBlock, PreviousSupport, ReceiveSupport {
+    constructor(network: AttoNetwork, version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, height: AttoHeight, balance: AttoAmount, timestamp: AttoInstant, previous: AttoHash, sendHashAlgorithm: AttoAlgorithm, sendHash: AttoHash);
+    get network(): AttoNetwork;
+    get version(): AttoVersion;
+    get algorithm(): AttoAlgorithm;
+    get publicKey(): AttoPublicKey;
+    get height(): AttoHeight;
+    get balance(): AttoAmount;
+    get timestamp(): AttoInstant;
+    get previous(): AttoHash;
+    get sendHashAlgorithm(): AttoAlgorithm;
+    get sendHash(): AttoHash;
+    get type(): AttoBlockType;
+    get hash(): AttoHash;
+    get address(): AttoAddress;
+    copy(network?: AttoNetwork, version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, height?: AttoHeight, balance?: AttoAmount, timestamp?: AttoInstant, previous?: AttoHash, sendHashAlgorithm?: AttoAlgorithm, sendHash?: AttoHash): AttoReceiveBlock;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    validate(): AttoValidation;
+    isValid(): boolean;
+    toByteArray(): Int8Array;
+    readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"] & ReceiveSupport["__doNotUseOrImplementIt"];
+}
+export declare namespace AttoReceiveBlock {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoReceiveBlock;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare class AttoOpenBlock implements AttoBlock, ReceiveSupport, RepresentativeSupport {
+    constructor(network: AttoNetwork, version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, balance: AttoAmount, timestamp: AttoInstant, sendHashAlgorithm: AttoAlgorithm, sendHash: AttoHash, representativeAlgorithm: AttoAlgorithm, representativePublicKey: AttoPublicKey);
+    get network(): AttoNetwork;
+    get version(): AttoVersion;
+    get algorithm(): AttoAlgorithm;
+    get publicKey(): AttoPublicKey;
+    get balance(): AttoAmount;
+    get timestamp(): AttoInstant;
+    get sendHashAlgorithm(): AttoAlgorithm;
+    get sendHash(): AttoHash;
+    get representativeAlgorithm(): AttoAlgorithm;
+    get representativePublicKey(): AttoPublicKey;
+    get type(): AttoBlockType;
+    get hash(): AttoHash;
+    get height(): AttoHeight;
+    get address(): AttoAddress;
+    get representativeAddress(): AttoAddress;
+    copy(network?: AttoNetwork, version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, balance?: AttoAmount, timestamp?: AttoInstant, sendHashAlgorithm?: AttoAlgorithm, sendHash?: AttoHash, representativeAlgorithm?: AttoAlgorithm, representativePublicKey?: AttoPublicKey): AttoOpenBlock;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    validate(): AttoValidation;
+    isValid(): boolean;
+    toByteArray(): Int8Array;
+    readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & ReceiveSupport["__doNotUseOrImplementIt"] & RepresentativeSupport["__doNotUseOrImplementIt"];
+}
+export declare namespace AttoOpenBlock {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoOpenBlock;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare class AttoChangeBlock implements AttoBlock, PreviousSupport, RepresentativeSupport {
+    constructor(network: AttoNetwork, version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, height: AttoHeight, balance: AttoAmount, timestamp: AttoInstant, previous: AttoHash, representativeAlgorithm: AttoAlgorithm, representativePublicKey: AttoPublicKey);
+    get network(): AttoNetwork;
+    get version(): AttoVersion;
+    get algorithm(): AttoAlgorithm;
+    get publicKey(): AttoPublicKey;
+    get height(): AttoHeight;
+    get balance(): AttoAmount;
+    get timestamp(): AttoInstant;
+    get previous(): AttoHash;
+    get representativeAlgorithm(): AttoAlgorithm;
+    get representativePublicKey(): AttoPublicKey;
+    get type(): AttoBlockType;
+    get hash(): AttoHash;
+    get address(): AttoAddress;
+    get representativeAddress(): AttoAddress;
+    copy(network?: AttoNetwork, version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, height?: AttoHeight, balance?: AttoAmount, timestamp?: AttoInstant, previous?: AttoHash, representativeAlgorithm?: AttoAlgorithm, representativePublicKey?: AttoPublicKey): AttoChangeBlock;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    validate(): AttoValidation;
+    isValid(): boolean;
+    toByteArray(): Int8Array;
+    readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"] & RepresentativeSupport["__doNotUseOrImplementIt"];
+}
+export declare namespace AttoChangeBlock {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoChangeBlock;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare class AttoChallenge {
+    constructor(value: Int8Array);
+    get value(): Int8Array;
+    equals(other: Nullable<any>): boolean;
+    hashCode(): number;
+    toString(): string;
+    copy(value?: Int8Array): AttoChallenge;
+}
+export declare namespace AttoChallenge {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoChallenge;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare class AttoHash {
+    constructor(value: Int8Array);
+    get value(): Int8Array;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    toString(): string;
+    isValid(): boolean;
+    copy(value?: Int8Array): AttoHash;
+}
+export declare namespace AttoHash {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoHash;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                parse(value: string): AttoHash;
+                hash(size: number, byteArrays: Array<Int8Array>): AttoHash;
+                hashVote(blockHash: AttoHash, algorithm: AttoAlgorithm, timestamp: AttoInstant): AttoHash;
+                private constructor();
+            }
+        }
+    }
+}
+export declare interface AttoHashable {
+    readonly hash: AttoHash;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.AttoHashable": unique symbol;
+    };
+}
+export declare class AttoHeight /* implements Comparable<AttoHeight> */ {
+    private constructor();
+    get value(): bigint;
+    plus(height: AttoHeight): AttoHeight;
+    minus(height: AttoHeight): AttoHeight;
+    next(): AttoHeight;
+    toString(): string;
+    copy(value?: bigint): AttoHeight;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    static get MIN(): AttoHeight;
+    static get MAX(): AttoHeight;
+}
+export declare namespace AttoHeight {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoHeight;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare function toAttoHeight(_this_: string): AttoHeight;
+export declare class AttoInstant /* implements Comparable<AttoInstant> */ {
+    private constructor();
+    get value(): any/* Instant */;
+    toEpochMilliseconds(): bigint;
+    toString(): string;
+    copy(value?: any/* Instant */): AttoInstant;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AttoInstant {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoInstant;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                now(): AttoInstant;
+                fromIso(value: string): AttoInstant;
+                fromEpochMilliseconds(value: bigint): AttoInstant;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class AttoKeyIndex {
+    private constructor();
+    get value(): any/* UInt */;
+    toInt(): number;
+    copy(value?: any/* UInt */): AttoKeyIndex;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AttoKeyIndex {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoKeyIndex;
+    }
+}
+export declare function toAttoIndex(_this_: number): AttoKeyIndex;
+export declare class AttoMnemonic {
+    private constructor();
+    get phrase(): string;
+    static fromPhrase(words: string): AttoMnemonic;
+    static fromEntropy(entropy: Int8Array): AttoMnemonic;
+    toEntropy(): Int8Array;
+    equals(other: Nullable<any>): boolean;
+    hashCode(): number;
+    toString(): string;
+    static generate(): AttoMnemonic;
+}
+export declare namespace AttoMnemonic {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoMnemonic;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare abstract class AttoNetwork {
+    private constructor();
+    static get LIVE(): AttoNetwork & {
+        get name(): "LIVE";
+        get ordinal(): 0;
+    };
+    static get BETA(): AttoNetwork & {
+        get name(): "BETA";
+        get ordinal(): 1;
+    };
+    static get DEV(): AttoNetwork & {
+        get name(): "DEV";
+        get ordinal(): 2;
+    };
+    static get LOCAL(): AttoNetwork & {
+        get name(): "LOCAL";
+        get ordinal(): 3;
+    };
+    static get UNKNOWN(): AttoNetwork & {
+        get name(): "UNKNOWN";
+        get ordinal(): 4;
+    };
+    get name(): "LIVE" | "BETA" | "DEV" | "LOCAL" | "UNKNOWN";
+    get ordinal(): 0 | 1 | 2 | 3 | 4;
+    get code(): any/* UByte */;
+    get thresholdIncreaseFactor(): bigint;
+    static values(): Array<AttoNetwork>;
+    static valueOf(value: string): AttoNetwork;
+}
+export declare namespace AttoNetwork {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoNetwork;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare class AttoPrivateKey {
+    constructor(value: Int8Array);
+    get value(): Int8Array;
+    toString(): string;
+}
+export declare namespace AttoPrivateKey {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoPrivateKey;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                parse(value: string): AttoPrivateKey;
+                generate(): AttoPrivateKey;
+                private constructor();
+            }
+        }
+    }
+}
+export declare function toPrivateKey(_this_: AttoSeed, index: AttoKeyIndex): AttoPrivateKey;
+export declare class AttoPublicKey {
+    constructor(value: Int8Array);
+    get value(): Int8Array;
+    equals(other: Nullable<any>): boolean;
+    hashCode(): number;
+    toString(): string;
+    copy(value?: Int8Array): AttoPublicKey;
+}
+export declare namespace AttoPublicKey {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoPublicKey;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                parse(value: string): AttoPublicKey;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class AttoReceivable {
+    constructor(network: AttoNetwork, hash: AttoHash, version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, timestamp: AttoInstant, receiverAlgorithm: AttoAlgorithm, receiverPublicKey: AttoPublicKey, amount: AttoAmount);
+    get network(): AttoNetwork;
+    get hash(): AttoHash;
+    get version(): AttoVersion;
+    get algorithm(): AttoAlgorithm;
+    get publicKey(): AttoPublicKey;
+    get timestamp(): AttoInstant;
+    get receiverAlgorithm(): AttoAlgorithm;
+    get receiverPublicKey(): AttoPublicKey;
+    get amount(): AttoAmount;
+    get address(): AttoAddress;
+    get receiverAddress(): AttoAddress;
+    copy(network?: AttoNetwork, hash?: AttoHash, version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, timestamp?: AttoInstant, receiverAlgorithm?: AttoAlgorithm, receiverPublicKey?: AttoPublicKey, amount?: AttoAmount): AttoReceivable;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AttoReceivable {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoReceivable;
+    }
+}
+export declare class AttoSeed {
+    constructor(value: Int8Array);
+    get value(): Int8Array;
+    equals(other: Nullable<any>): boolean;
+    hashCode(): number;
+    toString(): string;
+    copy(value?: Int8Array): AttoSeed;
+}
+export declare namespace AttoSeed {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoSeed;
+    }
+}
+export declare interface AttoSerializable {
+    toByteArray(): Int8Array;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.AttoSerializable": unique symbol;
+    };
+}
+export declare class AttoSignature {
+    constructor(value: Int8Array);
+    get value(): Int8Array;
+    equals(other: Nullable<any>): boolean;
+    hashCode(): number;
+    toString(): string;
+    copy(value?: Int8Array): AttoSignature;
+}
+export declare namespace AttoSignature {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoSignature;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                get SIZE(): number;
+                parse(value: string): AttoSignature;
+                private constructor();
+            }
+        }
+    }
+}
+export declare interface AttoSigner {
+    readonly algorithm: AttoAlgorithm;
+    readonly publicKey: AttoPublicKey;
+    readonly address: AttoAddress;
+    signHash(hash: AttoHash): Promise<AttoSignature>;
+    signBlock(block: AttoBlock): Promise<AttoSignature>;
+    signVote(vote: AttoVote): Promise<AttoSignature>;
+    signChallenge(challenge: AttoChallenge, timestamp: AttoInstant): Promise<AttoSignature>;
+    checkPublicKey(publicKey: AttoPublicKey): Promise<void>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.AttoSigner": unique symbol;
+    };
+}
+export declare namespace AttoSigner {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}
+export declare class AttoTransaction implements HeightSupport, AddressSupport, AttoSerializable {
+    constructor(block: AttoBlock, signature: AttoSignature, work: AttoWork);
+    get block(): AttoBlock;
+    get signature(): AttoSignature;
+    get work(): AttoWork;
+    get hash(): AttoHash;
+    get height(): AttoHeight;
+    get address(): AttoAddress;
+    validate(): AttoValidation;
+    isValid(): boolean;
+    getTotalSize(): number;
+    toString(): string;
+    copy(block?: AttoBlock, signature?: AttoSignature, work?: AttoWork): AttoTransaction;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    toByteArray(): Int8Array;
+    readonly __doNotUseOrImplementIt: HeightSupport["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"] & AttoSerializable["__doNotUseOrImplementIt"];
+}
+export declare namespace AttoTransaction {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoTransaction;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                get SIZE(): number;
+                private constructor();
+            }
+        }
+    }
+}
+export declare interface AttoValidation {
+    readonly isValid: boolean;
+    getError(): Nullable<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.AttoValidation": unique symbol;
+    };
+}
+export declare class AttoVersion /* implements Comparable<AttoVersion> */ {
+    private constructor();
+    get value(): any/* UShort */;
+    toString(): string;
+    copy(value?: any/* UShort */): AttoVersion;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AttoVersion {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoVersion;
+    }
+}
+export declare class AttoVote implements AttoHashable, AttoSerializable {
+    constructor(version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, blockAlgorithm: AttoAlgorithm, blockHash: AttoHash, timestamp: AttoInstant);
+    get version(): AttoVersion;
+    get algorithm(): AttoAlgorithm;
+    get publicKey(): AttoPublicKey;
+    get blockAlgorithm(): AttoAlgorithm;
+    get blockHash(): AttoHash;
+    get timestamp(): AttoInstant;
+    get hash(): AttoHash;
+    isFinal(): boolean;
+    isValid(): boolean;
+    copy(version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, blockAlgorithm?: AttoAlgorithm, blockHash?: AttoHash, timestamp?: AttoInstant): AttoVote;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    toByteArray(): Int8Array;
+    readonly __doNotUseOrImplementIt: AttoHashable["__doNotUseOrImplementIt"] & AttoSerializable["__doNotUseOrImplementIt"];
+}
+export declare namespace AttoVote {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoVote;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                get finalTimestamp(): AttoInstant;
+                private constructor();
+            }
+        }
+    }
+}
+export declare class AttoWork {
+    constructor(value: Int8Array);
+    get value(): Int8Array;
+    isValid(block: AttoBlock): boolean;
+    equals(other: Nullable<any>): boolean;
+    hashCode(): number;
+    toString(): string;
+    copy(value?: Int8Array): AttoWork;
+}
+export declare namespace AttoWork {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoWork;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                get SIZE(): number;
+                parse(value: string): AttoWork;
+                private constructor();
+            }
+        }
+    }
+}
+export declare function toHex(_this_: Int8Array): string;
+export declare function fromHexToByteArray(_this_: string): Int8Array;
+export declare class AccountUpdate {
+    constructor(account: AttoAccount, block: AttoBlock);
+    get account(): AttoAccount;
+    get block(): AttoBlock;
+    copy(account?: AttoAccount, block?: AttoBlock): AccountUpdate;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AccountUpdate {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AccountUpdate;
+    }
+}
+export declare function attoAccountOpen(representativeAddress: AttoAddress, receivable: AttoReceivable, timestamp?: Nullable<string>): AccountUpdate;
+export declare function attoAccountSend(account: AttoAccount, receiverAddress: AttoAddress, amount: AttoAmount, timestamp?: Nullable<string>): AccountUpdate;
+export declare function attoAccountReceive(account: AttoAccount, receivable: AttoReceivable, timestamp?: Nullable<string>): AccountUpdate;
+export declare function attoAccountChange(account: AttoAccount, representativeAddress: AttoAddress, timestamp?: Nullable<string>): AccountUpdate;
+export declare function toPublicKey(_this_: AttoPrivateKey): AttoPublicKey;
+export declare function toSeedAsync(_this_: AttoMnemonic, passphrase?: string): Promise<AttoSeed>;
+export declare class TimeDifferenceResponse {
+    constructor(clientInstant: AttoInstant, serverInstant: AttoInstant, differenceMillis: bigint);
+    get clientInstant(): AttoInstant;
+    get serverInstant(): AttoInstant;
+    get differenceMillis(): bigint;
+    copy(clientInstant?: AttoInstant, serverInstant?: AttoInstant, differenceMillis?: bigint): TimeDifferenceResponse;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace TimeDifferenceResponse {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => TimeDifferenceResponse;
+    }
+}
+export declare class AccountSearch {
+    constructor(addresses: any/* Collection<AttoAddress> */);
+    get addresses(): any/* Collection<AttoAddress> */;
+    copy(addresses?: any/* Collection<AttoAddress> */): AccountSearch;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AccountSearch {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AccountSearch;
+    }
+}
+export declare class AccountHeightSearch {
+    constructor(address: AttoAddress, fromHeight: AttoHeight, toHeight?: AttoHeight);
+    get address(): AttoAddress;
+    get fromHeight(): AttoHeight;
+    get toHeight(): AttoHeight;
+    copy(address?: AttoAddress, fromHeight?: AttoHeight, toHeight?: AttoHeight): AccountHeightSearch;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AccountHeightSearch {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AccountHeightSearch;
+    }
+}
+export declare class HeightSearch {
+    private constructor();
+    get search(): any/* Collection<AccountHeightSearch> */;
+    copy(search?: any/* Collection<AccountHeightSearch> */): HeightSearch;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace HeightSearch {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => HeightSearch;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                fromArray(search: Array<AccountHeightSearch>): HeightSearch;
+                private constructor();
+            }
+        }
+    }
+}
+export declare function receivableToJson(_this_: AttoReceivable): string;
+export declare function receivableFromJson(_this_: string): AttoReceivable;
+export declare function transactionToJson(_this_: AttoTransaction): string;
+export declare function transactionFromJson(_this_: string): AttoTransaction;
+export declare function blockToJson(_this_: AttoBlock): string;
+export declare function blockFromJson(_this_: string): AttoBlock;
+export declare function accountEntryToJson(_this_: AttoAccountEntry): string;
+export declare function accountEntryFromJson(_this_: string): AttoAccountEntry;
+export declare function fromByteArrayToTransactionJson(_this_: Int8Array): string;
+export declare function fromByteArrayToBlockJson(_this_: Int8Array): string;
+export declare class AttoAccountEntryMonitorAsyncBuilder {
+    constructor(nodeClient: AttoNodeClientAsync, accountMonitor: AttoAccountMonitorAsync);
+    heightProvider(value: (p0: AttoAddress) => Promise<AttoHeight>): AttoAccountEntryMonitorAsyncBuilder;
+    build(): AttoAccountEntryMonitorAsync;
+}
+export declare namespace AttoAccountEntryMonitorAsyncBuilder {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoAccountEntryMonitorAsyncBuilder;
+    }
+}
+export declare class AttoTransactionMonitorAsyncBuilder {
+    constructor(nodeClient: AttoNodeClientAsync, accountMonitor: AttoAccountMonitorAsync);
+    heightProvider(value: (p0: AttoAddress) => Promise<AttoHeight>): AttoTransactionMonitorAsyncBuilder;
+    build(): AttoTransactionMonitorAsync;
+}
+export declare namespace AttoTransactionMonitorAsyncBuilder {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoTransactionMonitorAsyncBuilder;
+    }
+}
+export declare class AttoNodeClientAsync /* implements AutoCloseable */ {
+    private constructor();
+    get client(): any/* AttoNodeClient */;
+    accountByPublicKey(publicKey: AttoPublicKey): Promise<Nullable<AttoAccount>>;
+    accountByAddresses(addresses: Array<AttoAddress>): Promise<Array<AttoAccount>>;
+    onAccountByPublicKey(publicKey: AttoPublicKey, onAccount: (p0: AttoAccount) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
+    onAccountByAddresses(addresses: Array<AttoAddress>, onAccount: (p0: AttoAccount) => void, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
+    onReceivableByPublicKey(publicKey: AttoPublicKey, minAmount: AttoAmount | undefined, onReceivable: (p0: AttoReceivable) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
+    onReceivableByAddresses(addresses: Array<AttoAddress>, minAmount: AttoAmount | undefined, onReceivable: (p0: AttoReceivable) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
+    accountEntry(hash: AttoHash): Promise<AttoAccountEntry>;
+    onAccountEntryByPublicKey(publicKey: AttoPublicKey, fromHeight: AttoHeight | undefined, toHeight: Nullable<AttoHeight> | undefined, onAccountEntry: (p0: AttoAccountEntry) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
+    onAccountEntryByHeightSearch(heightSearch: HeightSearch, onAccountEntry: (p0: AttoAccountEntry) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
+    transaction(hash: AttoHash): Promise<AttoTransaction>;
+    onTransactionByPublicKey(publicKey: AttoPublicKey, fromHeight: AttoHeight | undefined, toHeight: Nullable<AttoHeight> | undefined, onTransaction: (p0: AttoTransaction) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
+    onTransactionByHeightSearch(heightSearch: HeightSearch, onTransaction: (p0: AttoTransaction) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
+    now(): Promise<AttoInstant>;
+    publish(transaction: AttoTransaction): Promise<void>;
+}
+export declare namespace AttoNodeClientAsync {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoNodeClientAsync;
+    }
+}
+export declare class AttoAccountEntryMonitorAsync /* implements AutoCloseable */ {
+    private constructor();
+    get accountEntryMonitor(): any/* AttoAccountEntryMonitor */;
+    onAccountEntry(onAccountEntry: any /*Suspend functions are not supported*/, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => void): any/* AttoJob */;
+}
+export declare namespace AttoAccountEntryMonitorAsync {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoAccountEntryMonitorAsync;
+    }
+}
+export declare class AttoAccountMonitorAsync /* implements AutoCloseable */ {
+    private constructor();
+    get accountMonitor(): any/* AttoAccountMonitor */;
+    monitorCollection(addresses: any/* Collection<AttoAddress> */): Promise<void>;
+    monitorAddress(address: AttoAddress): Promise<void>;
+    getAccounts(): Promise<any/* Collection<AttoAccount> */>;
+    onReceivable(minAmount: AttoAmount | undefined, onReceivable: (p0: AttoReceivable) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
+}
+export declare namespace AttoAccountMonitorAsync {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoAccountMonitorAsync;
+    }
+}
+export declare class AttoAccountMonitorAsyncBuilder {
+    constructor(nodeClient: AttoNodeClientAsync);
+    build(): AttoAccountMonitorAsync;
+}
+export declare namespace AttoAccountMonitorAsyncBuilder {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoAccountMonitorAsyncBuilder;
+    }
+}
+export declare class AttoTransactionMonitorAsync /* implements AutoCloseable */ {
+    private constructor();
+    get transactionMonitor(): any/* AttoTransactionMonitor */;
+    onTransaction(onTransaction: any /*Suspend functions are not supported*/, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => void): any/* AttoJob */;
+}
+export declare namespace AttoTransactionMonitorAsync {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoTransactionMonitorAsync;
+    }
+}
+export declare class AttoWorkerAsync {
+    private constructor();
+    get worker(): any/* AttoWorker */;
+    workThreshold(threshold: bigint, target: any/* AttoWorkTarget */): Promise<AttoWork>;
+    workNetwork(network: AttoNetwork, timestamp: AttoInstant, target: any/* AttoWorkTarget */): Promise<AttoWork>;
+    workBlock(block: AttoBlock): Promise<AttoWork>;
+}
+export declare namespace AttoWorkerAsync {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoWorkerAsync;
+    }
+}
+export declare class AttoWalletAccount {
+    constructor(index: AttoKeyIndex, address: AttoAddress, account?: Nullable<AttoAccount>);
+    get index(): AttoKeyIndex;
+    get address(): AttoAddress;
+    get account(): Nullable<AttoAccount>;
+    set account(value: Nullable<AttoAccount>);
+}
+export declare namespace AttoWalletAccount {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoWalletAccount;
+    }
+}
+export declare class AttoWalletAsync {
+    private constructor();
+    openAccountCollection(indexes: Array<AttoKeyIndex>): Promise<Array<AttoWalletAccount>>;
+    openAccountRange(fromIndex: AttoKeyIndex, toIndex: AttoKeyIndex): Promise<Array<AttoWalletAccount>>;
+    openAccount(index: AttoKeyIndex): Promise<AttoWalletAccount>;
+    closeAccount(index: AttoKeyIndex): Promise<void>;
+    isOpenByIndex(index: AttoKeyIndex): Promise<boolean>;
+    isOpenByAddress(address: AttoAddress): Promise<boolean>;
+    getAccountByIndex(index: AttoKeyIndex): Promise<Nullable<AttoAccount>>;
+    getAccountByAddress(address: AttoAddress): Promise<Nullable<AttoAccount>>;
+    getAddress(index: AttoKeyIndex): Promise<AttoAddress>;
+    publish(index: AttoKeyIndex, block: AttoBlock): Promise<AttoTransaction>;
+    sendByIndex(index: AttoKeyIndex, receiverAddress: AttoAddress, amount: AttoAmount, timestamp?: Nullable<AttoInstant>): Promise<AttoTransaction>;
+    sendByAddress(address: AttoAddress, receiverAddress: AttoAddress, amount: AttoAmount, timestamp?: Nullable<AttoInstant>): Promise<AttoTransaction>;
+    receive(receivable: AttoReceivable, representativeAddress?: Nullable<AttoAddress>, timestamp?: Nullable<AttoInstant>): Promise<AttoTransaction>;
+    change(index: AttoKeyIndex, representativeAddress: AttoAddress, timestamp?: Nullable<AttoInstant>): Promise<AttoTransaction>;
+}
+export declare namespace AttoWalletAsync {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoWalletAsync;
+    }
+}
+export declare class AttoWalletAsyncBuilder {
+    constructor(clientAsync: AttoNodeClientAsync, workerAsync: AttoWorkerAsync);
+    signerProviderFunction(value: AttoSignerProvider): AttoWalletAsyncBuilder;
+    signerProviderSeed(value: AttoSeed): AttoWalletAsyncBuilder;
+    enableAutoReceiver(monitor: AttoAccountMonitorAsync, minAmount: AttoAmount | undefined, retryAfterSeconds: number, defaultRepresentativeAddressProvider: () => AttoAddress): AttoWalletAsyncBuilder;
+    build(): AttoWalletAsync;
+}
+export declare namespace AttoWalletAsyncBuilder {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoWalletAsyncBuilder;
+    }
+}
+export declare interface AttoSignerProvider {
+    get(index: AttoKeyIndex): Promise<AttoSigner>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.wallet.AttoSignerProvider": unique symbol;
+    };
+}
+/** @deprecated  */
+export declare const initHook: { get(): any; };
+export declare class AttoNodeClientAsyncBuilder {
+    constructor(url: string);
+    headers(value: KtMap<string, string>): AttoNodeClientAsyncBuilder;
+    header(name: string, value: string): AttoNodeClientAsyncBuilder;
+    build(): AttoNodeClientAsync;
+}
+export declare namespace AttoNodeClientAsyncBuilder {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoNodeClientAsyncBuilder;
+    }
+}
+export declare class AttoWorkerAsyncBuilder {
+    constructor(url: string);
+    headers(value: KtMap<string, string>): AttoWorkerAsyncBuilder;
+    header(name: string, value: string): AttoWorkerAsyncBuilder;
+    cached(value: boolean): AttoWorkerAsyncBuilder;
+    retryEvery(value: any/* Duration */): AttoWorkerAsyncBuilder;
+    retryEverySeconds(value: bigint): AttoWorkerAsyncBuilder;
+    build(): AttoWorkerAsync;
+}
+export declare namespace AttoWorkerAsyncBuilder {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoWorkerAsyncBuilder;
+    }
+}