@attocash/commons-js 6.3.2 → 6.6.0

package/README.md

@@ -0,0 +1,267 @@
+# @attocash/commons-js
+
+[![npm version](https://img.shields.io/npm/v/@attocash/commons-js.svg)](https://www.npmjs.com/package/@attocash/commons-js)
+[![license](https://img.shields.io/github/license/attocash/commons.svg)](https://github.com/attocash/commons/blob/main/LICENSE)
+
+JavaScript and TypeScript bindings for Atto, instant and feeless digital cash for everyday payments.
+
+`@attocash/commons-js` packages the Atto Commons protocol types and client helpers for JavaScript applications. Use it to work with Atto addresses, mnemonics, amounts, wallets, node clients, work servers, monitors, blocks, signatures, and transactions.
+
+## Install
+
+```sh
+npm install @attocash/commons-js
+```
+
+This package is published as ESM and includes TypeScript declarations.
+
+```js
+import { AttoAddress, AttoAmount, AttoUnit } from '@attocash/commons-js'
+```
+
+## Try It Live
+
+The [Atto interactive playground](https://atto.cash/docs/integration/advanced/interactive-playground) lets you experiment with `@attocash/commons-js` directly in the browser. It includes seed generation and public-key/address conversion examples.
+
+Do not use mnemonics, private keys, or addresses generated by a website for real funds. Treat the playground as an educational tool.
+
+## What You Can Build
+
+- Wallet flows: derive accounts, open accounts, send funds, receive pending funds, and change representatives.
+- Service integrations: connect to an Atto node and a Work Server from a backend or tool.
+- Monitoring: subscribe to account, transaction, receivable, and account-entry updates.
+- Protocol tooling: parse and format addresses, amounts, blocks, transactions, hashes, and JSON payloads.
+- Tests and demos: pair with `@attocash/commons-test` to run local mock node and worker services.
+
+## Requirements
+
+- Node.js 18 or newer is recommended.
+- Use ESM imports. In Node.js files, use `.mjs` or set `"type": "module"`.
+- For live transactions, provide access to an Atto node and a Work Server.
+- Keep production mnemonics and private keys outside browser code, logs, source control, and analytics.
+
+Node.js examples that use the remote node/worker clients should expose `require` for the underlying runtime:
+
+```js
+import { createRequire } from 'node:module'
+
+globalThis.require = createRequire(import.meta.url)
+```
+
+## Generate an Account
+
+```js
+import {
+  AttoAddress,
+  AttoAlgorithm,
+  AttoMnemonic,
+  toAttoIndex,
+  toPrivateKey,
+  toPublicKey,
+  toSeedAsync,
+} from '@attocash/commons-js'
+
+const mnemonic = AttoMnemonic.generate()
+const seed = await toSeedAsync(mnemonic)
+
+const accountIndex = toAttoIndex(0)
+const privateKey = toPrivateKey(seed, accountIndex)
+const publicKey = toPublicKey(privateKey)
+const address = new AttoAddress(AttoAlgorithm.V1, publicKey)
+
+console.log(address.toString())
+```
+
+Store the mnemonic securely. Anyone with the mnemonic can derive the private keys for the wallet.
+
+## Connect to a Node and Work Server
+
+```js
+import { createRequire } from 'node:module'
+import {
+  AttoNodeClientAsyncBuilder,
+  AttoWorkerAsyncBuilder,
+} from '@attocash/commons-js'
+
+globalThis.require = createRequire(import.meta.url)
+
+const nodeClient = new AttoNodeClientAsyncBuilder('http://localhost:8080').build()
+const worker = new AttoWorkerAsyncBuilder('http://localhost:8085').build()
+```
+
+The node provides ledger data and publishes transactions. The Work Server computes the small proof-of-work required for spam prevention.
+
+## Open an Account and Send ATTO
+
+```js
+import { createRequire } from 'node:module'
+import {
+  AttoAddress,
+  AttoAmount,
+  AttoMnemonic,
+  AttoNodeClientAsyncBuilder,
+  AttoUnit,
+  AttoWalletAsyncBuilder,
+  AttoWorkerAsyncBuilder,
+  toAttoIndex,
+  toSeedAsync,
+} from '@attocash/commons-js'
+
+globalThis.require = createRequire(import.meta.url)
+
+const mnemonic = AttoMnemonic.fromPhrase(process.env.ATTO_MNEMONIC)
+const seed = await toSeedAsync(mnemonic)
+
+const nodeClient = new AttoNodeClientAsyncBuilder(process.env.ATTO_NODE_URL).build()
+const worker = new AttoWorkerAsyncBuilder(process.env.ATTO_WORKER_URL).build()
+
+const wallet = new AttoWalletAsyncBuilder(nodeClient, worker)
+  .signerProviderSeed(seed)
+  .build()
+
+const senderIndex = toAttoIndex(0)
+await wallet.openAccount(senderIndex)
+
+const receiver = AttoAddress.parse(process.env.ATTO_RECEIVER_ADDRESS)
+const amount = AttoAmount.from(AttoUnit.ATTO, '1')
+
+const transaction = await wallet.sendByIndex(senderIndex, receiver, amount, null)
+
+console.log(`Published ${transaction.hash}`)
+```
+
+Atto transfers are asynchronous. A sender publishes a send block, and the receiver claims the pending receivable with an open or receive block.
+
+## Enable Auto Receive
+
+```js
+import {
+  AttoAccountMonitorAsyncBuilder,
+  AttoAddress,
+  AttoWalletAsyncBuilder,
+  toAttoIndex,
+} from '@attocash/commons-js'
+
+const accountMonitor = new AttoAccountMonitorAsyncBuilder(nodeClient).build()
+const representative = AttoAddress.parse(process.env.ATTO_REPRESENTATIVE_ADDRESS)
+
+const wallet = new AttoWalletAsyncBuilder(nodeClient, worker)
+  .signerProviderSeed(seed)
+  .enableAutoReceiver(
+    accountMonitor,
+    undefined,
+    10,
+    () => representative,
+  )
+  .build()
+
+const address = await wallet.getAddress(toAttoIndex(0))
+await accountMonitor.monitorAddress(address)
+```
+
+Passing `undefined` as the minimum amount receives every pending receivable. Use an `AttoAmount` value if your application should ignore tiny receivables.
+
+## Monitor Transactions
+
+```js
+import {
+  AttoAddress,
+  AttoAccountMonitorAsyncBuilder,
+  AttoTransactionMonitorAsyncBuilder,
+  transactionToJson,
+} from '@attocash/commons-js'
+
+const accountMonitor = new AttoAccountMonitorAsyncBuilder(nodeClient).build()
+const transactionMonitor = new AttoTransactionMonitorAsyncBuilder(nodeClient, accountMonitor).build()
+
+transactionMonitor.onTransaction(
+  async (transaction) => {
+    console.log(transactionToJson(transaction))
+  },
+  async (error) => {
+    if (error) {
+      console.error(error)
+    }
+  },
+)
+
+await accountMonitor.monitorAddress(AttoAddress.parse(process.env.ATTO_ADDRESS))
+```
+
+Use account-entry monitors when you need ledger entries rather than full transactions.
+
+## Build, Sign, Work, and Publish Manually
+
+The wallet helper is the usual integration path, but lower-level APIs are available when you need direct control over a transaction.
+
+```js
+import {
+  AttoAddress,
+  AttoAmount,
+  AttoTransaction,
+  AttoUnit,
+  attoAccountSend,
+  privateKeyToSigner,
+} from '@attocash/commons-js'
+
+const signer = privateKeyToSigner(privateKey)
+const account = await nodeClient.accountByPublicKey(signer.publicKey)
+
+if (!account) {
+  throw new Error('Sender account is not open')
+}
+
+const update = attoAccountSend(
+  account,
+  AttoAddress.parse(process.env.ATTO_RECEIVER_ADDRESS),
+  AttoAmount.from(AttoUnit.ATTO, '1'),
+  null,
+)
+
+const signature = await signer.signBlock(update.block)
+const work = await worker.workBlock(update.block)
+const transaction = new AttoTransaction(update.block, signature, work)
+
+await nodeClient.publish(transaction)
+```
+
+This is useful for signing services, audits, custom queues, and offline-signing flows.
+
+## Local Mock Example
+
+For tests and demos, install the companion test package:
+
+```sh
+npm install --save-dev @attocash/commons-test
+```
+
+The repository includes a runnable JavaScript example that starts mock node and worker services, creates a wallet, opens accounts, sends transactions, and listens to monitors:
+
+- [examples/js-client](https://github.com/attocash/commons/tree/main/examples/js-client)
+
+## API Areas
+
+| Area | Common exports |
+| --- | --- |
+| Keys and addresses | `AttoMnemonic`, `toSeedAsync`, `toPrivateKey`, `toPublicKey`, `AttoAddress`, `AttoPublicKey` |
+| Amounts | `AttoAmount`, `AttoUnit` |
+| Node access | `AttoNodeClientAsyncBuilder` |
+| Work server | `AttoWorkerAsyncBuilder` |
+| Wallets | `AttoWalletAsyncBuilder`, `sendByIndex`, `receive`, `change` |
+| Monitors | `AttoAccountMonitorAsyncBuilder`, `AttoTransactionMonitorAsyncBuilder`, `AttoAccountEntryMonitorAsyncBuilder` |
+| Serialization | `transactionToJson`, `transactionFromJson`, `blockToJson`, `blockFromJson`, `fromHexToByteArray`, `toHex` |
+| Low-level transactions | `attoAccountSend`, `AttoTransaction`, `privateKeyToSigner` |
+
+## Documentation
+
+- [Atto documentation](https://atto.cash/docs)
+- [Integration overview](https://atto.cash/docs/integration)
+- [Node integration](https://atto.cash/docs/integration/node)
+- [Work Server integration](https://atto.cash/docs/integration/work-server)
+- [Wallet Server integration](https://atto.cash/docs/integration/wallet-server)
+- [Offline signing with Atto Commons](https://atto.cash/docs/integration/advanced/offline-signing-with-atto-commons)
+- [Protocol-level offline-signing reference](https://atto.cash/docs/integration/advanced/protocol-offline-signing-reference)
+
+## License
+
+[BSD 3-Clause](https://github.com/attocash/commons/blob/main/LICENSE)

package/commons-commons-js.d.mts

@@ -27,7 +27,7 @@ export declare class AttoAccount implements HeightSupport, AddressSupport {
     toString(): string;
     hashCode(): number;
     equals(other: Nullable<any>): boolean;
-    readonly __doNotUseOrImplementIt: HeightSupport["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"];
+    readonly __doNotUseOrImplementIt: AddressSupport["__doNotUseOrImplementIt"] & HeightSupport["__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 */
@@ -64,7 +64,7 @@ export declare class AttoAccountEntry implements HeightSupport, AddressSupport {
     toString(): string;
     hashCode(): number;
     equals(other: Nullable<any>): boolean;
-    readonly __doNotUseOrImplementIt: HeightSupport["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"];
+    readonly __doNotUseOrImplementIt: AddressSupport["__doNotUseOrImplementIt"] & HeightSupport["__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 */
@@ -115,14 +115,14 @@ export declare abstract class AttoAlgorithm {
         get name(): "V1";
         get ordinal(): 0;
     };
+    static values(): [typeof AttoAlgorithm.V1];
+    static valueOf(value: string): AttoAlgorithm;
     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 */
@@ -151,11 +151,11 @@ export declare abstract class AttoUnit {
         get name(): "RAW";
         get ordinal(): 1;
     };
+    static values(): [typeof AttoUnit.ATTO, typeof AttoUnit.RAW];
+    static valueOf(value: string): AttoUnit;
     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 */
@@ -216,10 +216,10 @@ export declare abstract class AttoBlockType {
         get name(): "CHANGE";
         get ordinal(): 4;
     };
+    static values(): [typeof AttoBlockType.UNKNOWN, typeof AttoBlockType.OPEN, typeof AttoBlockType.RECEIVE, typeof AttoBlockType.SEND, typeof AttoBlockType.CHANGE];
+    static valueOf(value: string): AttoBlockType;
     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 */
@@ -264,7 +264,7 @@ export declare interface AttoBlock extends HeightSupport, AddressSupport, AttoHa
     isValid(): boolean;
     readonly __doNotUseOrImplementIt: {
         readonly "cash.atto.commons.AttoBlock": unique symbol;
-    } & HeightSupport["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"] & AttoHashable["__doNotUseOrImplementIt"] & AttoSerializable["__doNotUseOrImplementIt"];
+    } & AttoSerializable["__doNotUseOrImplementIt"] & AttoHashable["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"] & HeightSupport["__doNotUseOrImplementIt"];
 }
 export declare namespace AttoBlock {
     abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
@@ -324,7 +324,7 @@ export declare class AttoSendBlock implements AttoBlock, PreviousSupport {
     equals(other: Nullable<any>): boolean;
     isValid(): boolean;
     toByteArray(): Int8Array;
-    readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"];
+    readonly __doNotUseOrImplementIt: PreviousSupport["__doNotUseOrImplementIt"] & AttoBlock["__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 */
@@ -365,7 +365,7 @@ export declare class AttoReceiveBlock implements AttoBlock, PreviousSupport, Rec
     validate(): AttoValidation;
     isValid(): boolean;
     toByteArray(): Int8Array;
-    readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"] & ReceiveSupport["__doNotUseOrImplementIt"];
+    readonly __doNotUseOrImplementIt: ReceiveSupport["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"] & AttoBlock["__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 */
@@ -408,7 +408,7 @@ export declare class AttoOpenBlock implements AttoBlock, ReceiveSupport, Represe
     validate(): AttoValidation;
     isValid(): boolean;
     toByteArray(): Int8Array;
-    readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & ReceiveSupport["__doNotUseOrImplementIt"] & RepresentativeSupport["__doNotUseOrImplementIt"];
+    readonly __doNotUseOrImplementIt: RepresentativeSupport["__doNotUseOrImplementIt"] & ReceiveSupport["__doNotUseOrImplementIt"] & AttoBlock["__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 */
@@ -450,7 +450,7 @@ export declare class AttoChangeBlock implements AttoBlock, PreviousSupport, Repr
     validate(): AttoValidation;
     isValid(): boolean;
     toByteArray(): Int8Array;
-    readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"] & RepresentativeSupport["__doNotUseOrImplementIt"];
+    readonly __doNotUseOrImplementIt: RepresentativeSupport["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"] & AttoBlock["__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 */
@@ -655,12 +655,12 @@ export declare abstract class AttoNetwork {
         get name(): "UNKNOWN";
         get ordinal(): 4;
     };
+    static values(): [typeof AttoNetwork.LIVE, typeof AttoNetwork.BETA, typeof AttoNetwork.DEV, typeof AttoNetwork.LOCAL, typeof AttoNetwork.UNKNOWN];
+    static valueOf(value: string): AttoNetwork;
     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 */
@@ -844,7 +844,7 @@ export declare class AttoTransaction implements HeightSupport, AddressSupport, A
     hashCode(): number;
     equals(other: Nullable<any>): boolean;
     toByteArray(): Int8Array;
-    readonly __doNotUseOrImplementIt: HeightSupport["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"] & AttoSerializable["__doNotUseOrImplementIt"];
+    readonly __doNotUseOrImplementIt: AttoSerializable["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"] & HeightSupport["__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 */
@@ -901,7 +901,7 @@ export declare class AttoVote implements AttoHashable, AttoSerializable {
     hashCode(): number;
     equals(other: Nullable<any>): boolean;
     toByteArray(): Int8Array;
-    readonly __doNotUseOrImplementIt: AttoHashable["__doNotUseOrImplementIt"] & AttoSerializable["__doNotUseOrImplementIt"];
+    readonly __doNotUseOrImplementIt: AttoSerializable["__doNotUseOrImplementIt"] & AttoHashable["__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 */
@@ -1083,18 +1083,24 @@ export declare class AttoNodeClientAsync /* implements AutoCloseable */ {
     get client(): any/* AttoNodeClient */;
     accountByPublicKey(publicKey: AttoPublicKey): Promise<Nullable<AttoAccount>>;
     accountByAddresses(addresses: Array<AttoAddress>): Promise<Array<AttoAccount>>;
+    onAccountAll(onAccount: (p0: AttoAccount) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
     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>;
+    onAccountEntryAll(onAccountEntry: (p0: AttoAccountEntry) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
+    onAccountEntryByHash(hash: AttoHash, onAccountEntry: (p0: AttoAccountEntry) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
     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>;
+    onTransactionAll(onTransaction: (p0: AttoTransaction) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
+    onTransactionByHash(hash: AttoHash, onTransaction: (p0: AttoTransaction) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
     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>;
+    voterWeight(address: AttoAddress): Promise<any/* AttoVoterWeight */>;
 }
 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 */
@@ -1119,6 +1125,7 @@ export declare class AttoAccountMonitorAsync /* implements AutoCloseable */ {
     monitorAddressArray(addresses: Array<AttoAddress>): Promise<void>;
     monitorAddress(address: AttoAddress): Promise<void>;
     getAccounts(): Promise<Array<AttoAccount>>;
+    onAccount(onAccount: (p0: AttoAccount) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
     onReceivable(minAmount: AttoAmount | undefined, onReceivable: (p0: AttoReceivable) => any, onCancel: (p0: Nullable<Error>/* Nullable<Exception> */) => any): any/* AttoJob */;
 }
 export declare namespace AttoAccountMonitorAsync {
@@ -1217,7 +1224,9 @@ export declare interface AttoSignerProvider {
     };
 }
 /** @deprecated  */
-export declare const initHook: { get(): any; };
+export declare const initHook: {
+    get(): any;
+};
 export declare class AttoNodeClientAsyncBuilder {
     constructor(url: string);
     headers(value: KtMap<string, string>): AttoNodeClientAsyncBuilder;