@attocash/commons-js 5.0.0

package/Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/serializers/LocalTimeSerializers.mjs

@@ -0,0 +1,53 @@
+import { STRING_getInstance2ou4lro9xn2qn as STRING_getInstance } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/descriptors/SerialKinds.mjs';
+import { PrimitiveSerialDescriptor3egfp53lutxj2 as PrimitiveSerialDescriptor } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/descriptors/SerialDescriptors.mjs';
+import {
+  Companion_getInstance3vhybkmm49bju as Companion_getInstance,
+  LocalTime22kisvxz6f9p4 as LocalTime,
+} from '../LocalTime.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { KSerializerzf77vz1967fq as KSerializer } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.mjs';
+import { initMetadataForObject1cxne3s9w65el as initMetadataForObject } from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var LocalTimeIso8601SerializerClass;
+function LocalTimeIso8601Serializer() {
+  if (LocalTimeIso8601SerializerClass === VOID) {
+    class $ {
+      constructor() {
+        LocalTimeIso8601Serializer_instance = this;
+        this.t1v_1 = PrimitiveSerialDescriptor('kotlinx.datetime.LocalTime', STRING_getInstance());
+      }
+      xs() {
+        return this.t1v_1;
+      }
+      zs(decoder) {
+        return Companion_getInstance().w1v(decoder.fx());
+      }
+      x1v(encoder, value) {
+        encoder.oy(value.toString());
+      }
+      ys(encoder, value) {
+        return this.x1v(encoder, value instanceof LocalTime() ? value : THROW_CCE());
+      }
+    }
+    initMetadataForObject($, 'LocalTimeIso8601Serializer', VOID, VOID, [KSerializer()]);
+    LocalTimeIso8601SerializerClass = $;
+  }
+  return LocalTimeIso8601SerializerClass;
+}
+var LocalTimeIso8601Serializer_instance;
+function LocalTimeIso8601Serializer_getInstance() {
+  if (LocalTimeIso8601Serializer_instance === VOID)
+    new (LocalTimeIso8601Serializer())();
+  return LocalTimeIso8601Serializer_instance;
+}
+//region block: exports
+export {
+  LocalTimeIso8601Serializer_getInstance as LocalTimeIso8601Serializer_getInstance1gy7xllc2odvq,
+};
+//endregion
+
+//# sourceMappingURL=LocalTimeSerializers.mjs.map

package/Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/serializers/LocalTimeSerializers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../opt/buildAgent/work/8ebe0a8279b7bad8/core/common/src/serializers/LocalTimeSerializers.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-descriptor>","deserialize","decoder","serialize","encoder","value"],"mappings":";;;;;;;;;;;;;;;;;;;;QAuBQ,uCAA2B,4BAA3B,uB;;QADKA,CAAAA,EAAA;A,QAAA,iB;MACuE,C;QAEvEC,CAAgBC,OAAhBD,EACL;A,QAAuC,OAA7B,4BAAM,OAAQ,KAAd,C;MAA4B,C;SAEjCE,CAAcC,O,EAAkBC,KAAhCF,EAAkD;A,QACvD,OAAQ,IAAa,KAAM,WAAnB,C;MACZ,C;SAqDigHC,O,EAAkBC,K;;;;;;;;;;;;;;;;;;;"}

package/Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/serializers/TimeZoneSerializers.mjs

