@taquito/michelson-encoder 23.0.2 → 23.1.0

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/constants.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Symbol representing Unit value in Michelson
+ */
+export declare const UnitValue: unique symbol;
+/**
+ * Sapling state placeholder value
+ */
+export declare const SaplingStateValue: {};

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

@@ -46,14 +46,9 @@ export declare class ParameterSchema {
      * @throws {@link ParameterEncodingError}
      */
     EncodeObject(value?: any, semantics?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): any;
     /**
      * @description Produce a schema grouping together all the entry points of a contract.
      */
     generateSchema(): TokenSchema;
-    ExtractSignatures(): any[][];
+    ExtractSignatures(): TokenSchema[][];
 }

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

@@ -1,6 +1,5 @@
 import { MichelsonV1Expression, ScriptResponse } from '@taquito/rpc';
 import { BigMapKeyType, Semantic, SemanticEncoding, Token } from '../tokens/token';
-import { RpcTransaction } from './model';
 import { TokenSchema } from './types';
 declare const schemaTypeSymbol: unique symbol;
 export declare function deepEqual(a: MichelsonV1Expression | undefined, b: MichelsonV1Expression | undefined): boolean;
@@ -23,7 +22,14 @@ export declare class Schema {
     constructor(val: MichelsonV1Expression);
     private removeTopLevelAnnotation;
     Execute(val: any, semantics?: Semantic): any;
-    Typecheck(val: any): void;
+    /**
+     * @description 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
+     * @returns Returns true if validation passes, false if validation fails
+     */
+    Typecheck(val: any): boolean;
     /**
      * @throws {@link InvalidBigMapSchemaError}
      * @throws {@link InvalidBigMapDiffError}
@@ -51,21 +57,11 @@ export declare class Schema {
      * @throws {@link StorageEncodingError}
      */
     Encode(value?: any, semantics?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): any;
     /**
      * @description 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;
-    /**
-     * @deprecated
-     * @throws {@link InvalidBigMapSchemaError}
-     */
-    ComputeState(tx: RpcTransaction[], state: any): any;
     /**
      * @description Look up in top-level pairs of the storage to find a value matching the specified type
      *

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

@@ -44,10 +44,10 @@ export declare class ViewSchema {
      *
      * @description Return the signature of the view parameter
      */
-    extractArgsSchema(): any;
+    extractArgsSchema(): import("./types").TokenSchema;
     /**
      *
      * @description Return the format of the view result
      */
-    extractResultSchema(): any;
+    extractResultSchema(): import("./types").TokenSchema;
 }

package/dist/types/taquito-michelson-encoder.d.ts

@@ -10,8 +10,7 @@ export * from './schema/errors';
 export * from './schema/types';
 export { Semantic, SemanticEncoding, BigMapKeyType } from './tokens/token';
 export * from './errors';
-export declare const UnitValue: unique symbol;
-export declare const SaplingStateValue: {};
+export { UnitValue, SaplingStateValue } from './constants';
 export * from './michelson-map';
 export { VERSION } from './version';
 export { FieldNumberingStrategy, Token } from './tokens/token';

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

@@ -26,16 +26,6 @@ export declare class BigMapToken extends Token {
     }, idx: number, fac: TokenFactory);
     get ValueSchema(): Token;
     get KeySchema(): ComparableToken;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): {
-        big_map: {
-            key: any;
-            value: any;
-        };
-    };
     generateSchema(): BigMapTokenSchema;
     /**
      * @throws {@link BigMapValidationError}

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

@@ -46,11 +46,6 @@ export declare class Bls12381frToken extends Token {
         bytes: string | number | Uint8Array;
     };
     Execute(val: any): string;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "bls12_381_fr";
     generateSchema(): BaseTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -42,11 +42,6 @@ export declare class Bls12381g1Token extends Token {
         bytes: string | Uint8Array;
     };
     Execute(val: any): string;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "bls12_381_g1";
     generateSchema(): BaseTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -42,11 +42,6 @@ export declare class Bls12381g2Token extends Token {
         bytes: string | Uint8Array;
     };
     Execute(val: any): string;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "bls12_381_g2";
     generateSchema(): BaseTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -29,11 +29,6 @@ export declare class ChainIDToken extends ComparableToken {
      */
     private validate;
     Execute(val: any): string;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "chain_id";
     generateSchema(): BaseTokenSchema;
     /**
      * @throws {@link ChainIDValidationError}

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

@@ -42,11 +42,6 @@ export declare class ChestKeyToken extends Token {
         bytes: string | Uint8Array;
     };
     Execute(val: any): string;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "chest_key";
     generateSchema(): BaseTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -42,11 +42,6 @@ export declare class ChestToken extends Token {
         bytes: string | Uint8Array;
     };
     Execute(val: any): string;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "chest";
     generateSchema(): BaseTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -51,11 +51,6 @@ export declare class AddressToken extends ComparableToken {
         bytes: string;
         string: string;
     }): string;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "address";
     generateSchema(): BaseTokenSchema;
     /**
      * @throws {@link AddressValidationError}

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

@@ -17,11 +17,6 @@ export declare class BoolToken extends ComparableToken {
     Execute(val: any): boolean;
     Encode(args: any[]): any;
     EncodeObject(val: any, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1Expression;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "bool";
     generateSchema(): BaseTokenSchema;
     ToBigMapKey(val: string): {
         key: {

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

@@ -46,11 +46,6 @@ export declare class BytesToken extends ComparableToken {
      */
     EncodeObject(val: string | Uint8Array, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1Expression;
     Execute(val: any): string;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "bytes";
     generateSchema(): BaseTokenSchema;
     ToKey({ bytes, string }: any): any;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];

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

