@attocash/commons-test 6.0.0

package/commons-commons-core/cash/atto/commons/AttoAmount.mjs

@@ -0,0 +1,351 @@
+import {
+  THROW_IAE23kobfj9wdoxr as THROW_IAE,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  _UByte___init__impl__g9hnc43ude1dscg1q30 as _UByte___init__impl__g9hnc4,
+  _UByte___get_data__impl__jof9qr2p2xx2i2jvnz8 as _UByte___get_data__impl__jof9qr,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/UByte.mjs';
+import { Enum3alwj03lh1n41 as Enum } from '../../../../kotlin-kotlin-stdlib/kotlin/Enum.mjs';
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  _ULong___init__impl__c78o9k1p6qzv0dh0bvg as _ULong___init__impl__c78o9k,
+  _ULong___get_data__impl__fggpzb2qlkrfp9zs48z as _ULong___get_data__impl__fggpzb,
+  ULong3f9k7s38t3rfp as ULong,
+  ULong__toString_impl_f9au7kivnvhcxkib53 as ULong__toString_impl_f9au7k,
+  ULong__hashCode_impl_6hv2lb37naj4fr4k4il as ULong__hashCode_impl_6hv2lb,
+  Companion_getInstance1puqqwzccfvrg as Companion_getInstance,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/ULong.mjs';
+import {
+  multiply2k9eolhnz1bjv as multiply,
+  add2suhfggl4zvkk as add,
+  subtract2orl8z9upxd9l as subtract,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/internal/longAsBigInt/longAsBigInt.mjs';
+import { _Char___init__impl__6a9atx2js6krycynjoo as _Char___init__impl__6a9atx } from '../../../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
+import { charArrayOf27f4r3dozbrk1 as charArrayOf } from '../../../../kotlin-kotlin-stdlib/kotlin/js/arrays.mjs';
+import {
+  split3d3yeauc4rm2n as split,
+  padStart36w1507hs626a as padStart,
+  trimEndvvzjdhan75g as trimEnd,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/text/Strings.mjs';
+import { toULong266mnyksbttkw as toULong } from '../../../../kotlin-kotlin-stdlib/kotlin/text/UStrings.mjs';
+import { toByte4i43936u611k as toByte } from '../../../../kotlin-kotlin-stdlib/kotlin/js/numberConversion.mjs';
+import {
+  ulongDivide3e52ct8hxp5n7 as ulongDivide,
+  ulongCompare29yg6v52hxi4l as ulongCompare,
+  ulongRemainder2rz3omb7z07fg as ulongRemainder,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/UnsignedJs.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { Comparable198qfk8pnblz0 as Comparable } from '../../../../kotlin-kotlin-stdlib/kotlin/Comparable.mjs';
+import { serializer2lw83vwvpnyms as serializer } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/builtins/BuiltinSerializers.mjs';
+import { KSerializerzf77vz1967fq as KSerializer } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var AttoUnit_ATTO_instance;
+var AttoUnit_RAW_instance;
+function values() {
+  return [AttoUnit_ATTO_getInstance(), AttoUnit_RAW_getInstance()];
+}
+function valueOf(value) {
+  switch (value) {
+    case 'ATTO':
+      return AttoUnit_ATTO_getInstance();
+    case 'RAW':
+      return AttoUnit_RAW_getInstance();
+    default:
+      AttoUnit_initEntries();
+      THROW_IAE('No enum constant cash.atto.commons.AttoUnit.' + value);
+      break;
+  }
+}
+var AttoUnit_entriesInitialized;
+function AttoUnit_initEntries() {
+  if (AttoUnit_entriesInitialized)
+    return Unit_instance;
+  AttoUnit_entriesInitialized = true;
+  AttoUnit_ATTO_instance = new (AttoUnit())('ATTO', 0, 'atto', _UByte___init__impl__g9hnc4(9));
+  AttoUnit_RAW_instance = new (AttoUnit())('RAW', 1, 'raw', _UByte___init__impl__g9hnc4(0));
+}
+var AttoUnitClass;
+function AttoUnit() {
+  if (AttoUnitClass === VOID) {
+    class $ extends Enum() {
+      constructor(name, ordinal, prefix, scale) {
+        super(name, ordinal);
+        this.prefix = prefix;
+        this.c4m_1 = scale;
+      }
+      d4m() {
+        return this.prefix;
+      }
+      e4m() {
+        return this.c4m_1;
+      }
+      get name() {
+        return this.w3();
+      }
+      get ordinal() {
+        return this.x3();
+      }
+    }
+    initMetadataForClass($, 'AttoUnit');
+    AttoUnitClass = $;
+  }
+  return AttoUnitClass;
+}
+function pow($this, _this__u8e3s4, exponent) {
+  var result = _ULong___init__impl__c78o9k(1n);
+  // Inline function 'kotlin.repeat' call
+  var inductionVariable = 0;
+  if (inductionVariable < exponent)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'kotlin.ULong.times' call
+      var this_0 = result;
+      result = _ULong___init__impl__c78o9k(multiply(_ULong___get_data__impl__fggpzb(this_0), _ULong___get_data__impl__fggpzb(_this__u8e3s4)));
+    }
+     while (inductionVariable < exponent);
+  return result;
+}
+function scaleFactor($this, scale) {
+  var tmp = _ULong___init__impl__c78o9k(10n);
+  // Inline function 'kotlin.UByte.toInt' call
+  var tmp$ret$0 = _UByte___get_data__impl__jof9qr(scale) & 255;
+  return pow($this, tmp, tmp$ret$0);
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        this.f4m_1 = _ULong___init__impl__c78o9k(-446744073709551616n);
+        this.MAX = new (AttoAmount())(this.f4m_1);
+        this.g4m_1 = _ULong___init__impl__c78o9k(0n);
+        this.MIN = new (AttoAmount())(this.g4m_1);
+      }
+      h4m() {
+        return this.MAX;
+      }
+      i4m() {
+        return this.MIN;
+      }
+      j4m(unit, string) {
+        var parts = split(string, charArrayOf([_Char___init__impl__6a9atx(46)]));
+        var wholePart = toULong(parts.o1(0));
+        var factor = scaleFactor(this, unit.c4m_1);
+        // Inline function 'kotlin.ULong.times' call
+        var scaledValue = _ULong___init__impl__c78o9k(multiply(_ULong___get_data__impl__fggpzb(wholePart), _ULong___get_data__impl__fggpzb(factor)));
+        if (parts.n1() > 1) {
+          var fractionalPart = toULong(parts.o1(1));
+          var tmp0 = scaledValue;
+          // Inline function 'kotlin.ULong.times' call
+          var tmp0_0 = _ULong___init__impl__c78o9k(multiply(_ULong___get_data__impl__fggpzb(fractionalPart), _ULong___get_data__impl__fggpzb(factor)));
+          // Inline function 'kotlin.toUByte' call
+          var this_0 = parts.o1(1).length;
+          var tmp$ret$2 = _UByte___init__impl__g9hnc4(toByte(this_0));
+          // Inline function 'kotlin.ULong.div' call
+          var other = scaleFactor(this, tmp$ret$2);
+          // Inline function 'kotlin.ULong.plus' call
+          var other_0 = ulongDivide(tmp0_0, other);
+          scaledValue = _ULong___init__impl__c78o9k(add(_ULong___get_data__impl__fggpzb(tmp0), _ULong___get_data__impl__fggpzb(other_0)));
+        }
+        return new (AttoAmount())(scaledValue);
+      }
+      p3q() {
+        return AttoAmountAsULongSerializer_getInstance();
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance_0() {
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
+function from(unit, string) {
+  return Companion_getInstance_0().j4m(unit, string);
+}
+var AttoAmountClass;
+function AttoAmount() {
+  if (AttoAmountClass === VOID) {
+    class $ {
+      constructor(raw) {
+        Companion_getInstance_0();
+        this.raw = raw;
+        var tmp0 = this.raw;
+        // Inline function 'kotlin.ULong.compareTo' call
+        var other = Companion_getInstance_0().f4m_1;
+        if (ulongCompare(_ULong___get_data__impl__fggpzb(tmp0), _ULong___get_data__impl__fggpzb(other)) > 0) {
+          throw IllegalStateException().w4('' + new (ULong())(this.raw) + ' exceeds the max amount of ' + new (ULong())(Companion_getInstance_0().f4m_1));
+        }
+      }
+      k4m() {
+        return this.raw;
+      }
+      toFormattedString(unit) {
+        var factor = scaleFactor(Companion_getInstance_0(), unit.c4m_1);
+        // Inline function 'kotlin.ULong.div' call
+        var this_0 = this.raw;
+        var wholePart = ulongDivide(this_0, factor);
+        // Inline function 'kotlin.ULong.rem' call
+        var this_1 = this.raw;
+        var fractionalPart = ulongRemainder(this_1, factor);
+        var tmp;
+        if (fractionalPart === _ULong___init__impl__c78o9k(0n)) {
+          tmp = ULong__toString_impl_f9au7k(wholePart);
+        } else {
+          var tmp_0 = ULong__toString_impl_f9au7k(fractionalPart);
+          // Inline function 'kotlin.UByte.toInt' call
+          var this_2 = unit.c4m_1;
+          var tmp$ret$2 = _UByte___get_data__impl__jof9qr(this_2) & 255;
+          var fractionalStr = trimEnd(padStart(tmp_0, tmp$ret$2, _Char___init__impl__6a9atx(48)), charArrayOf([_Char___init__impl__6a9atx(48)]));
+          tmp = '' + new (ULong())(wholePart) + '.' + fractionalStr;
+        }
+        return tmp;
+      }
+      plus(amount) {
+        var tmp0 = this.raw;
+        // Inline function 'kotlin.ULong.plus' call
+        var other = amount.raw;
+        var total = _ULong___init__impl__c78o9k(add(_ULong___get_data__impl__fggpzb(tmp0), _ULong___get_data__impl__fggpzb(other)));
+        var tmp;
+        // Inline function 'kotlin.ULong.compareTo' call
+        var other_0 = this.raw;
+        if (ulongCompare(_ULong___get_data__impl__fggpzb(total), _ULong___get_data__impl__fggpzb(other_0)) < 0) {
+          tmp = true;
+        } else {
+          // Inline function 'kotlin.ULong.compareTo' call
+          var other_1 = amount.raw;
+          tmp = ulongCompare(_ULong___get_data__impl__fggpzb(total), _ULong___get_data__impl__fggpzb(other_1)) < 0;
+        }
+        if (tmp) {
+          throw IllegalStateException().w4('ULong overflow');
+        }
+        return new (AttoAmount())(total);
+      }
+      minus(amount) {
+        var tmp0 = this.raw;
+        // Inline function 'kotlin.ULong.minus' call
+        var other = amount.raw;
+        var total = _ULong___init__impl__c78o9k(subtract(_ULong___get_data__impl__fggpzb(tmp0), _ULong___get_data__impl__fggpzb(other)));
+        // Inline function 'kotlin.ULong.compareTo' call
+        var other_0 = this.raw;
+        if (ulongCompare(_ULong___get_data__impl__fggpzb(total), _ULong___get_data__impl__fggpzb(other_0)) > 0) {
+          throw IllegalStateException().w4('ULong underflow');
+        }
+        return new (AttoAmount())(total);
+      }
+      l4m(other) {
+        var tmp0 = this.raw;
+        // Inline function 'kotlin.ULong.compareTo' call
+        var other_0 = other.raw;
+        return ulongCompare(_ULong___get_data__impl__fggpzb(tmp0), _ULong___get_data__impl__fggpzb(other_0));
+      }
+      d(other) {
+        return this.l4m(other instanceof AttoAmount() ? other : THROW_CCE());
+      }
+      toString() {
+        return '' + new (ULong())(this.raw);
+      }
+      m4m() {
+        return this.raw;
+      }
+      n4m(raw) {
+        return new (AttoAmount())(raw);
+      }
+      copy(raw, $super) {
+        raw = raw === VOID ? this.raw : raw;
+        return $super === VOID ? this.n4m(raw) : $super.n4m.call(this, new (ULong())(raw));
+      }
+      hashCode() {
+        return ULong__hashCode_impl_6hv2lb(this.raw);
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof AttoAmount()))
+          return false;
+        if (!(this.raw === other.raw))
+          return false;
+        return true;
+      }
+    }
+    initMetadataForClass($, 'AttoAmount', VOID, VOID, [Comparable()], VOID, VOID, {0: AttoAmountAsULongSerializer_getInstance});
+    AttoAmountClass = $;
+  }
+  return AttoAmountClass;
+}
+function toAttoAmount(_this__u8e3s4) {
+  return new (AttoAmount())(toULong(_this__u8e3s4));
+}
+var AttoAmountAsULongSerializerClass;
+function AttoAmountAsULongSerializer() {
+  if (AttoAmountAsULongSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        AttoAmountAsULongSerializer_instance = this;
+        this.o4m_1 = serializer(Companion_getInstance()).z1s();
+      }
+      z1s() {
+        return this.o4m_1;
+      }
+      p4m(encoder, value) {
+        serializer(Companion_getInstance()).a1t(encoder, new (ULong())(value.raw));
+      }
+      a1t(encoder, value) {
+        return this.p4m(encoder, value instanceof AttoAmount() ? value : THROW_CCE());
+      }
+      b1t(decoder) {
+        return new (AttoAmount())(serializer(Companion_getInstance()).b1t(decoder).ur_1);
+      }
+    }
+    initMetadataForObject($, 'AttoAmountAsULongSerializer', VOID, VOID, [KSerializer()]);
+    AttoAmountAsULongSerializerClass = $;
+  }
+  return AttoAmountAsULongSerializerClass;
+}
+var AttoAmountAsULongSerializer_instance;
+function AttoAmountAsULongSerializer_getInstance() {
+  if (AttoAmountAsULongSerializer_instance === VOID)
+    new (AttoAmountAsULongSerializer())();
+  return AttoAmountAsULongSerializer_instance;
+}
+function AttoUnit_ATTO_getInstance() {
+  AttoUnit_initEntries();
+  return AttoUnit_ATTO_instance;
+}
+function AttoUnit_RAW_getInstance() {
+  AttoUnit_initEntries();
+  return AttoUnit_RAW_instance;
+}
+//region block: exports
+export {
+  Companion as Companion311shwy120dnf,
+  AttoAmount as AttoAmount28z2ffm4ih7im,
+  valueOf as valueOf2yt2l9kimc6n,
+  values as values3ntpkxfaw56c5,
+  AttoUnit as AttoUnit3uf7k0bjq9xrg,
+  toAttoAmount as toAttoAmount2kbgjtdbld3yn,
+  from as from1fjx23mt482ol,
+  AttoUnit_ATTO_getInstance as AttoUnit_ATTO_getInstance1gwhthkel17m5,
+  AttoUnit_RAW_getInstance as AttoUnit_RAW_getInstance1qbk9zmheijip,
+  Companion_getInstance_0 as Companion_getInstancezafbg69jdanb,
+  AttoAmountAsULongSerializer_getInstance as AttoAmountAsULongSerializer_getInstanceh2609yxm2twf,
+};
+//endregion
+
+//# sourceMappingURL=AttoAmount.mjs.map

package/commons-commons-core/cash/atto/commons/AttoAmount.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoAmount.kt","src/kotlin/util/Standard.kt","unsigned/src/kotlin/ULong.kt","unsigned/src/kotlin/UByte.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["values","valueOf","value","prefix","scale","<get-prefix>","<get-scale>","pow","<this>","exponent","result","index","scaleFactor","<get-MAX>","<get-MIN>","from","unit","string","parts","wholePart","factor","scaledValue","fractionalPart","serializer","raw","<get-raw>","toString","fractionalStr","plus","amount","total","minus","compareTo","other","toAttoAmount","<get-descriptor>","serialize","encoder","deserialize","decoder"],"mappings":"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"}