@@ -0,0 +1,130 @@
+import { STRING_getInstance2ou4lro9xn2qn as STRING_getInstance } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/descriptors/SerialKinds.mjs';
+import { PrimitiveSerialDescriptor3egfp53lutxj2 as PrimitiveSerialDescriptor } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/descriptors/SerialDescriptors.mjs';
+import {
+  Companion_getInstance3p275ab8rhrps as Companion_getInstance,
+  UtcOffset17lxgyhnn4rny as UtcOffset,
+} from '../UtcOffset.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { KSerializerzf77vz1967fq as KSerializer } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.mjs';
+import { initMetadataForObject1cxne3s9w65el as initMetadataForObject } from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  Companion_getInstance3qu5ydsg8audm as Companion_getInstance_0,
+  TimeZone3oibfp0mqo4lg as TimeZone,
+  FixedOffsetTimeZone3oldrgkltiv4z as FixedOffsetTimeZone,
+} from '../TimeZone.mjs';
+import { SerializationExceptioneqrdve3ts2n9 as SerializationException } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/SerializationExceptions.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var UtcOffsetSerializerClass;
+function UtcOffsetSerializer() {
+  if (UtcOffsetSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        UtcOffsetSerializer_instance = this;
+        this.y1v_1 = PrimitiveSerialDescriptor('kotlinx.datetime.UtcOffset', STRING_getInstance());
+      }
+      xs() {
+        return this.y1v_1;
+      }
+      zs(decoder) {
+        return Companion_getInstance().a1w(decoder.fx());
+      }
+      b1w(encoder, value) {
+        encoder.oy(value.toString());
+      }
+      ys(encoder, value) {
+        return this.b1w(encoder, value instanceof UtcOffset() ? value : THROW_CCE());
+      }
+    }
+    initMetadataForObject($, 'UtcOffsetSerializer', VOID, VOID, [KSerializer()]);
+    UtcOffsetSerializerClass = $;
+  }
+  return UtcOffsetSerializerClass;
+}
+var UtcOffsetSerializer_instance;
+function UtcOffsetSerializer_getInstance() {
+  if (UtcOffsetSerializer_instance === VOID)
+    new (UtcOffsetSerializer())();
+  return UtcOffsetSerializer_instance;
+}
+var TimeZoneSerializerClass;
+function TimeZoneSerializer() {
+  if (TimeZoneSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        TimeZoneSerializer_instance = this;
+        this.c1w_1 = PrimitiveSerialDescriptor('kotlinx.datetime.TimeZone', STRING_getInstance());
+      }
+      xs() {
+        return this.c1w_1;
+      }
+      zs(decoder) {
+        return Companion_getInstance_0().e1w(decoder.fx());
+      }
+      f1w(encoder, value) {
+        encoder.oy(value.h1w());
+      }
+      ys(encoder, value) {
+        return this.f1w(encoder, value instanceof TimeZone() ? value : THROW_CCE());
+      }
+    }
+    initMetadataForObject($, 'TimeZoneSerializer', VOID, VOID, [KSerializer()]);
+    TimeZoneSerializerClass = $;
+  }
+  return TimeZoneSerializerClass;
+}
+var TimeZoneSerializer_instance;
+function TimeZoneSerializer_getInstance() {
+  if (TimeZoneSerializer_instance === VOID)
+    new (TimeZoneSerializer())();
+  return TimeZoneSerializer_instance;
+}
+var FixedOffsetTimeZoneSerializerClass;
+function FixedOffsetTimeZoneSerializer() {
+  if (FixedOffsetTimeZoneSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        FixedOffsetTimeZoneSerializer_instance = this;
+        this.i1w_1 = PrimitiveSerialDescriptor('kotlinx.datetime.FixedOffsetTimeZone', STRING_getInstance());
+      }
+      xs() {
+        return this.i1w_1;
+      }
+      zs(decoder) {
+        var zone = Companion_getInstance_0().e1w(decoder.fx());
+        if (zone instanceof FixedOffsetTimeZone()) {
+          return zone;
+        } else {
+          throw SerializationException().nu("Timezone identifier '" + zone.toString() + "' does not correspond to a fixed-offset timezone");
+        }
+      }
+      j1w(encoder, value) {
+        encoder.oy(value.h1w());
+      }
+      ys(encoder, value) {
+        return this.j1w(encoder, value instanceof FixedOffsetTimeZone() ? value : THROW_CCE());
+      }
+    }
+    initMetadataForObject($, 'FixedOffsetTimeZoneSerializer', VOID, VOID, [KSerializer()]);
+    FixedOffsetTimeZoneSerializerClass = $;
+  }
+  return FixedOffsetTimeZoneSerializerClass;
+}
+var FixedOffsetTimeZoneSerializer_instance;
+function FixedOffsetTimeZoneSerializer_getInstance() {
+  if (FixedOffsetTimeZoneSerializer_instance === VOID)
+    new (FixedOffsetTimeZoneSerializer())();
+  return FixedOffsetTimeZoneSerializer_instance;
+}
+//region block: exports
+export {
+  FixedOffsetTimeZoneSerializer_getInstance as FixedOffsetTimeZoneSerializer_getInstance1l46ueoee8ix3,
+  TimeZoneSerializer_getInstance as TimeZoneSerializer_getInstanceqa9aveo7y5x8,
+  UtcOffsetSerializer_getInstance as UtcOffsetSerializer_getInstancehfvjgq5w8o12,
+};
+//endregion
+
+//# sourceMappingURL=TimeZoneSerializers.mjs.map

