@airgap/substrate 0.13.11-beta.1 → 0.13.11-beta.3

package/v1/data/metadata/v14/extrinsic/MetadataV14Extrinsic.js

@@ -0,0 +1,44 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataV14Exstrinsic = void 0;
+var SCALEDecoder_1 = require("../../../scale/SCALEDecoder");
+var MetadataV14Component_1 = require("../MetadataV14Component");
+var MetadataV14SignedExtension_1 = require("./MetadataV14SignedExtension");
+var MetadataV14Exstrinsic = /** @class */ (function (_super) {
+    __extends(MetadataV14Exstrinsic, _super);
+    function MetadataV14Exstrinsic(type, version, signedExtensions) {
+        var _this = _super.call(this, type) || this;
+        _this.version = version;
+        _this.signedExtensions = signedExtensions;
+        _this.scaleFields = [_this.type, _this.version, _this.signedExtensions];
+        return _this;
+    }
+    MetadataV14Exstrinsic.decode = function (configuration, runtimeVersion, raw) {
+        var decoder = new SCALEDecoder_1.SCALEDecoder(configuration, runtimeVersion, raw);
+        var type = decoder.decodeNextCompactInt();
+        var version = decoder.decodeNextInt(8);
+        var signedExtensions = decoder.decodeNextArray(MetadataV14SignedExtension_1.MetadataV14SignedExtension.decode);
+        return {
+            bytesDecoded: type.bytesDecoded + version.bytesDecoded + signedExtensions.bytesDecoded,
+            decoded: new MetadataV14Exstrinsic(type.decoded, version.decoded, signedExtensions.decoded)
+        };
+    };
+    return MetadataV14Exstrinsic;
+}(MetadataV14Component_1.MetadataV14Component));
+exports.MetadataV14Exstrinsic = MetadataV14Exstrinsic;
+//# sourceMappingURL=MetadataV14Extrinsic.js.map

package/v1/data/metadata/v14/extrinsic/MetadataV14Extrinsic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataV14Extrinsic.js","sourceRoot":"","sources":["../../../../../../src/v1/data/metadata/v14/extrinsic/MetadataV14Extrinsic.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AACA,4DAA6E;AAK7E,gEAA8D;AAE9D,2EAAyE;AAEzE;IAA2C,yCAAoB;IAoB7D,+BACE,IAAqB,EACZ,OAAiB,EACjB,gBAAwD;QAHnE,YAKE,kBAAM,IAAI,CAAC,SACZ;QAJU,aAAO,GAAP,OAAO,CAAU;QACjB,sBAAgB,GAAhB,gBAAgB,CAAwC;QALzD,iBAAW,GAAgB,CAAC,KAAI,CAAC,IAAI,EAAE,KAAI,CAAC,OAAO,EAAE,KAAI,CAAC,gBAAgB,CAAC,CAAA;;IAQrF,CAAC;IAzBa,4BAAM,GAApB,UACE,aAAgB,EAChB,cAAkC,EAClC,GAAW;QAEX,IAAM,OAAO,GAAG,IAAI,2BAAY,CAAC,aAAa,EAAE,cAAc,EAAE,GAAG,CAAC,CAAA;QAEpE,IAAM,IAAI,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAA;QAC3C,IAAM,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAA;QACxC,IAAM,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,uDAA0B,CAAC,MAAM,CAAC,CAAA;QAEnF,OAAO;YACL,YAAY,EAAE,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,GAAG,gBAAgB,CAAC,YAAY;YACtF,OAAO,EAAE,IAAI,qBAAqB,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC;SAC5F,CAAA;IACH,CAAC;IAWH,4BAAC;AAAD,CAAC,AA3BD,CAA2C,2CAAoB,GA2B9D;AA3BY,sDAAqB"}

package/v1/data/metadata/v14/extrinsic/MetadataV14SignedExtension.d.ts

@@ -0,0 +1,13 @@
+import { SubstrateProtocolConfiguration } from '../../../../types/configuration';
+import { SCALEDecodeResult } from '../../../scale/SCALEDecoder';
+import { SCALECompactInt } from '../../../scale/type/SCALECompactInt';
+import { SCALEString } from '../../../scale/type/SCALEString';
+import { SCALEType } from '../../../scale/type/SCALEType';
+import { MetadataV14Component } from '../MetadataV14Component';
+export declare class MetadataV14SignedExtension extends MetadataV14Component {
+    readonly identifier: SCALEString;
+    readonly additionalSigned: SCALECompactInt;
+    static decode<C extends SubstrateProtocolConfiguration>(configuration: C, runtimeVersion: number | undefined, raw: string): SCALEDecodeResult<MetadataV14SignedExtension>;
+    protected scaleFields: SCALEType[];
+    private constructor();
+}

package/v1/data/metadata/v14/extrinsic/MetadataV14SignedExtension.js