package/commons-commons-core/cash/atto/commons/AttoBlock.export.d.mts

@@ -0,0 +1,287 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+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;
+    get code(): any/* UByte */;
+    get size(): number;
+    static values(): Array<AttoBlockType>;
+    static valueOf(value: string): AttoBlockType;
+}
+/** @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 AttoBlockType.$metadata$ {
+    const constructor: abstract new () => AttoBlockType;
+}
+export declare namespace AttoBlockType {
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$metadata$.type;
+        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 type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            from(code: any/* UByte */): AttoBlockType;
+            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(): any/* AttoValidation */;
+    isValid(): boolean;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.AttoBlock": unique symbol;
+    } & HeightSupport["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"] & AttoHashable["__doNotUseOrImplementIt"];
+}
+export declare abstract class AttoBlock {
+    static readonly getInstance: () => typeof AttoBlock.$metadata$.type;
+    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 */
+export declare namespace AttoBlock.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor /* implements SerializerFactory */ {
+        fromBuffer(serializedBlock: any/* Buffer */): Nullable<AttoBlock>;
+        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(): any/* 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;
+    readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__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 AttoSendBlock.$metadata$ {
+    const constructor: abstract new () => AttoSendBlock;
+}
+export declare namespace AttoSendBlock {
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$metadata$.type;
+        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 type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        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(): any/* AttoValidation */;
+    isValid(): boolean;
+    readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"] & ReceiveSupport["__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 AttoReceiveBlock.$metadata$ {
+    const constructor: abstract new () => AttoReceiveBlock;
+}
+export declare namespace AttoReceiveBlock {
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$metadata$.type;
+        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 type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        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(): any/* AttoValidation */;
+    isValid(): boolean;
+    readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & ReceiveSupport["__doNotUseOrImplementIt"] & RepresentativeSupport["__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 AttoOpenBlock.$metadata$ {
+    const constructor: abstract new () => AttoOpenBlock;
+}
+export declare namespace AttoOpenBlock {
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$metadata$.type;
+        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 type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        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(): any/* AttoValidation */;
+    isValid(): boolean;
+    readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"] & RepresentativeSupport["__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 AttoChangeBlock.$metadata$ {
+    const constructor: abstract new () => AttoChangeBlock;
+}
+export declare namespace AttoChangeBlock {
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$metadata$.type;
+        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 type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            private constructor();
+        }
+    }
+}