package/Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/serializers/TimeZoneSerializers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../opt/buildAgent/work/8ebe0a8279b7bad8/core/common/src/serializers/TimeZoneSerializers.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-descriptor>","deserialize","decoder","serialize","encoder","value","zone"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;QAiEgD,uCAA2B,4BAA3B,uB;;QAAnCA,CAAAA,EAAA;A,QAAA,iB;MAA+G,C;QAE/GC,CAAgBC,OAAhBD,EAA6C;A,QAClD,OAAiB,4BAAM,OAAQ,KAAd,C;MACrB,C;SAESE,CAAcC,O,EAAkBC,KAAhCF,EAAkD;A,QACvD,OAAQ,IAAa,KAAM,WAAnB,C;MACZ,C;SAG64IC,O,EAAkBC,K;;;;;;;;;;;;;;;;;;;;;QAvDn3I,uCAA2B,2BAA3B,uB;;QAAnCL,CAAAA,EAAA;A,QAAA,iB;MAA8G,C;QAE9GC,CAAgBC,OAAhBD,EAA8C;A,QAAmC,OAA1B,8BAAG,OAAQ,KAAX,C;MAAyB,C;SAEhFE,CAAcC,O,EAAkBC,KAAhCF,EAAiD;A,QACtD,OAAQ,IAAa,KAAM,MAAnB,C;MACZ,C;SAiD64IC,O,EAAkBC,K;;;;;;;;;;;;;;;;;;;;;QAtCn3I,uCAA2B,sCAA3B,uB;;QAAnCL,CAAAA,EAAA;A,QAAA,iB;MAAyH,C;QAEzHC,CAAgBC,OAAhBD,EAAuD;A,YAC5DK,OAAoB,8BAAG,OAAQ,KAAX,C;QACpB,IAAI,IAAJ,kC,CAAiC;A,UAC7B,OAAO,I;QACX,C;UACI,kCAA8B,uBAA9B,GAAoD,IAApD,cAAwD,kDAAxD,C;;MAER,C;SAESH,CAAcC,O,EAAkBC,KAAhCF,EAA4D;A,QACjE,OAAQ,IAAa,KAAM,MAAnB,C;MACZ,C;SAyB64IC,O,EAAkBC,K;;;;;;;;;;;;;;;;;;;"}

package/commons-commons-core/cash/atto/commons/AccountUpdate.js.export.d.ts