@@ -0,0 +1,43 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataV14SignedExtension = void 0;
+var SCALEDecoder_1 = require("../../../scale/SCALEDecoder");
+var MetadataV14Component_1 = require("../MetadataV14Component");
+var MetadataV14SignedExtension = /** @class */ (function (_super) {
+    __extends(MetadataV14SignedExtension, _super);
+    function MetadataV14SignedExtension(identifier, type, additionalSigned) {
+        var _this = _super.call(this, type) || this;
+        _this.identifier = identifier;
+        _this.additionalSigned = additionalSigned;
+        _this.scaleFields = [_this.identifier, _this.type, _this.additionalSigned];
+        return _this;
+    }
+    MetadataV14SignedExtension.decode = function (configuration, runtimeVersion, raw) {
+        var decoder = new SCALEDecoder_1.SCALEDecoder(configuration, runtimeVersion, raw);
+        var identifier = decoder.decodeNextString();
+        var type = decoder.decodeNextCompactInt();
+        var additionalSigned = decoder.decodeNextCompactInt();
+        return {
+            bytesDecoded: identifier.bytesDecoded + type.bytesDecoded + additionalSigned.bytesDecoded,
+            decoded: new MetadataV14SignedExtension(identifier.decoded, type.decoded, additionalSigned.decoded)
+        };
+    };
+    return MetadataV14SignedExtension;
+}(MetadataV14Component_1.MetadataV14Component));
+exports.MetadataV14SignedExtension = MetadataV14SignedExtension;
+//# sourceMappingURL=MetadataV14SignedExtension.js.map

package/v1/data/metadata/v14/extrinsic/MetadataV14SignedExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataV14SignedExtension.js","sourceRoot":"","sources":["../../../../../../src/v1/data/metadata/v14/extrinsic/MetadataV14SignedExtension.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AACA,4DAA6E;AAI7E,gEAA8D;AAE9D;IAAgD,8CAAoB;IAoBlE,oCAA6B,UAAuB,EAAE,IAAqB,EAAW,gBAAiC;QAAvH,YACE,kBAAM,IAAI,CAAC,SACZ;QAF4B,gBAAU,GAAV,UAAU,CAAa;QAAkC,sBAAgB,GAAhB,gBAAgB,CAAiB;QAF7G,iBAAW,GAAgB,CAAC,KAAI,CAAC,UAAU,EAAE,KAAI,CAAC,IAAI,EAAE,KAAI,CAAC,gBAAgB,CAAC,CAAA;;IAIxF,CAAC;IArBa,iCAAM,GAApB,UACE,aAAgB,EAChB,cAAkC,EAClC,GAAW;QAEX,IAAM,OAAO,GAAG,IAAI,2BAAY,CAAC,aAAa,EAAE,cAAc,EAAE,GAAG,CAAC,CAAA;QAEpE,IAAM,UAAU,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAA;QAC7C,IAAM,IAAI,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAA;QAC3C,IAAM,gBAAgB,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAA;QAEvD,OAAO;YACL,YAAY,EAAE,UAAU,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,GAAG,gBAAgB,CAAC,YAAY;YACzF,OAAO,EAAE,IAAI,0BAA0B,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAC;SACpG,CAAA;IACH,CAAC;IAOH,iCAAC;AAAD,CAAC,AAvBD,CAAgD,2CAAoB,GAuBnE;AAvBY,gEAA0B"}

package/v1/data/metadata/v14/pallet/MetadataV14Call.d.ts

@@ -0,0 +1,6 @@
+import { SubstrateProtocolConfiguration } from '../../../../types/configuration';
+import { SCALEDecodeResult } from '../../../scale/SCALEDecoder';
+import { MetadataV14Component } from '../MetadataV14Component';
+export declare class MetadataV14Call extends MetadataV14Component {
+    static decode<C extends SubstrateProtocolConfiguration>(configuration: C, runtimeVersion: number | undefined, raw: string): SCALEDecodeResult<MetadataV14Call>;
+}

package/v1/data/metadata/v14/pallet/MetadataV14Call.js

@@ -0,0 +1,37 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataV14Call = void 0;
+var SCALEDecoder_1 = require("../../../scale/SCALEDecoder");
+var MetadataV14Component_1 = require("../MetadataV14Component");
+var MetadataV14Call = /** @class */ (function (_super) {
+    __extends(MetadataV14Call, _super);
+    function MetadataV14Call() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MetadataV14Call.decode = function (configuration, runtimeVersion, raw) {
+        var decoder = new SCALEDecoder_1.SCALEDecoder(configuration, runtimeVersion, raw);
+        var type = decoder.decodeNextCompactInt();
+        return {
+            bytesDecoded: type.bytesDecoded,
+            decoded: new MetadataV14Call(type.decoded)
+        };
+    };
+    return MetadataV14Call;
+}(MetadataV14Component_1.MetadataV14Component));
+exports.MetadataV14Call = MetadataV14Call;
+//# sourceMappingURL=MetadataV14Call.js.map

package/v1/data/metadata/v14/pallet/MetadataV14Call.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataV14Call.js","sourceRoot":"","sources":["../../../../../../src/v1/data/metadata/v14/pallet/MetadataV14Call.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AACA,4DAA6E;AAC7E,gEAA8D;AAE9D;IAAqC,mCAAoB;IAAzD;;IAeA,CAAC;IAde,sBAAM,GAApB,UACE,aAAgB,EAChB,cAAkC,EAClC,GAAW;QAEX,IAAM,OAAO,GAAG,IAAI,2BAAY,CAAC,aAAa,EAAE,cAAc,EAAE,GAAG,CAAC,CAAA;QAEpE,IAAM,IAAI,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAA;QAE3C,OAAO;YACL,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,OAAO,EAAE,IAAI,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC;SAC3C,CAAA;IACH,CAAC;IACH,sBAAC;AAAD,CAAC,AAfD,CAAqC,2CAAoB,GAexD;AAfY,0CAAe"}

package/v1/data/metadata/v14/pallet/MetadataV14Constant.d.ts

