@airgap/tezos 0.13.7-beta.11

package/protocol/types/fa/TezosFA2BalanceOfResponse.d.ts

@@ -0,0 +1,5 @@
+export interface TezosFA2BalanceOfResponse {
+    address: string;
+    tokenID: number;
+    amount: string;
+}

package/protocol/types/fa/TezosFA2BalanceOfResponse.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TezosFA2BalanceOfResponse.js.map

package/protocol/types/fa/TezosFA2BalanceOfResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TezosFA2BalanceOfResponse.js","sourceRoot":"","sources":["../../../../src/protocol/types/fa/TezosFA2BalanceOfResponse.ts"],"names":[],"mappings":""}

package/protocol/types/fa/TezosFA2TransferRequest.d.ts

@@ -0,0 +1,8 @@
+export interface TezosFA2TransferRequest {
+    from: string;
+    txs: {
+        to: string;
+        tokenID: number;
+        amount: string;
+    }[];
+}

package/protocol/types/fa/TezosFA2TransferRequest.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TezosFA2TransferRequest.js.map

package/protocol/types/fa/TezosFA2TransferRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TezosFA2TransferRequest.js","sourceRoot":"","sources":["../../../../src/protocol/types/fa/TezosFA2TransferRequest.ts"],"names":[],"mappings":""}

package/protocol/types/fa/TezosFA2UpdateOperatorRequest.d.ts

@@ -0,0 +1,6 @@
+export interface TezosFA2UpdateOperatorRequest {
+    operation: 'add' | 'remove';
+    owner: string;
+    operator: string;
+    tokenId: number;
+}

package/protocol/types/fa/TezosFA2UpdateOperatorRequest.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TezosFA2UpdateOperatorRequest.js.map

package/protocol/types/fa/TezosFA2UpdateOperatorRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TezosFA2UpdateOperatorRequest.js","sourceRoot":"","sources":["../../../../src/protocol/types/fa/TezosFA2UpdateOperatorRequest.ts"],"names":[],"mappings":""}

package/protocol/types/fa/TezosFATokenMetadata.d.ts

@@ -0,0 +1,6 @@
+export interface TezosFATokenMetadata {
+    symbol: string;
+    name: string;
+    decimals: number;
+    [key: string]: string | number | boolean;
+}

package/protocol/types/fa/TezosFATokenMetadata.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TezosFATokenMetadata.js.map

package/protocol/types/fa/TezosFATokenMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TezosFATokenMetadata.js","sourceRoot":"","sources":["../../../../src/protocol/types/fa/TezosFATokenMetadata.ts"],"names":[],"mappings":""}

package/protocol/types/kt/TezosKtAddressCursor.d.ts

@@ -0,0 +1,4 @@
+import { TezosAddressCursor } from '../TezosAddressCursor';
+export interface TezosKtAddressCursor extends TezosAddressCursor {
+    index?: number;
+}

package/protocol/types/kt/TezosKtAddressCursor.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TezosKtAddressCursor.js.map

package/protocol/types/kt/TezosKtAddressCursor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TezosKtAddressCursor.js","sourceRoot":"","sources":["../../../../src/protocol/types/kt/TezosKtAddressCursor.ts"],"names":[],"mappings":""}

package/protocol/types/kt/TezosKtAddressResult.d.ts

@@ -0,0 +1,5 @@
+import { TezosAddressResult } from '../TezosAddressResult';
+import { TezosKtAddressCursor } from './TezosKtAddressCursor';
+export interface TezosKtAddressResult extends TezosAddressResult {
+    cursor: TezosKtAddressCursor;
+}

package/protocol/types/kt/TezosKtAddressResult.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TezosKtAddressResult.js.map

package/protocol/types/kt/TezosKtAddressResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TezosKtAddressResult.js","sourceRoot":"","sources":["../../../../src/protocol/types/kt/TezosKtAddressResult.ts"],"names":[],"mappings":""}

package/protocol/types/micheline/MichelineNode.d.ts