@@ -0,0 +1,19 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+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;
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace AccountUpdate.$metadata$ {
+    const constructor: abstract new () => AccountUpdate;
+}
+export declare function attoAccountOpen(network: AttoNetwork, 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;

package/commons-commons-core/cash/atto/commons/AccountUpdate.js.export.mjs

@@ -0,0 +1,23 @@
+import {
+  AccountUpdate3m5ii90g53dk0 as AccountUpdate,
+  attoAccountOpen3t8hvxlhl88n9 as attoAccountOpen,
+  attoAccountSend10xw3fd7hv66q as attoAccountSend,
+  attoAccountReceive1u9d6blqhaze9 as attoAccountReceive,
+  attoAccountChange3bznxcqvojj77 as attoAccountChange,
+} from './AccountUpdate.js.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+var AccountUpdate_0 = AccountUpdate();
+export {
+  AccountUpdate_0 as AccountUpdate,
+  attoAccountOpen as attoAccountOpen,
+  attoAccountSend as attoAccountSend,
+  attoAccountReceive as attoAccountReceive,
+  attoAccountChange as attoAccountChange,
+};
+//endregion
+
+//# sourceMappingURL=AccountUpdate.js.export.mjs.map

package/commons-commons-core/cash/atto/commons/AccountUpdate.js.export.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}

package/commons-commons-core/cash/atto/commons/AccountUpdate.js.mjs

@@ -0,0 +1,109 @@
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  toString1pkumu07cwy4m as toString,
+  hashCodeq5arwsb9dgti as hashCode,
+  equals2au1ep9vhcato as equals,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { System_instance3dr57gee6r420 as System_instance } from '../../../../Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/Clock.mjs';
+import { Companion_getInstance3vjikuur3h0k4 as Companion_getInstance } from '../../../../Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/Instant.mjs';
+import { Companion_getInstance1zxsxskq6zbhe as Companion_getInstance_0 } from './AttoAccount.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+var AccountUpdateClass;
+function AccountUpdate() {
+  if (AccountUpdateClass === VOID) {
+    class $ {
+      constructor(account, block) {
+        this.account = account;
+        this.block = block;
+      }
+      b35() {
+        return this.account;
+      }
+      f34() {
+        return this.block;
+      }
+      gl() {
+        return this.account;
+      }
+      hl() {
+        return this.block;
+      }
+      c35(account, block) {
+        return new (AccountUpdate())(account, block);
+      }
+      copy(account, block, $super) {
+        account = account === VOID ? this.account : account;
+        block = block === VOID ? this.block : block;
+        return $super === VOID ? this.c35(account, block) : $super.c35.call(this, account, block);
+      }
+      toString() {
+        return 'AccountUpdate(account=' + this.account.toString() + ', block=' + toString(this.block) + ')';
+      }
+      hashCode() {
+        var result = this.account.hashCode();
+        result = imul(result, 31) + hashCode(this.block) | 0;
+        return result;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof AccountUpdate()))
+          return false;
+        var tmp0_other_with_cast = other instanceof AccountUpdate() ? other : THROW_CCE();
+        if (!this.account.equals(tmp0_other_with_cast.account))
+          return false;
+        if (!equals(this.block, tmp0_other_with_cast.block))
+          return false;
+        return true;
+      }
+    }
+    initMetadataForClass($, 'AccountUpdate');
+    AccountUpdateClass = $;
+  }
+  return AccountUpdateClass;
+}
+function toInstant(_this__u8e3s4) {
+  if (_this__u8e3s4 == null)
+    return System_instance.i1e();
+  return Companion_getInstance().h1v(_this__u8e3s4);
+}
+function toAccountUpdate(_this__u8e3s4) {
+  return new (AccountUpdate())(_this__u8e3s4.fl_1, _this__u8e3s4.el_1);
+}
+function attoAccountOpen(network, representativeAddress, receivable, timestamp) {
+  timestamp = timestamp === VOID ? null : timestamp;
+  var update = Companion_getInstance_0().s2u(representativeAddress.algorithm, representativeAddress.publicKey, receivable, network, toInstant(timestamp));
+  return toAccountUpdate(update);
+}
+function attoAccountSend(account, receiverAddress, amount, timestamp) {
+  timestamp = timestamp === VOID ? null : timestamp;
+  var update = account.c2w(receiverAddress.algorithm, receiverAddress.publicKey, amount, toInstant(timestamp));
+  return toAccountUpdate(update);
+}
+function attoAccountReceive(account, receivable, timestamp) {
+  timestamp = timestamp === VOID ? null : timestamp;
+  var update = account.d2w(receivable, toInstant(timestamp));
+  return toAccountUpdate(update);
+}
+function attoAccountChange(account, representativeAddress, timestamp) {
+  timestamp = timestamp === VOID ? null : timestamp;
+  var update = account.e2w(representativeAddress.algorithm, representativeAddress.publicKey, toInstant(timestamp));
+  return toAccountUpdate(update);
+}
+//region block: exports
+export {
+  AccountUpdate as AccountUpdate3m5ii90g53dk0,
+  attoAccountChange as attoAccountChange3bznxcqvojj77,
+  attoAccountOpen as attoAccountOpen3t8hvxlhl88n9,
+  attoAccountReceive as attoAccountReceive1u9d6blqhaze9,
+  attoAccountSend as attoAccountSend10xw3fd7hv66q,
+};
+//endregion
+
+//# sourceMappingURL=AccountUpdate.js.mjs.map