@@ -0,0 +1,15 @@
+import { SubstrateProtocolConfiguration } from '../../../../types/configuration';
+import { SCALEDecodeResult } from '../../../scale/SCALEDecoder';
+import { SCALEArray } from '../../../scale/type/SCALEArray';
+import { SCALEBytes } from '../../../scale/type/SCALEBytes';
+import { SCALECompactInt } from '../../../scale/type/SCALECompactInt';
+import { SCALEString } from '../../../scale/type/SCALEString';
+import { MetadataV14Component } from '../MetadataV14Component';
+export declare class MetadataV14Constant extends MetadataV14Component {
+    readonly name: SCALEString;
+    readonly value: SCALEBytes;
+    readonly docs: SCALEArray<SCALEString>;
+    static decode<C extends SubstrateProtocolConfiguration>(configuration: C, runtimeVersion: number | undefined, raw: string): SCALEDecodeResult<MetadataV14Constant>;
+    protected scaleFields: (SCALEBytes | SCALECompactInt | SCALEString | SCALEArray<SCALEString>)[];
+    private constructor();
+}

package/v1/data/metadata/v14/pallet/MetadataV14Constant.js

@@ -0,0 +1,46 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataV14Constant = void 0;
+var SCALEDecoder_1 = require("../../../scale/SCALEDecoder");
+var SCALEString_1 = require("../../../scale/type/SCALEString");
+var MetadataV14Component_1 = require("../MetadataV14Component");
+var MetadataV14Constant = /** @class */ (function (_super) {
+    __extends(MetadataV14Constant, _super);
+    function MetadataV14Constant(name, type, value, docs) {
+        var _this = _super.call(this, type) || this;
+        _this.name = name;
+        _this.value = value;
+        _this.docs = docs;
+        _this.scaleFields = [_this.name, _this.type, _this.value, _this.docs];
+        return _this;
+    }
+    MetadataV14Constant.decode = function (configuration, runtimeVersion, raw) {
+        var decoder = new SCALEDecoder_1.SCALEDecoder(configuration, runtimeVersion, raw);
+        var name = decoder.decodeNextString();
+        var type = decoder.decodeNextCompactInt();
+        var value = decoder.decodeNextBytes();
+        var docs = decoder.decodeNextArray(function (_configuration, _runtimeVersion, hex) { return SCALEString_1.SCALEString.decode(hex); });
+        return {
+            bytesDecoded: name.bytesDecoded + type.bytesDecoded + value.bytesDecoded + docs.bytesDecoded,
+            decoded: new MetadataV14Constant(name.decoded, type.decoded, value.decoded, docs.decoded)
+        };
+    };
+    return MetadataV14Constant;
+}(MetadataV14Component_1.MetadataV14Component));
+exports.MetadataV14Constant = MetadataV14Constant;
+//# sourceMappingURL=MetadataV14Constant.js.map

package/v1/data/metadata/v14/pallet/MetadataV14Constant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataV14Constant.js","sourceRoot":"","sources":["../../../../../../src/v1/data/metadata/v14/pallet/MetadataV14Constant.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AACA,4DAA6E;AAI7E,+DAA6D;AAC7D,gEAA8D;AAE9D;IAAyC,uCAAoB;IAqB3D,6BACW,IAAiB,EAC1B,IAAqB,EACZ,KAAiB,EACjB,IAA6B;QAJxC,YAME,kBAAM,IAAI,CAAC,SACZ;QANU,UAAI,GAAJ,IAAI,CAAa;QAEjB,WAAK,GAAL,KAAK,CAAY;QACjB,UAAI,GAAJ,IAAI,CAAyB;QAN9B,iBAAW,GAAG,CAAC,KAAI,CAAC,IAAI,EAAE,KAAI,CAAC,IAAI,EAAE,KAAI,CAAC,KAAK,EAAE,KAAI,CAAC,IAAI,CAAC,CAAA;;IASrE,CAAC;IA3Ba,0BAAM,GAApB,UACE,aAAgB,EAChB,cAAkC,EAClC,GAAW;QAEX,IAAM,OAAO,GAAG,IAAI,2BAAY,CAAC,aAAa,EAAE,cAAc,EAAE,GAAG,CAAC,CAAA;QAEpE,IAAM,IAAI,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAA;QACvC,IAAM,IAAI,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAA;QAC3C,IAAM,KAAK,GAAG,OAAO,CAAC,eAAe,EAAE,CAAA;QACvC,IAAM,IAAI,GAAG,OAAO,CAAC,eAAe,CAAC,UAAC,cAAc,EAAE,eAAe,EAAE,GAAG,IAAK,OAAA,yBAAW,CAAC,MAAM,CAAC,GAAG,CAAC,EAAvB,CAAuB,CAAC,CAAA;QAEvG,OAAO;YACL,YAAY,EAAE,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY;YAC5F,OAAO,EAAE,IAAI,mBAAmB,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC;SAC1F,CAAA;IACH,CAAC;IAYH,0BAAC;AAAD,CAAC,AA7BD,CAAyC,2CAAoB,GA6B5D;AA7BY,kDAAmB"}

package/v1/data/metadata/v14/pallet/MetadataV14Error.d.ts

@@ -0,0 +1,6 @@
+import { SubstrateProtocolConfiguration } from '../../../../types/configuration';
+import { SCALEDecodeResult } from '../../../scale/SCALEDecoder';
+import { MetadataV14Component } from '../MetadataV14Component';
+export declare class MetadataV14Error extends MetadataV14Component {
+    static decode<C extends SubstrateProtocolConfiguration>(configuration: C, runtimeVersion: number | undefined, raw: string): SCALEDecodeResult<MetadataV14Error>;
+}