@@ -0,0 +1,15 @@
+import { MichelsonGrammarData } from '../michelson/grammar/MichelsonGrammarData';
+import { MichelsonGrammarInstruction } from '../michelson/grammar/MichelsonGrammarInstruction';
+import { MichelsonGrammarType } from '../michelson/grammar/MichelsonGrammarType';
+export declare type MichelineGenericNode<T extends MichelsonGrammarType | MichelsonGrammarData> = MichelinePrimitive<'int'> | MichelinePrimitive<'string'> | MichelinePrimitive<'bytes'> | MichelinePrimitiveApplication<T> | MichelineGenericNode<T>[];
+export declare type MichelineNode = MichelineGenericNode<MichelsonGrammarType | MichelsonGrammarData>;
+export declare type MichelineTypeNode = MichelineGenericNode<MichelsonGrammarType>;
+export declare type MichelineDataNode = MichelineGenericNode<MichelsonGrammarData>;
+export declare type MichelineCodeNode = MichelineGenericNode<MichelsonGrammarInstruction>;
+export declare type MichelinePrimitiveType = 'int' | 'string' | 'bytes';
+export declare type MichelinePrimitive<T extends MichelinePrimitiveType> = Record<T, string>;
+export interface MichelinePrimitiveApplication<T extends MichelsonGrammarType | MichelsonGrammarData> {
+    prim: T;
+    args?: MichelineGenericNode<T>[];
+    annots?: string[];
+}

package/protocol/types/micheline/MichelineNode.js

@@ -0,0 +1,5 @@
+"use strict";
+// https://tezos.gitlab.io/whitedoc/micheline.html#bnf-grammar
+// https://tezos.gitlab.io/whitedoc/micheline.html#conversion-to-json
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=MichelineNode.js.map

package/protocol/types/micheline/MichelineNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MichelineNode.js","sourceRoot":"","sources":["../../../../src/protocol/types/micheline/MichelineNode.ts"],"names":[],"mappings":";AAAA,8DAA8D;AAC9D,qEAAqE"}

package/protocol/types/micheline/MichelineNodeUtils.d.ts

@@ -0,0 +1,6 @@
+import { MichelsonGrammarData } from '../michelson/grammar/MichelsonGrammarData';
+import { MichelsonGrammarType } from '../michelson/grammar/MichelsonGrammarType';
+import { MichelineGenericNode } from './MichelineNode';
+export declare class MichelineNodeUtils {
+    static normalize<T extends MichelsonGrammarData | MichelsonGrammarType>(node: MichelineGenericNode<T>): MichelineGenericNode<T>;
+}

package/protocol/types/micheline/MichelineNodeUtils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MichelineNodeUtils = void 0;
+var utils_1 = require("../utils");
+var MichelineNodeUtils = /** @class */ (function () {
+    function MichelineNodeUtils() {
+    }
+    MichelineNodeUtils.normalize = function (node) {
+        var _a;
+        if (utils_1.isMichelineSequence(node, false)) {
+            return node.map(function (value) { return MichelineNodeUtils.normalize(value); });
+        }
+        else if (utils_1.isAnyMichelinePrimitiveApplication(node)) {
+            var args = void 0;
+            if ((node.prim === 'pair' || node.prim === 'Pair') && node.args && node.args.length > 2) {
+                args = [
+                    MichelineNodeUtils.normalize(node.args[0]),
+                    MichelineNodeUtils.normalize({
+                        prim: node.prim,
+                        args: node.args.slice(1)
+                    })
+                ];
+            }
+            else {
+                args = (_a = node.args) === null || _a === void 0 ? void 0 : _a.map(function (arg) { return MichelineNodeUtils.normalize(arg); });
+            }
+            return {
+                prim: node.prim,
+                args: args,
+                annots: node.annots
+            };
+        }
+        else {
+            return node;
+        }
+    };
+    return MichelineNodeUtils;
+}());
+exports.MichelineNodeUtils = MichelineNodeUtils;
+//# sourceMappingURL=MichelineNodeUtils.js.map