@@ -29,11 +29,6 @@ export declare class IntToken extends ComparableToken {
     }): {
         [key: string]: any;
     };
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "int";
     generateSchema(): BaseTokenSchema;
     /**
      * @throws {@link IntValidationError}

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

@@ -40,11 +40,6 @@ export declare class KeyHashToken extends ComparableToken {
      * @throws {@link KeyHashValidationError}
      */
     EncodeObject(val: any, semantic?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "key_hash";
     generateSchema(): BaseTokenSchema;
     ToKey({ string, bytes }: any): any;
     ToBigMapKey(val: string): {

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

@@ -26,11 +26,6 @@ export declare class MutezToken extends ComparableToken {
         annots: any[];
     }, idx: number, fac: TokenFactory);
     Execute(val: any): BigNumber;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "mutez";
     generateSchema(): BaseTokenSchema;
     /**
      * @throws {@link MutezValidationError}

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

@@ -40,11 +40,6 @@ export declare class NatToken extends ComparableToken {
      * @throws {@link NatValidationError}
      */
     EncodeObject(val: any, semantic?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "nat";
     generateSchema(): BaseTokenSchema;
     ToBigMapKey(val: string | number): {
         key: {

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

@@ -15,11 +15,6 @@ export declare class StringToken extends ComparableToken {
         annots: any[];
     }, idx: number, fac: TokenFactory);
     Execute(val: any): string;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "string";
     generateSchema(): BaseTokenSchema;
     Encode(args: any[]): any;
     EncodeObject(val: any, semantic?: SemanticEncoding): any;

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

@@ -20,11 +20,6 @@ export declare class TimestampToken extends ComparableToken {
     }): string | undefined;
     Encode(args: any[]): any;
     EncodeObject(val: any, semantic?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "timestamp";
     generateSchema(): BaseTokenSchema;
     ToKey({ string }: any): any;
     ToBigMapKey(val: string): {

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

@@ -46,11 +46,6 @@ export declare class GlobalConstantToken extends Token {
      * @throws {@link GlobalConstantEncodingError}
      */
     EncodeObject(val: any, semantic?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "constant";
     generateSchema(): ConstantTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -43,11 +43,6 @@ export declare class ContractToken extends Token {
      * @throws {@link ContractValidationError}
      */
     EncodeObject(val: any, semantic?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "contract";
     generateSchema(): ContractTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -40,11 +40,6 @@ export declare class KeyToken extends ComparableToken {
      * @throws {@link KeyValidationError}
      */
     EncodeObject(val: any, semantic?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "key";
     generateSchema(): BaseTokenSchema;
     ToKey(val: any): string;
     ToBigMapKey(val: string): {
@@ -55,7 +50,6 @@ export declare class KeyToken extends ComparableToken {
             prim: "key";
         };
     };
-    decompressP256PublicKey(compressedKey: Uint8Array): Buffer;
     compare(key1: string, key2: string): number;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -19,16 +19,6 @@ export declare class LambdaToken extends Token {
     Execute(val: any): any;
     Encode(args: any[]): any;
     EncodeObject(val: any, semantic?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): {
-        lambda: {
-            parameters: any;
-            returns: any;
-        };
-    };
     generateSchema(): LambdaTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -41,13 +41,6 @@ export declare class ListToken extends Token {
      * @throws {@link ListValidationError}
      */
     EncodeObject(args: any, semantic?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): {
-        list: any;
-    };
     generateSchema(): ListTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -42,16 +42,6 @@ export declare class MapToken extends Token {
      * @throws {@link MapValidationError}
      */
     EncodeObject(args: any, semantic?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): {
-        map: {
-            key: any;
-            value: any;
-        };
-    };
     generateSchema(): MapTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -36,11 +36,6 @@ export declare class NeverToken extends Token {
      * @throws {@link NeverTokenError}
      */
     Execute(val: any): void;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "never";
     generateSchema(): BaseTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -19,11 +19,6 @@ export declare class OperationToken extends Token {
     };
     Encode(...args: any[]): any;
     EncodeObject(val: any, semantic?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "operation";
     generateSchema(): BaseTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -22,15 +22,8 @@ export declare class OptionToken extends ComparableToken {
     Execute(val: any, semantics?: Semantic): {
         Some: any;
     } | null;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): {
-        Some: any;
-    };
     generateSchema(): OptionTokenSchema;
-    ExtractSignature(): any[][];
+    ExtractSignature(): import("../schema/types").TokenSchema[][];
     get KeySchema(): ComparableToken;
     compare(val1: any, val2: any): number;
     ToKey(val: any): {

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

@@ -40,11 +40,6 @@ export declare class OrToken extends ComparableToken {
      */
     Execute(val: any, semantics?: Semantic): any;
     private traversal;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): any;
     generateSchema(): OrTokenSchema;
     private findToken;
     compare(val1: any, val2: any): any;

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

@@ -40,11 +40,6 @@ export declare class PairToken extends ComparableToken {
     Execute(val: any, semantics?: Semantic): {
         [key: string]: any;
     };
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): any;
     generateSchema(): PairTokenSchema;
     /**
      * @throws {@link TokenComparisonError}

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

@@ -39,15 +39,6 @@ export declare class SaplingStateToken extends Token {
      * @throws {@link SaplingStateValidationError}
      */
     EncodeObject(val: any, semantic?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): {
-        sapling_state: {
-            'memo-size': number;
-        };
-    };
     generateSchema(): SaplingStateTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -35,15 +35,6 @@ export declare class SaplingTransactionDeprecatedToken extends Token {
     private convertUint8ArrayToHexString;
     Encode(args: any[]): any;
     EncodeObject(val: string | Uint8Array, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1Expression;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): {
-        sapling_transaction_deprecated: {
-            'memo-size': number;
-        };
-    };
     generateSchema(): SaplingTransactionDeprecatedTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -35,15 +35,6 @@ export declare class SaplingTransactionToken extends Token {
     private convertUint8ArrayToHexString;
     Encode(args: any[]): any;
     EncodeObject(val: string | Uint8Array, semantic?: SemanticEncoding): import("@taquito/rpc").MichelsonV1Expression;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): {
-        sapling_transaction: {
-            'memo-size': number;
-        };
-    };
     generateSchema(): SaplingTransactionTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -38,11 +38,6 @@ export declare class SetToken extends Token {
      * @throws {@link SetValidationError}
      */
     EncodeObject(args: any, semantic?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "set";
     generateSchema(): SetTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -39,11 +39,6 @@ export declare class SignatureToken extends ComparableToken {
      * @throws {@link SignatureValidationError}
      */
     EncodeObject(val: any, semantic?: SemanticEncoding): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "signature";
     generateSchema(): BaseTokenSchema;
     ToKey(val: any): string;
     ToBigMapKey(val: string): {

package/dist/types/tokens/ticket-deprecated.d.ts

@@ -33,15 +33,6 @@ export declare class TicketDeprecatedToken extends Token {
      */
     EncodeObject(args: any, semantic?: SemanticEncoding): any;
     Execute(val: any, semantics?: Semantic): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): {
-        ticketer: "contract";
-        value: any;
-        amount: "int";
-    };
     generateSchema(): TicketDeprecatedTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -33,15 +33,6 @@ export declare class TicketToken extends Token {
      */
     EncodeObject(args: any, semantic?: SemanticEncoding): any;
     Execute(val: any, semantics?: Semantic): any;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): {
-        ticketer: "contract";
-        value: any;
-        amount: "int";
-    };
     generateSchema(): TicketTokenSchema;
     findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
 }

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

@@ -45,16 +45,11 @@ export declare abstract class Token {
     hasAnnotations(): number | false;
     get tokenVal(): MichelsonV1ExpressionExtended;
     createToken: TokenFactory;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    abstract ExtractSchema(): any;
     abstract generateSchema(): TokenSchema;
     abstract Execute(val: any, semantics?: Semantic): any;
     abstract Encode(_args: any[]): any;
     abstract EncodeObject(args: any, semantics?: SemanticEncoding): any;
-    ExtractSignature(): any[][];
+    ExtractSignature(): TokenSchema[][];
     abstract findAndReturnTokens(tokenToFind: string, tokens: Array<Token>): Array<Token>;
 }
 export type BigMapKeyType = string | number | object;

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

@@ -19,11 +19,6 @@ export declare class UnitToken extends ComparableToken {
     Execute(_val: {
         prim: string;
     }): symbol;
-    /**
-     * @deprecated ExtractSchema has been deprecated in favor of generateSchema
-     *
-     */
-    ExtractSchema(): "unit";
     generateSchema(): BaseTokenSchema;
     compare(_val1: any, _val2: any): number;
     ToKey(_val: any): symbol;