package/v1/data/metadata/v14/pallet/MetadataV14Error.js

@@ -0,0 +1,37 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataV14Error = void 0;
+var SCALEDecoder_1 = require("../../../scale/SCALEDecoder");
+var MetadataV14Component_1 = require("../MetadataV14Component");
+var MetadataV14Error = /** @class */ (function (_super) {
+    __extends(MetadataV14Error, _super);
+    function MetadataV14Error() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MetadataV14Error.decode = function (configuration, runtimeVersion, raw) {
+        var decoder = new SCALEDecoder_1.SCALEDecoder(configuration, runtimeVersion, raw);
+        var type = decoder.decodeNextCompactInt();
+        return {
+            bytesDecoded: type.bytesDecoded,
+            decoded: new MetadataV14Error(type.decoded)
+        };
+    };
+    return MetadataV14Error;
+}(MetadataV14Component_1.MetadataV14Component));
+exports.MetadataV14Error = MetadataV14Error;
+//# sourceMappingURL=MetadataV14Error.js.map

package/v1/data/metadata/v14/pallet/MetadataV14Error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataV14Error.js","sourceRoot":"","sources":["../../../../../../src/v1/data/metadata/v14/pallet/MetadataV14Error.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AACA,4DAA6E;AAC7E,gEAA8D;AAE9D;IAAsC,oCAAoB;IAA1D;;IAeA,CAAC;IAde,uBAAM,GAApB,UACE,aAAgB,EAChB,cAAkC,EAClC,GAAW;QAEX,IAAM,OAAO,GAAG,IAAI,2BAAY,CAAC,aAAa,EAAE,cAAc,EAAE,GAAG,CAAC,CAAA;QAEpE,IAAM,IAAI,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAA;QAE3C,OAAO;YACL,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,OAAO,EAAE,IAAI,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC;SAC5C,CAAA;IACH,CAAC;IACH,uBAAC;AAAD,CAAC,AAfD,CAAsC,2CAAoB,GAezD;AAfY,4CAAgB"}

package/v1/data/metadata/v14/pallet/MetadataV14Event.d.ts

@@ -0,0 +1,6 @@
+import { SubstrateProtocolConfiguration } from '../../../../types/configuration';
+import { SCALEDecodeResult } from '../../../scale/SCALEDecoder';
+import { MetadataV14Component } from '../MetadataV14Component';
+export declare class MetadataV14Event extends MetadataV14Component {
+    static decode<C extends SubstrateProtocolConfiguration>(configuration: C, runtimeVersion: number | undefined, raw: string): SCALEDecodeResult<MetadataV14Event>;
+}

package/v1/data/metadata/v14/pallet/MetadataV14Event.js

@@ -0,0 +1,37 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataV14Event = void 0;
+var SCALEDecoder_1 = require("../../../scale/SCALEDecoder");
+var MetadataV14Component_1 = require("../MetadataV14Component");
+var MetadataV14Event = /** @class */ (function (_super) {
+    __extends(MetadataV14Event, _super);
+    function MetadataV14Event() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MetadataV14Event.decode = function (configuration, runtimeVersion, raw) {
+        var decoder = new SCALEDecoder_1.SCALEDecoder(configuration, runtimeVersion, raw);
+        var type = decoder.decodeNextCompactInt();
+        return {
+            bytesDecoded: type.bytesDecoded,
+            decoded: new MetadataV14Event(type.decoded)
+        };
+    };
+    return MetadataV14Event;
+}(MetadataV14Component_1.MetadataV14Component));
+exports.MetadataV14Event = MetadataV14Event;
+//# sourceMappingURL=MetadataV14Event.js.map

package/v1/data/metadata/v14/pallet/MetadataV14Event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataV14Event.js","sourceRoot":"","sources":["../../../../../../src/v1/data/metadata/v14/pallet/MetadataV14Event.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AACA,4DAA6E;AAC7E,gEAA8D;AAE9D;IAAsC,oCAAoB;IAA1D;;IAeA,CAAC;IAde,uBAAM,GAApB,UACE,aAAgB,EAChB,cAAkC,EAClC,GAAW;QAEX,IAAM,OAAO,GAAG,IAAI,2BAAY,CAAC,aAAa,EAAE,cAAc,EAAE,GAAG,CAAC,CAAA;QAEpE,IAAM,IAAI,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAA;QAE3C,OAAO;YACL,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,OAAO,EAAE,IAAI,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC;SAC5C,CAAA;IACH,CAAC;IACH,uBAAC;AAAD,CAAC,AAfD,CAAsC,2CAAoB,GAezD;AAfY,4CAAgB"}

package/v1/data/metadata/v14/pallet/MetadataV14Pallet.d.ts