package/protocol/types/micheline/MichelineNodeUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MichelineNodeUtils.js","sourceRoot":"","sources":["../../../../src/protocol/types/micheline/MichelineNodeUtils.ts"],"names":[],"mappings":";;;AAEA,kCAAkF;AAGlF;IAAA;IA2BA,CAAC;IA1Be,4BAAS,GAAvB,UAA+E,IAA6B;;QAC1G,IAAI,2BAAmB,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE;YACpC,OAAO,IAAI,CAAC,GAAG,CAAC,UAAC,KAAK,IAAK,OAAA,kBAAkB,CAAC,SAAS,CAAC,KAAK,CAAC,EAAnC,CAAmC,CAAC,CAAA;SAChE;aAAM,IAAI,0CAAkC,CAAC,IAAI,CAAC,EAAE;YACnD,IAAI,IAAI,SAAuC,CAAA;YAC/C,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;gBACvF,IAAI,GAAG;oBACL,kBAAkB,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;oBAC1C,kBAAkB,CAAC,SAAS,CAAC;wBAC3B,IAAI,EAAE,IAAI,CAAC,IAAI;wBACf,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;qBACzB,CAAC;iBACH,CAAA;aACF;iBAAM;gBACL,IAAI,SAAG,IAAI,CAAC,IAAI,0CAAE,GAAG,CAAC,UAAC,GAAG,IAAK,OAAA,kBAAkB,CAAC,SAAS,CAAC,GAAG,CAAC,EAAjC,CAAiC,CAAC,CAAA;aAClE;YAED,OAAO;gBACL,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,IAAI,MAAA;gBACJ,MAAM,EAAE,IAAI,CAAC,MAAM;aACpB,CAAA;SACF;aAAM;YACL,OAAO,IAAI,CAAA;SACZ;IACH,CAAC;IACH,yBAAC;AAAD,CAAC,AA3BD,IA2BC;AA3BY,gDAAkB"}

package/protocol/types/michelson/MichelsonType.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { MichelineDataNode } from '../micheline/MichelineNode';
+export declare abstract class MichelsonType {
+    name?: string | undefined;
+    constructor(name?: string | undefined);
+    abstract asRawValue(): any;
+    abstract toMichelineJSON(): MichelineDataNode;
+    eval(): void;
+    encode(): Buffer;
+    setName(name: string): void;
+}

package/protocol/types/michelson/MichelsonType.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MichelsonType = void 0;
+var errors_1 = require("@airgap/coinlib-core/errors");
+var coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
+var MichelsonType = /** @class */ (function () {
+    function MichelsonType(name) {
+        this.name = name;
+    }
+    MichelsonType.prototype.eval = function () {
+        // default implementation, no action required
+    };
+    MichelsonType.prototype.encode = function () {
+        throw new errors_1.UnsupportedError(coinlib_error_1.Domain.TEZOS, 'Encoding for this Michelson type is not supported');
+    };
+    MichelsonType.prototype.setName = function (name) {
+        this.name = name;
+    };
+    return MichelsonType;
+}());
+exports.MichelsonType = MichelsonType;
+//# sourceMappingURL=MichelsonType.js.map

package/protocol/types/michelson/MichelsonType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MichelsonType.js","sourceRoot":"","sources":["../../../../src/protocol/types/michelson/MichelsonType.ts"],"names":[],"mappings":";;;AAAA,sDAA8D;AAC9D,2EAAkE;AAIlE;IACE,uBAAmB,IAAa;QAAb,SAAI,GAAJ,IAAI,CAAS;IAAG,CAAC;IAK7B,4BAAI,GAAX;QACE,6CAA6C;IAC/C,CAAC;IAEM,8BAAM,GAAb;QACE,MAAM,IAAI,yBAAgB,CAAC,sBAAM,CAAC,KAAK,EAAE,mDAAmD,CAAC,CAAA;IAC/F,CAAC;IAEM,+BAAO,GAAd,UAAe,IAAY;QACzB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;IACH,oBAAC;AAAD,CAAC,AAjBD,IAiBC;AAjBqB,sCAAa"}

package/protocol/types/michelson/MichelsonTypeMeta.d.ts