package/commons-commons-core/cash/atto/commons/AccountUpdate.js.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/jsMain/kotlin/cash/atto/commons/AccountUpdate.js.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["account","block","<get-account>","<get-block>","result","toInstant","<this>","toAccountUpdate","attoAccountOpen","network","representativeAddress","receivable","timestamp","update","attoAccountSend","receiverAddress","amount","attoAccountReceive","attoAccountChange"],"mappings":";;;;;;;;;;;;;;;;;;;;kBASIA,O,EACAC,K;QADA,sB;QACA,kB;;SADAC,CAAAA,EAAA;A,QAAA,mB;MAAuB,C;SACvBC,CAAAA,EAAA;A,QAAA,iB;MAAmB,C;WAVvB;A,QAAA,mB;MAAA,C;WAAA;A,QAAA,iB;MAAA,C;0BAAA;A,QAAA,4C;MAAA,C;;qCAAA,I,CAAA,O;iCAAA,I,CAAA,K;;;iBAAA;A,QAAA,mG;MAAA,C;iBAAA;A,YAAAC,gC;QAAA,oD;QAAA,a;MAAA,C;oBAAA;A,QAAA,mB;UAAA,W;QAAA,wC;UAAA,Y;YAAA,6E;QAAA,uD;UAAA,Y;QAAA,oD;UAAA,Y;QAAA,W;MAAA,C;;;;;;;kBAaAC,CAAYC,aAAZD,EAAyC;A,EACjC,qBAAQ,IAAR,C;IAAc,OAAoB,qB;EACtC,OAAe,4BAAM,aAAN,C;AACnB,C;wBAEAE,CAAYD,aAAZC,EAA0E;A,EACtE,6BAAqB,aAArB,CAAqB,IAArB,EAA6B,aAA7B,CAA6B,IAA7B,C;AACJ,C;wBAEAC,CACIC,O,EACAC,qB,EACAC,U,EACAC,SAJJJ,EAKiB;A,mCADQ,I;MAErBK,SACgB,8BACR,qBADQ,CACc,SADd,EAER,qBAFQ,CAEc,SAFd,EAGR,UAHQ,EAIR,OAJQ,EAKE,UAAV,SAAU,CALF,C;EAOhB,OAAc,gBAAP,MAAO,C;AAClB,C;wBAEAC,CACId,O,EACAe,e,EACAC,M,EACAJ,SAJJE,EAKiB;A,mCADQ,I;MAErBD,SAAa,OAAQ,KAAK,eAAL,CAAqB,SAArB,EAAgC,eAAhC,CAAgD,SAAhD,EAA2D,MAA3D,EAA6E,UAAV,SAAU,CAA7E,C;EACrB,OAAc,gBAAP,MAAO,C;AAClB,C;2BAEAI,CACIjB,O,EACAW,U,EACAC,SAHJK,EAIiB;A,mCADQ,I;MAErBJ,SAAa,OAAQ,KAAQ,UAAR,EAA8B,UAAV,SAAU,CAA9B,C;EACrB,OAAc,gBAAP,MAAO,C;AAClB,C;0BAEAK,CACIlB,O,EACAU,qB,EACAE,SAHJM,EAIiB;A,mCADQ,I;MAErBL,SAAa,OAAQ,KAAO,qBAAP,CAA6B,SAA7B,EAAwC,qBAAxC,CAA8D,SAA9D,EAAmF,UAAV,SAAU,CAAnF,C;EACrB,OAAc,gBAAP,MAAO,C;AAClB,C;;;;;"}