@@ -0,0 +1,25 @@
+import { SubstrateProtocolConfiguration } from '../../../../types/configuration';
+import { SCALEDecodeResult } from '../../../scale/SCALEDecoder';
+import { SCALEArray } from '../../../scale/type/SCALEArray';
+import { SCALEClass } from '../../../scale/type/SCALEClass';
+import { SCALEInt } from '../../../scale/type/SCALEInt';
+import { SCALEOptional } from '../../../scale/type/SCALEOptional';
+import { SCALEString } from '../../../scale/type/SCALEString';
+import { SCALEType } from '../../../scale/type/SCALEType';
+import { MetadataV14Call } from './MetadataV14Call';
+import { MetadataV14Constant } from './MetadataV14Constant';
+import { MetadataV14Error } from './MetadataV14Error';
+import { MetadataV14Event } from './MetadataV14Event';
+import { MetadataV14Storage } from './storage/MetadataV14Storage';
+export declare class MetadataV14Pallet extends SCALEClass {
+    readonly name: SCALEString;
+    readonly storage: SCALEOptional<MetadataV14Storage>;
+    readonly calls: SCALEOptional<MetadataV14Call>;
+    readonly events: SCALEOptional<MetadataV14Event>;
+    readonly constants: SCALEArray<MetadataV14Constant>;
+    readonly errors: SCALEOptional<MetadataV14Error>;
+    readonly index: SCALEInt;
+    static decode<C extends SubstrateProtocolConfiguration>(configuration: C, runtimeVersion: number | undefined, raw: string): SCALEDecodeResult<MetadataV14Pallet>;
+    protected scaleFields: SCALEType[];
+    protected constructor(name: SCALEString, storage: SCALEOptional<MetadataV14Storage>, calls: SCALEOptional<MetadataV14Call>, events: SCALEOptional<MetadataV14Event>, constants: SCALEArray<MetadataV14Constant>, errors: SCALEOptional<MetadataV14Error>, index: SCALEInt);
+}

package/v1/data/metadata/v14/pallet/MetadataV14Pallet.js

@@ -0,0 +1,63 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataV14Pallet = void 0;
+var SCALEDecoder_1 = require("../../../scale/SCALEDecoder");
+var SCALEClass_1 = require("../../../scale/type/SCALEClass");
+var MetadataV14Call_1 = require("./MetadataV14Call");
+var MetadataV14Constant_1 = require("./MetadataV14Constant");
+var MetadataV14Error_1 = require("./MetadataV14Error");
+var MetadataV14Event_1 = require("./MetadataV14Event");
+var MetadataV14Storage_1 = require("./storage/MetadataV14Storage");
+var MetadataV14Pallet = /** @class */ (function (_super) {
+    __extends(MetadataV14Pallet, _super);
+    function MetadataV14Pallet(name, storage, calls, events, constants, errors, index) {
+        var _this = _super.call(this) || this;
+        _this.name = name;
+        _this.storage = storage;
+        _this.calls = calls;
+        _this.events = events;
+        _this.constants = constants;
+        _this.errors = errors;
+        _this.index = index;
+        _this.scaleFields = [_this.name, _this.storage, _this.calls, _this.events, _this.constants, _this.errors, _this.index];
+        return _this;
+    }
+    MetadataV14Pallet.decode = function (configuration, runtimeVersion, raw) {
+        var decoder = new SCALEDecoder_1.SCALEDecoder(configuration, runtimeVersion, raw);
+        var name = decoder.decodeNextString();
+        var storage = decoder.decodeNextOptional(MetadataV14Storage_1.MetadataV14Storage.decode);
+        var calls = decoder.decodeNextOptional(MetadataV14Call_1.MetadataV14Call.decode);
+        var events = decoder.decodeNextOptional(MetadataV14Event_1.MetadataV14Event.decode);
+        var constants = decoder.decodeNextArray(MetadataV14Constant_1.MetadataV14Constant.decode);
+        var errors = decoder.decodeNextOptional(MetadataV14Error_1.MetadataV14Error.decode);
+        var index = decoder.decodeNextInt(8);
+        return {
+            bytesDecoded: name.bytesDecoded +
+                storage.bytesDecoded +
+                calls.bytesDecoded +
+                events.bytesDecoded +
+                constants.bytesDecoded +
+                errors.bytesDecoded +
+                index.bytesDecoded,
+            decoded: new MetadataV14Pallet(name.decoded, storage.decoded, calls.decoded, events.decoded, constants.decoded, errors.decoded, index.decoded)
+        };
+    };
+    return MetadataV14Pallet;
+}(SCALEClass_1.SCALEClass));
+exports.MetadataV14Pallet = MetadataV14Pallet;
+//# sourceMappingURL=MetadataV14Pallet.js.map