@@ -0,0 +1,33 @@
+import { Lazy } from '@airgap/coinlib-core/data/Lazy';
+import { MichelinePrimitiveApplication, MichelineTypeNode } from '../../types/micheline/MichelineNode';
+import { MichelsonGrammarType } from '../../types/michelson/grammar/MichelsonGrammarType';
+import { MichelsonType } from './MichelsonType';
+export declare enum MichelsonAnnotationPrefix {
+    TYPE = ":",
+    VARIABLE = "@",
+    FIELD = "%"
+}
+export interface MichelsonTypeMetaCreateValueConfiguration {
+    lazyEval?: boolean;
+    readAnnots?: boolean;
+    beforeNext?(meta: MichelsonTypeMeta, raw: unknown): void;
+    onNext?(meta: MichelsonTypeMeta, raw: unknown, value: MichelsonType): void;
+}
+export declare class MichelsonTypeMeta {
+    readonly type: MichelsonGrammarType;
+    readonly parent?: MichelsonGenericTypeMeta | undefined;
+    readonly annots: string[];
+    constructor(type: MichelsonGrammarType, parent?: MichelsonGenericTypeMeta | undefined, annots?: string[]);
+    static fromMichelineNode(node: MichelineTypeNode): MichelsonTypeMeta | undefined;
+    static fromMichelinePrimitiveApplication(primitiveApplication: MichelinePrimitiveApplication<any>, parent?: MichelsonGenericTypeMeta): MichelsonTypeMeta;
+    static from(type: MichelsonGrammarType, annots: string[], args: MichelinePrimitiveApplication<any>[], parent?: MichelsonGenericTypeMeta): MichelsonTypeMeta;
+    createValue(value: unknown, configuration?: MichelsonTypeMetaCreateValueConfiguration): MichelsonType;
+    getAnnotation(...prefixes: MichelsonAnnotationPrefix[]): string | undefined;
+    protected getMichelsonValue(raw: unknown, _configuration?: MichelsonTypeMetaCreateValueConfiguration): MichelsonType;
+    protected getRawValue(value: unknown): unknown;
+}
+export declare class MichelsonGenericTypeMeta extends MichelsonTypeMeta {
+    readonly generics: Lazy<MichelsonTypeMeta>[];
+    constructor(type: MichelsonGrammarType, genericTypes: MichelinePrimitiveApplication<any>[], parent?: MichelsonGenericTypeMeta, annots?: string[]);
+    protected getMichelsonValue(raw: unknown, configuration?: MichelsonTypeMetaCreateValueConfiguration): MichelsonType;
+}

package/protocol/types/michelson/MichelsonTypeMeta.js