package/commons-commons-core/cash/atto/commons/AttoAccount.export.d.ts

@@ -0,0 +1,41 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare class AttoAccount implements HeightSupport {
+    constructor(publicKey: AttoPublicKey, network: AttoNetwork, version: AttoVersion, algorithm: AttoAlgorithm, height: AttoHeight, balance: AttoAmount, lastTransactionHash: AttoHash, lastTransactionTimestamp: any/* Instant */, 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(): any/* Instant */;
+    get representativeAlgorithm(): AttoAlgorithm;
+    get representativePublicKey(): AttoPublicKey;
+    get address(): AttoAddress;
+    get representativeAddress(): AttoAddress;
+    send$default(receiverAlgorithm: AttoAlgorithm, receiverPublicKey: AttoPublicKey, amount: AttoAmount, timestamp?: any/* Instant */): any/* Pair<AttoSendBlock, AttoAccount> */;
+    receive$default(receivable: AttoReceivable, timestamp?: any/* Instant */): any/* Pair<AttoReceiveBlock, AttoAccount> */;
+    change$default(representativeAlgorithm: AttoAlgorithm, representativePublicKey: AttoPublicKey, timestamp?: any/* Instant */): any/* Pair<AttoChangeBlock, AttoAccount> */;
+    copy(publicKey?: AttoPublicKey, network?: AttoNetwork, version?: AttoVersion, algorithm?: AttoAlgorithm, height?: AttoHeight, balance?: AttoAmount, lastTransactionHash?: AttoHash, lastTransactionTimestamp?: any/* Instant */, representativeAlgorithm?: AttoAlgorithm, representativePublicKey?: AttoPublicKey): AttoAccount;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    readonly __doNotUseOrImplementIt: HeightSupport["__doNotUseOrImplementIt"];
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace AttoAccount.$metadata$ {
+    const constructor: abstract new () => AttoAccount;
+}
+export declare namespace AttoAccount {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Companion.$metadata$ {
+        abstract class constructor {
+            open$default(representativeAlgorithm: AttoAlgorithm, representativePublicKey: AttoPublicKey, receivable: AttoReceivable, network: AttoNetwork, timestamp?: any/* Instant */): any/* Pair<AttoOpenBlock, AttoAccount> */;
+            private constructor();
+        }
+    }
+}

package/commons-commons-core/cash/atto/commons/AttoAccount.export.mjs

@@ -0,0 +1,19 @@
+import {
+  AttoAccountgigli120r8kv as AttoAccount,
+  Companion9ntcbv2sv4ko as Companion,
+  Companion_getInstance1zxsxskq6zbhe as Companion_getInstance,
+} from './AttoAccount.mjs';
+import { defineProp3hxgpk2knu2px as defineProp } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+var AttoAccount_0 = AttoAccount();
+defineProp(AttoAccount_0, 'Companion', Companion_getInstance);
+export {
+  AttoAccount_0 as AttoAccount,
+};
+//endregion
+
+//# sourceMappingURL=AttoAccount.export.mjs.map

package/commons-commons-core/cash/atto/commons/AttoAccount.export.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;;;;"}