package/v1/data/metadata/v14/pallet/MetadataV14Pallet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataV14Pallet.js","sourceRoot":"","sources":["../../../../../../src/v1/data/metadata/v14/pallet/MetadataV14Pallet.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AACA,4DAA6E;AAE7E,6DAA2D;AAM3D,qDAAmD;AACnD,6DAA2D;AAC3D,uDAAqD;AACrD,uDAAqD;AACrD,mEAAiE;AAEjE;IAAuC,qCAAU;IAuC/C,2BACkB,IAAiB,EACjB,OAA0C,EAC1C,KAAqC,EACrC,MAAuC,EACvC,SAA0C,EAC1C,MAAuC,EACvC,KAAe;QAPjC,YASE,iBAAO,SACR;QATiB,UAAI,GAAJ,IAAI,CAAa;QACjB,aAAO,GAAP,OAAO,CAAmC;QAC1C,WAAK,GAAL,KAAK,CAAgC;QACrC,YAAM,GAAN,MAAM,CAAiC;QACvC,eAAS,GAAT,SAAS,CAAiC;QAC1C,YAAM,GAAN,MAAM,CAAiC;QACvC,WAAK,GAAL,KAAK,CAAU;QATvB,iBAAW,GAAgB,CAAC,KAAI,CAAC,IAAI,EAAE,KAAI,CAAC,OAAO,EAAE,KAAI,CAAC,KAAK,EAAE,KAAI,CAAC,MAAM,EAAE,KAAI,CAAC,SAAS,EAAE,KAAI,CAAC,MAAM,EAAE,KAAI,CAAC,KAAK,CAAC,CAAA;;IAYhI,CAAC;IAhDa,wBAAM,GAApB,UACE,aAAgB,EAChB,cAAkC,EAClC,GAAW;QAEX,IAAM,OAAO,GAAG,IAAI,2BAAY,CAAC,aAAa,EAAE,cAAc,EAAE,GAAG,CAAC,CAAA;QAEpE,IAAM,IAAI,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAA;QACvC,IAAM,OAAO,GAAG,OAAO,CAAC,kBAAkB,CAAC,uCAAkB,CAAC,MAAM,CAAC,CAAA;QACrE,IAAM,KAAK,GAAG,OAAO,CAAC,kBAAkB,CAAC,iCAAe,CAAC,MAAM,CAAC,CAAA;QAChE,IAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,mCAAgB,CAAC,MAAM,CAAC,CAAA;QAClE,IAAM,SAAS,GAAG,OAAO,CAAC,eAAe,CAAC,yCAAmB,CAAC,MAAM,CAAC,CAAA;QACrE,IAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,mCAAgB,CAAC,MAAM,CAAC,CAAA;QAClE,IAAM,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAA;QAEtC,OAAO;YACL,YAAY,EACV,IAAI,CAAC,YAAY;gBACjB,OAAO,CAAC,YAAY;gBACpB,KAAK,CAAC,YAAY;gBAClB,MAAM,CAAC,YAAY;gBACnB,SAAS,CAAC,YAAY;gBACtB,MAAM,CAAC,YAAY;gBACnB,KAAK,CAAC,YAAY;YACpB,OAAO,EAAE,IAAI,iBAAiB,CAC5B,IAAI,CAAC,OAAO,EACZ,OAAO,CAAC,OAAO,EACf,KAAK,CAAC,OAAO,EACb,MAAM,CAAC,OAAO,EACd,SAAS,CAAC,OAAO,EACjB,MAAM,CAAC,OAAO,EACd,KAAK,CAAC,OAAO,CACd;SACF,CAAA;IACH,CAAC;IAeH,wBAAC;AAAD,CAAC,AAlDD,CAAuC,uBAAU,GAkDhD;AAlDY,8CAAiB"}

package/v1/data/metadata/v14/pallet/storage/MetadataV14Storage.d.ts

@@ -0,0 +1,13 @@
+import { SubstrateProtocolConfiguration } from '../../../../../types/configuration';
+import { SCALEDecodeResult } from '../../../../scale/SCALEDecoder';
+import { SCALEArray } from '../../../../scale/type/SCALEArray';
+import { SCALEClass } from '../../../../scale/type/SCALEClass';
+import { SCALEString } from '../../../../scale/type/SCALEString';
+import { MetadataV14StorageEntry } from './MetadataV14StorageEntry';
+export declare class MetadataV14Storage extends SCALEClass {
+    readonly prefix: SCALEString;
+    readonly storageEntries: SCALEArray<MetadataV14StorageEntry>;
+    static decode<C extends SubstrateProtocolConfiguration>(configuration: C, runtimeVersion: number | undefined, raw: string): SCALEDecodeResult<MetadataV14Storage>;
+    protected scaleFields: SCALEString[];
+    private constructor();
+}

package/v1/data/metadata/v14/pallet/storage/MetadataV14Storage.js

@@ -0,0 +1,43 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataV14Storage = void 0;
+var SCALEDecoder_1 = require("../../../../scale/SCALEDecoder");
+var SCALEClass_1 = require("../../../../scale/type/SCALEClass");
+var MetadataV14StorageEntry_1 = require("./MetadataV14StorageEntry");
+var MetadataV14Storage = /** @class */ (function (_super) {
+    __extends(MetadataV14Storage, _super);
+    function MetadataV14Storage(prefix, storageEntries) {
+        var _this = _super.call(this) || this;
+        _this.prefix = prefix;
+        _this.storageEntries = storageEntries;
+        _this.scaleFields = [_this.prefix];
+        return _this;
+    }
+    MetadataV14Storage.decode = function (configuration, runtimeVersion, raw) {
+        var decoder = new SCALEDecoder_1.SCALEDecoder(configuration, runtimeVersion, raw);
+        var prefix = decoder.decodeNextString();
+        var storageEntries = decoder.decodeNextArray(MetadataV14StorageEntry_1.MetadataV14StorageEntry.decode);
+        return {
+            bytesDecoded: prefix.bytesDecoded + storageEntries.bytesDecoded,
+            decoded: new MetadataV14Storage(prefix.decoded, storageEntries.decoded)
+        };
+    };
+    return MetadataV14Storage;
+}(SCALEClass_1.SCALEClass));
+exports.MetadataV14Storage = MetadataV14Storage;
+//# sourceMappingURL=MetadataV14Storage.js.map