@@ -0,0 +1,132 @@
+"use strict";
+// tslint:disable: max-classes-per-file
+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) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MichelsonGenericTypeMeta = exports.MichelsonTypeMeta = exports.MichelsonAnnotationPrefix = void 0;
+var Lazy_1 = require("@airgap/coinlib-core/data/Lazy");
+var utils_1 = require("../utils");
+var MichelsonType_1 = require("./MichelsonType");
+var MichelsonTypeUtils_1 = require("./MichelsonTypeUtils");
+var MichelsonAnnotationPrefix;
+(function (MichelsonAnnotationPrefix) {
+    MichelsonAnnotationPrefix["TYPE"] = ":";
+    MichelsonAnnotationPrefix["VARIABLE"] = "@";
+    MichelsonAnnotationPrefix["FIELD"] = "%";
+})(MichelsonAnnotationPrefix = exports.MichelsonAnnotationPrefix || (exports.MichelsonAnnotationPrefix = {}));
+var MichelsonTypeMeta = /** @class */ (function () {
+    function MichelsonTypeMeta(type, parent, annots) {
+        if (annots === void 0) { annots = []; }
+        this.type = type;
+        this.parent = parent;
+        this.annots = annots;
+    }
+    MichelsonTypeMeta.fromMichelineNode = function (node) {
+        if (!utils_1.isAnyMichelinePrimitiveApplication(node)) {
+            return undefined;
+        }
+        return this.fromMichelinePrimitiveApplication(node);
+    };
+    MichelsonTypeMeta.fromMichelinePrimitiveApplication = function (primitiveApplication, parent) {
+        var _a, _b, _c;
+        return this.from(primitiveApplication.prim, (_a = primitiveApplication.annots) !== null && _a !== void 0 ? _a : [], (_c = (_b = primitiveApplication.args) === null || _b === void 0 ? void 0 : _b.filter(utils_1.isAnyMichelinePrimitiveApplication)) !== null && _c !== void 0 ? _c : [], parent);
+    };
+    MichelsonTypeMeta.from = function (type, annots, args, parent) {
+        return args.length === 0 ? new MichelsonTypeMeta(type, parent, annots) : new MichelsonGenericTypeMeta(type, args, parent, annots);
+    };
+    MichelsonTypeMeta.prototype.createValue = function (value, configuration) {
+        var _a, _b;
+        if (configuration === void 0) { configuration = {}; }
+        if (value instanceof MichelsonType_1.MichelsonType) {
+            return value;
+        }
+        var raw = this.getRawValue(value);
+        if (configuration.beforeNext) {
+            configuration.beforeNext(this, raw);
+        }
+        var michelsonValue = this.getMichelsonValue(raw, configuration);
+        if (!((_a = configuration.lazyEval) !== null && _a !== void 0 ? _a : true)) {
+            michelsonValue.eval();
+        }
+        if ((_b = configuration.readAnnots) !== null && _b !== void 0 ? _b : true) {
+            var name_1 = this.getAnnotation(MichelsonAnnotationPrefix.FIELD, MichelsonAnnotationPrefix.TYPE);
+            if (name_1) {
+                michelsonValue.setName(name_1);
+            }
+        }
+        if (configuration.onNext) {
+            configuration.onNext(this, raw, michelsonValue);
+        }
+        return michelsonValue;
+    };
+    MichelsonTypeMeta.prototype.getAnnotation = function () {
+        var prefixes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            prefixes[_i] = arguments[_i];
+        }
+        var _loop_1 = function (annot) {
+            var matchedPrefix = prefixes.find(function (prefix) {
+                return annot.startsWith(prefix);
+            });
+            if (matchedPrefix !== undefined) {
+                return { value: annot.slice(matchedPrefix.length) };
+            }
+        };
+        for (var _a = 0, _b = this.annots; _a < _b.length; _a++) {
+            var annot = _b[_a];
+            var state_1 = _loop_1(annot);
+            if (typeof state_1 === "object")
+                return state_1.value;
+        }
+        return undefined;
+    };
+    MichelsonTypeMeta.prototype.getMichelsonValue = function (raw, _configuration) {
+        if (_configuration === void 0) { _configuration = {}; }
+        return MichelsonTypeUtils_1.MichelsonTypeUtils.create(this.type, raw);
+    };
+    MichelsonTypeMeta.prototype.getRawValue = function (value) {
+        var argName = this.getAnnotation(MichelsonAnnotationPrefix.TYPE, MichelsonAnnotationPrefix.FIELD);
+        return value instanceof Object && argName && argName in value ? value[argName] : value;
+    };
+    return MichelsonTypeMeta;
+}());
+exports.MichelsonTypeMeta = MichelsonTypeMeta;
+var MichelsonGenericTypeMeta = /** @class */ (function (_super) {
+    __extends(MichelsonGenericTypeMeta, _super);
+    function MichelsonGenericTypeMeta(type, genericTypes, parent, annots) {
+        if (annots === void 0) { annots = []; }
+        var _this = _super.call(this, type, parent, annots) || this;
+        _this.generics = genericTypes.map(function (type) {
+            return new Lazy_1.Lazy(function () { return MichelsonTypeMeta.fromMichelinePrimitiveApplication(type, _this); });
+        });
+        return _this;
+    }
+    MichelsonGenericTypeMeta.prototype.getMichelsonValue = function (raw, configuration) {
+        if (configuration === void 0) { configuration = {}; }
+        var genericFactories = this.generics.map(function (genericMeta) {
+            return function (genericValue) { return genericMeta.get().createValue(genericValue, configuration); };
+        });
+        return MichelsonTypeUtils_1.MichelsonTypeUtils.create.apply(MichelsonTypeUtils_1.MichelsonTypeUtils, __spreadArrays([this.type, raw], genericFactories));
+    };
+    return MichelsonGenericTypeMeta;
+}(MichelsonTypeMeta));
+exports.MichelsonGenericTypeMeta = MichelsonGenericTypeMeta;
+//# sourceMappingURL=MichelsonTypeMeta.js.map

package/protocol/types/michelson/MichelsonTypeMeta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MichelsonTypeMeta.js","sourceRoot":"","sources":["../../../../src/protocol/types/michelson/MichelsonTypeMeta.ts"],"names":[],"mappings":"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"}

package/protocol/types/michelson/MichelsonTypeUtils.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { MichelsonGrammarType } from './grammar/MichelsonGrammarType';
+import { MichelsonType } from './MichelsonType';
+export declare class MichelsonTypeUtils {
+    static readonly literalPrefixes: {
+        int: Buffer;
+        string: Buffer;
+        bytes: Buffer;
+    };
+    static readonly primPrefixes: {
+        pair: Buffer;
+    };
+    static readonly sequencePrefixes: {
+        list: Buffer;
+    };
+    static decode(encoded: string | Buffer | Uint8Array): MichelsonType | undefined;
+    private static readonly michelsonTypeFactories;
+    static create(type: MichelsonGrammarType, ...args: unknown[]): MichelsonType;
+}