@taquito/michelson-encoder 24.2.0 → 24.3.0-beta.1

package/dist/taquito-michelson-encoder.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito-michelson-encoder.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito-michelson-encoder.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/michelson-map.d.ts

@@ -2,7 +2,7 @@ import { MichelsonV1Expression } from '@taquito/rpc';
 import { TaquitoError } from '@taquito/core';
 /**
  *  @category Error
- *  @description Error that indicates an invalid map type being passed or used
+ *  Error that indicates an invalid map type being passed or used
  */
 export declare class InvalidMapTypeError extends TaquitoError {
     readonly mapType: any;
@@ -13,7 +13,7 @@ declare const michelsonMapTypeSymbol: unique symbol;
 export type MichelsonMapKey = Array<any> | object | string | boolean | number | null;
 /**
  *  @category Error
- *  @description Error that indicates a map type mismatch, where an attempt to set a key or value in a Map doesn't match the defined type of the Map
+ *  Error that indicates a map type mismatch, where an attempt to set a key or value in a Map doesn't match the defined type of the Map
  */
 export declare class MapTypecheckError extends TaquitoError {
     readonly value: any;
@@ -23,7 +23,7 @@ export declare class MapTypecheckError extends TaquitoError {
     constructor(value: any, type: any, objectType: 'key' | 'value', reason: any);
 }
 /**
- * @description Michelson Map is an abstraction over the michelson native map. It supports complex Pair as key
+ * Michelson Map is an abstraction over the michelson native map. It supports complex Pair as key
  */
 export declare class MichelsonMap<K extends MichelsonMapKey, T> {
     private valueMap;
@@ -60,13 +60,13 @@ export declare class MichelsonMap<K extends MichelsonMapKey, T> {
     get(key: K): T | undefined;
     /**
      *
-     * @description Set a key and a value in the MichelsonMap. If the key already exists, override the current value.
+     * Set a key and a value in the MichelsonMap. If the key already exists, override the current value.
      *
      * @example map.set("myKey", "myValue") // Using a string as key
      *
      * @example map.set({0: "test", 1: "test1"}, "myValue") // Using a pair as key
      *
-     * @warn The same key can be represented in multiple ways, depending on the type of the key. This duplicate key situation will cause a runtime error (duplicate key) when sending the map data to the Tezos RPC node.
+     * @remarks The same key can be represented in multiple ways, depending on the type of the key. This duplicate key situation will cause a runtime error (duplicate key) when sending the map data to the Tezos RPC node.
      *
      * For example, consider a contract with a map whose key is of type boolean.  If you set the following values in MichelsonMap: map.set(false, "myValue") and map.set(null, "myValue").
      *

package/dist/types/schema/errors.d.ts

@@ -1,18 +1,18 @@
 import { InvalidViewParameterError, TaquitoError } from '@taquito/core';
 /**
  *  @category Error
- *  @description Error that indicates a failure when encoding (transforming JS parameter into JSON Michelson) the parameter of the view
+ *  Error that indicates a failure when encoding (transforming JS parameter into JSON Michelson) the parameter of the view
  */
 export declare class ParameterEncodingError extends InvalidViewParameterError {
     readonly viewName: string;
     readonly sigs: any;
     readonly args: any;
-    readonly cause?: any;
-    constructor(viewName: string, sigs: any, args: any, cause?: any);
+    readonly cause?: any | undefined;
+    constructor(viewName: string, sigs: any, args: any, cause?: any | undefined);
 }
 /**
  *  @category Error
- *  @description Error that indicates an invalid on-chain view found on the script
+ *  Error that indicates an invalid on-chain view found on the script
  */
 export declare class InvalidScriptError extends TaquitoError {
     readonly script: any;
@@ -22,7 +22,7 @@ export declare class InvalidScriptError extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error that indicates an invalid RPC response being passed or used
+ *  Error that indicates an invalid RPC response being passed or used
  */
 export declare class InvalidRpcResponseError extends TaquitoError {
     readonly script: any;
@@ -32,7 +32,7 @@ export declare class InvalidRpcResponseError extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error that indicates an invalid big map schema being passed or used
+ *  Error that indicates an invalid big map schema being passed or used
  */
 export declare class InvalidBigMapSchemaError extends TaquitoError {
     message: string;
@@ -41,7 +41,7 @@ export declare class InvalidBigMapSchemaError extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error that indicates an invalid big map diff being passed or used
+ *  Error that indicates an invalid big map diff being passed or used
  */
 export declare class InvalidBigMapDiffError extends TaquitoError {
     message: string;
@@ -51,7 +51,7 @@ export declare class InvalidBigMapDiffError extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error that indicates a failure when trying to encode big maps
+ *  Error that indicates a failure when trying to encode big maps
  */
 export declare class BigMapEncodingError extends TaquitoError {
     readonly details: any;
@@ -62,19 +62,19 @@ export declare class BigMapEncodingError extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error that indicates a failure when trying to encode storage
+ *  Error that indicates a failure when trying to encode storage
  */
 export declare class StorageEncodingError extends TaquitoError {
     details: any;
     readonly schema: any;
     readonly value: any;
-    readonly semantics?: any;
+    readonly semantics?: any | undefined;
     name: string;
-    constructor(obj: string, details: any, schema: any, value: any, semantics?: any);
+    constructor(obj: string, details: any, schema: any, value: any, semantics?: any | undefined);
 }
 /**
  *  @category Error
- *  @description General error that indicates a function not being passed a necessary argument
+ *  General error that indicates a function not being passed a necessary argument
  */
 export declare class MissingArgumentError extends TaquitoError {
     message: string;

package/dist/types/schema/parameter.d.ts

@@ -2,13 +2,13 @@ import { Semantic, SemanticEncoding } from '../tokens/token';
 import { ScriptResponse, MichelsonV1Expression } from '@taquito/rpc';
 import { TokenSchema } from './types';
 /**
- * @warn Our current smart contract abstraction feature is currently in preview. It's API is not final, and it may not cover every use case (yet). We will greatly appreciate any feedback on this feature.
+ * @remarks Our current smart contract abstraction feature is currently in preview. It's API is not final, and it may not cover every use case (yet). We will greatly appreciate any feedback on this feature.
  */
 export declare class ParameterSchema {
     private root;
     /**
      *
-     * @description Create an instance of ParameterSchema from a contract script
+     * Create an instance of ParameterSchema from a contract script
      *
      * @param val contract script obtained from the RPC
      * @returns ParameterSchema
@@ -18,36 +18,36 @@ export declare class ParameterSchema {
         script: ScriptResponse;
     }): ParameterSchema;
     /**
-     * @description Check if the Contract parameter is multiple entry point or not
+     * Check if the Contract parameter is multiple entry point or not
      */
     get isMultipleEntryPoint(): boolean;
     /**
-     * @description Check if the Contract parameter has an annotation or not
+     * Check if the Contract parameter has an annotation or not
      */
     get hasAnnotation(): boolean;
     /**
-     * @description Return the schema of the parameter of a specific entry point
-     * @throws {@link InvalidTokenError}
+     * Return the schema of the parameter of a specific entry point
+     * @throws InvalidTokenError
      */
     constructor(val: MichelsonV1Expression);
     /**
-     * @description Returns the javascript object equivalent of the Micheline value provided
+     * Returns the javascript object equivalent of the Micheline value provided
      */
     Execute(val: any, semantics?: Semantic): any;
     /**
-     * @description Returns a micheline formatted object for the values provided
-     * @throws {@link TokenValidationError}
+     * Returns a micheline formatted object for the values provided
+     * @throws TokenValidationError
      * @throws {@link ParameterEncodingError}
      */
     Encode(...args: any[]): any;
     /**
-     * @description Returns a micheline formatted object for the javascript object provided
-     * @throws {@link TokenValidationError}
+     * Returns a micheline formatted object for the javascript object provided
+     * @throws TokenValidationError
      * @throws {@link ParameterEncodingError}
      */
     EncodeObject(value?: any, semantics?: SemanticEncoding): any;
     /**
-     * @description Produce a schema grouping together all the entry points of a contract.
+     * Produce a schema grouping together all the entry points of a contract.
      */
     generateSchema(): TokenSchema;
     ExtractSignatures(): TokenSchema[][];

package/dist/types/schema/storage.d.ts

@@ -4,7 +4,7 @@ import { TokenSchema } from './types';
 declare const schemaTypeSymbol: unique symbol;
 export declare function deepEqual(a: MichelsonV1Expression | undefined, b: MichelsonV1Expression | undefined): boolean;
 /**
- * @warn Our current smart contract abstraction feature is currently in preview. Its API is not final, and it may not cover every use case (yet). We will greatly appreciate any feedback on this feature.
+ * @remarks Our current smart contract abstraction feature is currently in preview. Its API is not final, and it may not cover every use case (yet). We will greatly appreciate any feedback on this feature.
  */
 export declare class Schema {
     readonly val: MichelsonV1Expression;
@@ -23,7 +23,7 @@ export declare class Schema {
     private removeTopLevelAnnotation;
     Execute(val: any, semantics?: Semantic): any;
     /**
-     * @description Validates that a value matches the schema type.
+     * Validates that a value matches the schema type.
      * Performs type checking with special handling for BigMap, Ticket, and nested Map tokens.
      *
      * @param val - The value to validate against the schema
@@ -53,17 +53,17 @@ export declare class Schema {
         };
     };
     /**
-     * @throws {@link TokenValidationError}
+     * @throws TokenValidationError
      * @throws {@link StorageEncodingError}
      */
     Encode(value?: any, semantics?: SemanticEncoding): any;
     /**
-     * @description Produce a representation of the storage schema.
+     * Produce a representation of the storage schema.
      * Note: Provide guidance on how to write the storage object for the origination operation with Taquito.
      */
     generateSchema(): TokenSchema;
     /**
-     * @description Look up in top-level pairs of the storage to find a value matching the specified type
+     * Look up in top-level pairs of the storage to find a value matching the specified type
      *
      * @returns The first value found that match the type or `undefined` if no value is found
      *
@@ -77,7 +77,7 @@ export declare class Schema {
      */
     private findValue;
     /**
-     * @description Look up the schema to find any occurrence of a particular token.
+     * Look up the schema to find any occurrence of a particular token.
      *
      * @returns an array of tokens of the specified kind or an empty array if no token was found
      *

package/dist/types/schema/view-schema.d.ts

@@ -9,7 +9,7 @@ export declare class ViewSchema {
     private rootReturnType;
     /**
      *
-     * @description Create an instance of ViewSchema for each view in a script
+     * Create an instance of ViewSchema for each view in a script
      *
      * @param val contract script obtained from the RPC
      * @returns array of ViewSchema or empty array if there is no view in the contract
@@ -24,7 +24,7 @@ export declare class ViewSchema {
     constructor(viewArgs: MichelsonV1Expression[] | undefined);
     /**
      *
-     * @description Transform the view parameter into Michelson
+     * Transform the view parameter into Michelson
      *
      * @param args parameter of the view in js format
      * @returns parameter of the view in Michelson
@@ -33,7 +33,7 @@ export declare class ViewSchema {
     encodeViewArgs(args: any): any;
     /**
      *
-     * @description Transform the view result from Michelson to readable data
+     * Transform the view result from Michelson to readable data
      *
      * @param val result of the view in JSON Michelson
      * @param semantics optional semantics to override the default decoding behavior
@@ -42,12 +42,12 @@ export declare class ViewSchema {
     decodeViewResult(val: any, semantics?: Semantic): any;
     /**
      *
-     * @description Return the signature of the view parameter
+     * Return the signature of the view parameter
      */
     extractArgsSchema(): import("./types").TokenSchema;
     /**
      *
-     * @description Return the format of the view result
+     * Return the format of the view result
      */
     extractResultSchema(): import("./types").TokenSchema;
 }

package/dist/types/tokens/bigmap.d.ts

@@ -2,7 +2,7 @@ import { BigMapTokenSchema } from '../schema/types';
 import { ComparableToken, Semantic, SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing Big Map types
+ *  Error that indicates a failure happening when parsing encoding/executing Big Map types
  */
 export declare class BigMapValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/bls12-381-fr.d.ts

@@ -2,7 +2,7 @@ import { BaseTokenSchema } from '../schema/types';
 import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a BLS12-381 scalar field Fr
+ *  Error that indicates a failure happening when parsing encoding/executing a BLS12-381 scalar field Fr
  */
 export declare class Bls12381frValidationError extends TokenValidationError {
     value: any;
@@ -43,7 +43,7 @@ export declare class Bls12381frToken extends Token {
      * @throws {@link Bls12381frValidationError}
      */
     EncodeObject(val: string | Uint8Array | number, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1ExpressionExtended | import("@taquito/rpc").MichelsonV1ExpressionBase | import("@taquito/rpc").MichelsonV1Expression[] | {
-        bytes: string | number | Uint8Array;
+        bytes: string | number | Uint8Array<ArrayBufferLike>;
     };
     Execute(val: any): string;
     generateSchema(): BaseTokenSchema;

package/dist/types/tokens/bls12-381-g1.d.ts

@@ -2,7 +2,7 @@ import { BaseTokenSchema } from '../schema/types';
 import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a BLS12-381 curve G1
+ *  Error that indicates a failure happening when parsing encoding/executing a BLS12-381 curve G1
  */
 export declare class Bls12381g1ValidationError extends TokenValidationError {
     value: any;
@@ -39,7 +39,7 @@ export declare class Bls12381g1Token extends Token {
      * @throws {@link Bls12381g1ValidationError}
      */
     EncodeObject(val: string | Uint8Array, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1ExpressionExtended | import("@taquito/rpc").MichelsonV1ExpressionBase | import("@taquito/rpc").MichelsonV1Expression[] | {
-        bytes: string | Uint8Array;
+        bytes: string | Uint8Array<ArrayBufferLike>;
     };
     Execute(val: any): string;
     generateSchema(): BaseTokenSchema;

package/dist/types/tokens/bls12-381-g2.d.ts

@@ -2,7 +2,7 @@ import { BaseTokenSchema } from '../schema/types';
 import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a BLS12-381 curve G2
+ *  Error that indicates a failure happening when parsing encoding/executing a BLS12-381 curve G2
  */
 export declare class Bls12381g2ValidationError extends TokenValidationError {
     value: any;
@@ -39,7 +39,7 @@ export declare class Bls12381g2Token extends Token {
      * @throws {@link Bls12381g2ValidationError}
      */
     EncodeObject(val: string | Uint8Array, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1ExpressionExtended | import("@taquito/rpc").MichelsonV1ExpressionBase | import("@taquito/rpc").MichelsonV1Expression[] | {
-        bytes: string | Uint8Array;
+        bytes: string | Uint8Array<ArrayBufferLike>;
     };
     Execute(val: any): string;
     generateSchema(): BaseTokenSchema;

package/dist/types/tokens/chain-id.d.ts

@@ -2,7 +2,7 @@ import { Token, TokenFactory, ComparableToken, TokenValidationError, SemanticEnc
 import { BaseTokenSchema } from '../schema/types';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a ChainID
+ *  Error that indicates a failure happening when parsing encoding/executing a ChainID
  */
 export declare class ChainIDValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/chest-key.d.ts

@@ -2,7 +2,7 @@ import { BaseTokenSchema } from '../schema/types';
 import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a Chest Key
+ *  Error that indicates a failure happening when parsing encoding/executing a Chest Key
  */
 export declare class ChestKeyValidationError extends TokenValidationError {
     value: any;
@@ -39,7 +39,7 @@ export declare class ChestKeyToken extends Token {
      * @throws {@link ChestKeyValidationError}
      */
     EncodeObject(val: string | Uint8Array, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1ExpressionExtended | import("@taquito/rpc").MichelsonV1ExpressionBase | import("@taquito/rpc").MichelsonV1Expression[] | {
-        bytes: string | Uint8Array;
+        bytes: string | Uint8Array<ArrayBufferLike>;
     };
     Execute(val: any): string;
     generateSchema(): BaseTokenSchema;

package/dist/types/tokens/chest.d.ts

@@ -2,7 +2,7 @@ import { BaseTokenSchema } from '../schema/types';
 import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a Chest
+ *  Error that indicates a failure happening when parsing encoding/executing a Chest
  */
 export declare class ChestValidationError extends TokenValidationError {
     value: any;
@@ -39,7 +39,7 @@ export declare class ChestToken extends Token {
      * @throws {@link ChestKeyValidationError}
      */
     EncodeObject(val: string | Uint8Array, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1ExpressionExtended | import("@taquito/rpc").MichelsonV1ExpressionBase | import("@taquito/rpc").MichelsonV1Expression[] | {
-        bytes: string | Uint8Array;
+        bytes: string | Uint8Array<ArrayBufferLike>;
     };
     Execute(val: any): string;
     generateSchema(): BaseTokenSchema;

package/dist/types/tokens/comparable/address.d.ts

@@ -2,7 +2,7 @@ import { Token, TokenFactory, ComparableToken, TokenValidationError, SemanticEnc
 import { BaseTokenSchema } from '../../schema/types';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing an Address
+ *  Error that indicates a failure happening when parsing encoding/executing an Address
  */
 export declare class AddressValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/comparable/bytes.d.ts

@@ -2,7 +2,7 @@ import { BaseTokenSchema } from '../../schema/types';
 import { TokenFactory, ComparableToken, TokenValidationError, Token, SemanticEncoding } from '../token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing Bytes
+ *  Error that indicates a failure happening when parsing encoding/executing Bytes
  */
 export declare class BytesValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/comparable/int.d.ts

@@ -2,7 +2,7 @@ import { Token, TokenFactory, ComparableToken, TokenValidationError, SemanticEnc
 import { BaseTokenSchema } from '../../schema/types';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing Int
+ *  Error that indicates a failure happening when parsing encoding/executing Int
  */
 export declare class IntValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/comparable/key_hash.d.ts

@@ -2,7 +2,7 @@ import { Token, TokenFactory, ComparableToken, TokenValidationError, SemanticEnc
 import { BaseTokenSchema } from '../../schema/types';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing Key Hash
+ *  Error that indicates a failure happening when parsing encoding/executing Key Hash
  */
 export declare class KeyHashValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/comparable/mutez.d.ts

@@ -3,7 +3,7 @@ import BigNumber from 'bignumber.js';
 import { BaseTokenSchema } from '../../schema/types';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing Mutez
+ *  Error that indicates a failure happening when parsing encoding/executing Mutez
  */
 export declare class MutezValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/comparable/nat.d.ts

@@ -3,7 +3,7 @@ import BigNumber from 'bignumber.js';
 import { BaseTokenSchema } from '../../schema/types';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing Nat
+ *  Error that indicates a failure happening when parsing encoding/executing Nat
  */
 export declare class NatValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/constant.d.ts

@@ -2,7 +2,7 @@ import { ConstantTokenSchema } from '../schema/types';
 import { Semantic, SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding a Global Constant
+ *  Error that indicates a failure happening when parsing encoding a Global Constant
  */
 export declare class GlobalConstantEncodingError extends TokenValidationError {
     value: any;
@@ -12,7 +12,7 @@ export declare class GlobalConstantEncodingError extends TokenValidationError {
 }
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing executing a Global Constant
+ *  Error that indicates a failure happening when parsing executing a Global Constant
  */
 export declare class GlobalConstantDecodingError extends TokenValidationError {
     value: any;

package/dist/types/tokens/contract.d.ts

@@ -2,7 +2,7 @@ import { ContractTokenSchema } from '../schema/types';
 import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a Contract
+ *  Error that indicates a failure happening when parsing encoding/executing a Contract
  */
 export declare class ContractValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/createToken.d.ts

@@ -2,7 +2,7 @@ import { Token } from './token';
 import { TaquitoError } from '@taquito/core';
 /**
  *  @category Error
- *  @description Error that indicates a script having an invalid type or it being unsupported by the Michelson Encoder. Note some protocol changes might affect this, we encourage users to open an issue so we can look into implementing support for said types.
+ *  Error that indicates a script having an invalid type or it being unsupported by the Michelson Encoder. Note some protocol changes might affect this, we encourage users to open an issue so we can look into implementing support for said types.
  */
 export declare class InvalidTokenError extends TaquitoError {
     message: string;
@@ -12,7 +12,7 @@ export declare class InvalidTokenError extends TaquitoError {
 }
 /**
  *
- * @description Create a token from a value
+ * Create a token from a value
  * @throws {@link InvalidTokenError} If the value passed is not supported by the Michelson Encoder
  */
 export declare function createToken(val: any, idx: number, parentTokenType?: 'Or' | 'Pair' | 'Other' | undefined): Token;

package/dist/types/tokens/key.d.ts

@@ -2,7 +2,7 @@ import { ComparableToken, SemanticEncoding, Token, TokenFactory, TokenValidation
 import { BaseTokenSchema } from '../schema/types';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a Key
+ *  Error that indicates a failure happening when parsing encoding/executing a Key
  */
 export declare class KeyValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/list.d.ts

@@ -2,7 +2,7 @@ import { ListTokenSchema } from '../schema/types';
 import { Token, TokenFactory, Semantic, TokenValidationError, SemanticEncoding } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a List
+ *  Error that indicates a failure happening when parsing encoding/executing a List
  */
 export declare class ListValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/map.d.ts

@@ -2,7 +2,7 @@ import { MapTokenSchema } from '../schema/types';
 import { ComparableToken, Semantic, SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a Map
+ *  Error that indicates a failure happening when parsing encoding/executing a Map
  */
 export declare class MapValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/never.d.ts

@@ -2,7 +2,7 @@ import { BaseTokenSchema } from '../schema/types';
 import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a Never Token
+ *  Error that indicates a failure happening when parsing encoding/executing a Never Token
  */
 export declare class NeverTokenError extends TokenValidationError {
     value: any;

package/dist/types/tokens/or.d.ts

@@ -2,7 +2,7 @@ import { OrTokenSchema } from '../schema/types';
 import { Token, TokenFactory, Semantic, ComparableToken, SemanticEncoding, TokenValidationError } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing an OrToken
+ *  Error that indicates a failure happening when parsing encoding/executing an OrToken
  */
 export declare class OrValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/pair.d.ts

@@ -4,7 +4,7 @@ import { MichelsonV1Expression, MichelsonV1ExpressionExtended } from '@taquito/r
 import { TaquitoError } from '@taquito/core';
 /**
  *  @category Error
- *  @description Error that indicates in invalid token argument being passed
+ *  Error that indicates in invalid token argument being passed
  */
 export declare class TokenArgumentValidationError extends TaquitoError {
     message: string;
@@ -13,7 +13,7 @@ export declare class TokenArgumentValidationError extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error that indicates a failure occurring when doing a comparison of tokens
+ *  Error that indicates a failure occurring when doing a comparison of tokens
  */
 export declare class TokenComparisonError extends TaquitoError {
     val1: string;

package/dist/types/tokens/sapling-state.d.ts

@@ -2,7 +2,7 @@ import { SaplingStateTokenSchema } from '../schema/types';
 import { Semantic, SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a Sapling State
+ *  Error that indicates a failure happening when parsing encoding/executing a Sapling State
  */
 export declare class SaplingStateValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/sapling-transaction-deprecated.d.ts

@@ -2,7 +2,7 @@ import { SaplingTransactionDeprecatedTokenSchema } from '../schema/types';
 import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a Sapling Transaction Deprecated
+ *  Error that indicates a failure happening when parsing encoding/executing a Sapling Transaction Deprecated
  */
 export declare class SaplingTransactionDeprecatedValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/sapling-transaction.d.ts

@@ -2,7 +2,7 @@ import { SaplingTransactionTokenSchema } from '../schema/types';
 import { SemanticEncoding, Token, TokenFactory, TokenValidationError } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a Sapling Transaction
+ *  Error that indicates a failure happening when parsing encoding/executing a Sapling Transaction
  */
 export declare class SaplingTransactionValidationError extends TokenValidationError {
     value: any;

package/dist/types/tokens/set.d.ts

@@ -2,7 +2,7 @@ import { SetTokenSchema } from '../schema/types';
 import { Token, TokenFactory, Semantic, TokenValidationError, ComparableToken, SemanticEncoding } from './token';
 /**
  *  @category Error
- *  @description Error that indicates a failure happening when parsing encoding/executing a Set
+ *  Error that indicates a failure happening when parsing encoding/executing a Set
  */
 export declare class SetValidationError extends TokenValidationError {
     value: any;