package/v1/data/metadata/v14/pallet/storage/MetadataV14Storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataV14Storage.js","sourceRoot":"","sources":["../../../../../../../src/v1/data/metadata/v14/pallet/storage/MetadataV14Storage.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AACA,+DAAgF;AAEhF,gEAA8D;AAG9D,qEAAmE;AAEnE;IAAwC,sCAAU;IAmBhD,4BAA6B,MAAmB,EAAW,cAAmD;QAA9G,YACE,iBAAO,SACR;QAF4B,YAAM,GAAN,MAAM,CAAa;QAAW,oBAAc,GAAd,cAAc,CAAqC;QAFpG,iBAAW,GAAG,CAAC,KAAI,CAAC,MAAM,CAAC,CAAA;;IAIrC,CAAC;IApBa,yBAAM,GAApB,UACE,aAAgB,EAChB,cAAkC,EAClC,GAAW;QAEX,IAAM,OAAO,GAAG,IAAI,2BAAY,CAAC,aAAa,EAAE,cAAc,EAAE,GAAG,CAAC,CAAA;QAEpE,IAAM,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAA;QACzC,IAAM,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,iDAAuB,CAAC,MAAM,CAAC,CAAA;QAE9E,OAAO;YACL,YAAY,EAAE,MAAM,CAAC,YAAY,GAAG,cAAc,CAAC,YAAY;YAC/D,OAAO,EAAE,IAAI,kBAAkB,CAAC,MAAM,CAAC,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC;SACxE,CAAA;IACH,CAAC;IAOH,yBAAC;AAAD,CAAC,AAtBD,CAAwC,uBAAU,GAsBjD;AAtBY,gDAAkB"}

package/v1/data/metadata/v14/pallet/storage/MetadataV14StorageEntry.d.ts

@@ -0,0 +1,23 @@
+import { SubstrateProtocolConfiguration } from '../../../../../types/configuration';
+import { SCALEDecodeResult } from '../../../../scale/SCALEDecoder';
+import { SCALEArray } from '../../../../scale/type/SCALEArray';
+import { SCALEBytes } from '../../../../scale/type/SCALEBytes';
+import { SCALEClass } from '../../../../scale/type/SCALEClass';
+import { SCALEEnum } from '../../../../scale/type/SCALEEnum';
+import { SCALEString } from '../../../../scale/type/SCALEString';
+import { MetadataV14StorageEntryType } from './MetadataV14StorageEntryType';
+declare enum StorageEntryModifier {
+    Optional = 0,
+    Default = 1
+}
+export declare class MetadataV14StorageEntry extends SCALEClass {
+    readonly name: SCALEString;
+    readonly modifier: SCALEEnum<StorageEntryModifier>;
+    readonly type: MetadataV14StorageEntryType;
+    readonly fallback: SCALEBytes;
+    readonly docs: SCALEArray<SCALEString>;
+    static decode<C extends SubstrateProtocolConfiguration>(configuration: C, runtimeVersion: number | undefined, raw: string): SCALEDecodeResult<MetadataV14StorageEntry>;
+    protected scaleFields: (SCALEBytes | SCALEString | MetadataV14StorageEntryType | SCALEEnum<StorageEntryModifier>)[];
+    private constructor();
+}
+export {};

package/v1/data/metadata/v14/pallet/storage/MetadataV14StorageEntry.js

@@ -0,0 +1,55 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataV14StorageEntry = void 0;
+var SCALEDecoder_1 = require("../../../../scale/SCALEDecoder");
+var SCALEClass_1 = require("../../../../scale/type/SCALEClass");
+var SCALEString_1 = require("../../../../scale/type/SCALEString");
+var MetadataV14StorageEntryType_1 = require("./MetadataV14StorageEntryType");
+var StorageEntryModifier;
+(function (StorageEntryModifier) {
+    StorageEntryModifier[StorageEntryModifier["Optional"] = 0] = "Optional";
+    StorageEntryModifier[StorageEntryModifier["Default"] = 1] = "Default";
+})(StorageEntryModifier || (StorageEntryModifier = {}));
+var MetadataV14StorageEntry = /** @class */ (function (_super) {
+    __extends(MetadataV14StorageEntry, _super);
+    function MetadataV14StorageEntry(name, modifier, type, fallback, docs) {
+        var _this = _super.call(this) || this;
+        _this.name = name;
+        _this.modifier = modifier;
+        _this.type = type;
+        _this.fallback = fallback;
+        _this.docs = docs;
+        _this.scaleFields = [_this.name, _this.modifier, _this.type, _this.fallback];
+        return _this;
+    }
+    MetadataV14StorageEntry.decode = function (configuration, runtimeVersion, raw) {
+        var decoder = new SCALEDecoder_1.SCALEDecoder(configuration, runtimeVersion, raw);
+        var name = decoder.decodeNextString();
+        var modifier = decoder.decodeNextEnum(function (value) { return StorageEntryModifier[StorageEntryModifier[value]]; });
+        var type = decoder.decodeNextObject(MetadataV14StorageEntryType_1.MetadataV14StorageEntryType.decode);
+        var fallback = decoder.decodeNextBytes();
+        var docs = decoder.decodeNextArray(function (_configuration, _runtimeVersion, hex) { return SCALEString_1.SCALEString.decode(hex); });
+        return {
+            bytesDecoded: name.bytesDecoded + modifier.bytesDecoded + type.bytesDecoded + fallback.bytesDecoded + docs.bytesDecoded,
+            decoded: new MetadataV14StorageEntry(name.decoded, modifier.decoded, type.decoded, fallback.decoded, docs.decoded)
+        };
+    };
+    return MetadataV14StorageEntry;
+}(SCALEClass_1.SCALEClass));
+exports.MetadataV14StorageEntry = MetadataV14StorageEntry;
+//# sourceMappingURL=MetadataV14StorageEntry.js.map

package/v1/data/metadata/v14/pallet/storage/MetadataV14StorageEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataV14StorageEntry.js","sourceRoot":"","sources":["../../../../../../../src/v1/data/metadata/v14/pallet/storage/MetadataV14StorageEntry.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AACA,+DAAgF;AAGhF,gEAA8D;AAE9D,kEAAgE;AAEhE,6EAA2E;AAE3E,IAAK,oBAGJ;AAHD,WAAK,oBAAoB;IACvB,uEAAY,CAAA;IACZ,qEAAO,CAAA;AACT,CAAC,EAHI,oBAAoB,KAApB,oBAAoB,QAGxB;AAED;IAA6C,2CAAU;IAwBrD,iCACW,IAAiB,EACjB,QAAyC,EACzC,IAAiC,EACjC,QAAoB,EACpB,IAA6B;QALxC,YAOE,iBAAO,SACR;QAPU,UAAI,GAAJ,IAAI,CAAa;QACjB,cAAQ,GAAR,QAAQ,CAAiC;QACzC,UAAI,GAAJ,IAAI,CAA6B;QACjC,cAAQ,GAAR,QAAQ,CAAY;QACpB,UAAI,GAAJ,IAAI,CAAyB;QAP9B,iBAAW,GAAG,CAAC,KAAI,CAAC,IAAI,EAAE,KAAI,CAAC,QAAQ,EAAE,KAAI,CAAC,IAAI,EAAE,KAAI,CAAC,QAAQ,CAAC,CAAA;;IAU5E,CAAC;IA/Ba,8BAAM,GAApB,UACE,aAAgB,EAChB,cAAkC,EAClC,GAAW;QAEX,IAAM,OAAO,GAAG,IAAI,2BAAY,CAAC,aAAa,EAAE,cAAc,EAAE,GAAG,CAAC,CAAA;QAEpE,IAAM,IAAI,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAA;QACvC,IAAM,QAAQ,GAAG,OAAO,CAAC,cAAc,CACrC,UAAC,KAAK,IAAK,OAAA,oBAAoB,CAAC,oBAAoB,CAAC,KAAK,CAAsC,CAAC,EAAtF,CAAsF,CAClG,CAAA;QACD,IAAM,IAAI,GAAG,OAAO,CAAC,gBAAgB,CAAC,yDAA2B,CAAC,MAAM,CAAC,CAAA;QACzE,IAAM,QAAQ,GAAG,OAAO,CAAC,eAAe,EAAE,CAAA;QAC1C,IAAM,IAAI,GAAG,OAAO,CAAC,eAAe,CAAC,UAAC,cAAc,EAAE,eAAe,EAAE,GAAG,IAAK,OAAA,yBAAW,CAAC,MAAM,CAAC,GAAG,CAAC,EAAvB,CAAuB,CAAC,CAAA;QAEvG,OAAO;YACL,YAAY,EAAE,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY;YACvH,OAAO,EAAE,IAAI,uBAAuB,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC;SACnH,CAAA;IACH,CAAC;IAaH,8BAAC;AAAD,CAAC,AAjCD,CAA6C,uBAAU,GAiCtD;AAjCY,0DAAuB"}

package/v1/data/metadata/v14/pallet/storage/MetadataV14StorageEntryType.d.ts

@@ -0,0 +1,38 @@
+import { SubstrateProtocolConfiguration } from '../../../../../types/configuration';
+import { SCALEDecodeResult } from '../../../../scale/SCALEDecoder';
+import { SCALEArray } from '../../../../scale/type/SCALEArray';
+import { SCALEClass } from '../../../../scale/type/SCALEClass';
+import { SCALECompactInt } from '../../../../scale/type/SCALECompactInt';
+import { SCALEEnum } from '../../../../scale/type/SCALEEnum';
+import { SCALEType } from '../../../../scale/type/SCALEType';
+import { SubstrateStorageEntry, SubstrateStorageEntryHasher } from '../../../decorator/storage/SubstrateStorageEntry';
+declare enum StorageEntryType {
+    Plain = 0,
+    Map = 1
+}
+export declare abstract class MetadataV14StorageEntryType extends SCALEClass {
+    static decode<C extends SubstrateProtocolConfiguration>(configuration: C, runtimeVersion: number | undefined, raw: string): SCALEDecodeResult<MetadataV14StorageEntryType>;
+    protected abstract readonly type: SCALEEnum<StorageEntryType>;
+    protected abstract readonly _scaleFields: SCALEType[];
+    protected get scaleFields(): SCALEType[];
+    abstract decorate(palletName: string, prefix: string): SubstrateStorageEntry;
+}
+export declare class MetadataV14StorageEntryPlain extends MetadataV14StorageEntryType {
+    readonly id: SCALECompactInt;
+    static decode<C extends SubstrateProtocolConfiguration>(configuration: C, runtimeVersion: number | undefined, raw: string): SCALEDecodeResult<MetadataV14StorageEntryPlain>;
+    protected readonly type: SCALEEnum<StorageEntryType>;
+    protected readonly _scaleFields: SCALECompactInt[];
+    private constructor();
+    decorate(palletName: string, prefix: string): SubstrateStorageEntry;
+}
+export declare class MetadataV14StorageEntryMap extends MetadataV14StorageEntryType {
+    readonly hashers: SCALEArray<SCALEEnum<SubstrateStorageEntryHasher>>;
+    readonly key: SCALECompactInt;
+    readonly value: SCALECompactInt;
+    static decode<C extends SubstrateProtocolConfiguration>(configuration: C, runtimeVersion: number | undefined, raw: string): SCALEDecodeResult<MetadataV14StorageEntryMap>;
+    protected readonly type: SCALEEnum<StorageEntryType>;
+    protected readonly _scaleFields: (SCALECompactInt | SCALEArray<SCALEEnum<SubstrateStorageEntryHasher>>)[];
+    private constructor();
+    decorate(palletName: string, prefix: string): SubstrateStorageEntry;
+}
+export {};