import { ILayout } from '../typings/literal';
import { IType } from '../typings/type';
import { Layout } from '../core/enums/layout';
import { ContainerType, SimpleType, Type_VariantOrRecord } from '../core/type';
import { TypeAtom } from '../core/enums/type';
/**
 * An unknown type (It is used when leveraging type inference)
 *
 * ```typescript
 * TUnknown();
 * ```
 *
 * @return {IType<unknown>} A type
 */
export declare const TUnknown: () => IType;
/**
 * The type whose only value is Unit
 *
 * ```typescript
 * TUnit();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-unit
 *
 * @return {IType<TypeAtom.unit>} A type
 */
export declare const TUnit: () => SimpleType<TypeAtom.unit>;
/**
 * The type whose only value an arbitrary-precision natural number
 *
 * ```typescript
 * TNat();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-nat
 *
 * @return {IType<TypeAtom.nat>} A type
 */
export declare const TNat: () => SimpleType<TypeAtom.nat>;
/**
 * The type whose only value an arbitrary-precision integer
 *
 * ```typescript
 * TInt();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-int
 *
 * @return {IType<TypeAtom.int>} A type
 */
export declare const TInt: () => SimpleType<TypeAtom.int>;
/**
 * A specific type for manipulating the native tezos tokens.
 *
 * ```typescript
 * TMutez();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-mutez
 *
 * @return {IType<TypeAtom.mutez>} A type
 */
export declare const TMutez: () => SimpleType<TypeAtom.mutez>;
/**
 * A type that represents a sequence of characters.
 *
 * ```typescript
 * TString();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-string
 *
 * @return {IType<TypeAtom.string>} A type
 */
export declare const TString: () => SimpleType<TypeAtom.string>;
/**
 * The type used to represent boolean values.
 *
 * ```typescript
 * TBool();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-bool
 *
 * @return {IType<TypeAtom.bool>} A type
 */
export declare const TBool: () => SimpleType<TypeAtom.bool>;
/**
 * ```typescript
 * TAddress();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-address
 *
 * @return {IType<TypeAtom.address>} A type
 */
export declare const TAddress: () => SimpleType<TypeAtom.address>;
/**
 * ```typescript
 * TTimestamp();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-timestamp
 *
 * @return {IType<TypeAtom.timestamp>} A type
 */
export declare const TTimestamp: () => SimpleType<TypeAtom.timestamp>;
/**
 * ```typescript
 * TChain_id();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-chain_id
 *
 * @return {IType<TypeAtom.chain_id>} A type
 */
export declare const TChain_id: () => SimpleType<TypeAtom.chain_id>;
/**
 * ```typescript
 * TBytes();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-bytes
 *
 * @return {IType<TypeAtom.bytes>} A type
 */
export declare const TBytes: () => SimpleType<TypeAtom.bytes>;
/**
 * ```typescript
 * TBls12_381_fr();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-bls12_381_fr
 *
 * @return {IType<TypeAtom.bls12_381_fr>} A type
 */
export declare const TBls12_381_fr: () => SimpleType<TypeAtom.bls12_381_fr>;
/**
 * ```typescript
 * TBls12_381_g1();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-bls12_381_g1
 *
 * @return {IType<TypeAtom.bls12_381_g1>} A type
 */
export declare const TBls12_381_g1: () => SimpleType<TypeAtom.bls12_381_g1>;
/**
 * ```typescript
 * TBls12_381_g2();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-bls12_381_g2
 *
 * @return {IType<TypeAtom.bls12_381_g2>} A type
 */
export declare const TBls12_381_g2: () => SimpleType<TypeAtom.bls12_381_g2>;
/**
 * ```typescript
 * TKey();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-key
 *
 * @return {IType<TypeAtom.key>} A type
 */
export declare const TKey: () => SimpleType<TypeAtom.key>;
/**
 * ```typescript
 * TKey_hash();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-key_hash
 *
 * @return {IType<TypeAtom.key_hash>} A type
 */
export declare const TKey_hash: () => SimpleType<TypeAtom.key_hash>;
/**
 * ```typescript
 * TSignature();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-signature
 *
 * @return {IType<TypeAtom.signature>} A type
 */
export declare const TSignature: () => SimpleType<TypeAtom.signature>;
/**
 * ```typescript
 * TOperation();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-operation
 *
 * @return {IType<TypeAtom.operation>} A type
 */
export declare const TOperation: () => SimpleType<TypeAtom.operation>;
/**
 * ```typescript
 * TNever();
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-never
 *
 * @return {IType<TypeAtom.never>} A type
 */
export declare const TNever: () => SimpleType<TypeAtom.never>;
/**
 * ```typescript
 * TList(TNat());
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-list
 *
 * @return {IType<TypeAtom.list>} A type
 */
export declare const TList: (innerType: IType) => ContainerType<TypeAtom.list>;
/**
 * ```typescript
 * TSet(TNat());
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-set
 *
 * @return {IType<TypeAtom.set>} A type
 */
export declare const TSet: (innerType: IType) => ContainerType<TypeAtom.set>;
/**
 * ```typescript
 * TOption(TNat());
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-option
 *
 * @return {IType<TypeAtom.option>} A type
 */
export declare const TOption: (innerType: IType) => ContainerType<TypeAtom.option>;
/**
 * ```typescript
 * TMap(TString(), TNat());
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-map
 *
 * @return {IType<TypeAtom.map>} A type
 */
export declare const TMap: (keyType: IType, valueType: IType) => ContainerType<TypeAtom.map>;
/**
 * ```typescript
 * TBig_map(TString(), TNat());
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-big_map
 *
 * @return {IType<TypeAtom.big_map>} A type
 */
export declare const TBig_map: (keyType: IType, valueType: IType) => ContainerType<TypeAtom.big_map>;
/**
 * ```typescript
 * TPair(TString(), TNat());
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-pair
 *
 * @return {IType<TypeAtom.tuple>} A type
 */
export declare const TPair: (left: IType, right: IType, ...more: IType[]) => ContainerType<TypeAtom.tuple>;
/**
 * ```typescript
 * TOr(TString(), TNat());
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-or
 *
 * @return {IType<TypeAtom.or>} A type
 */
export declare const TOr: (left: IType, right: IType) => Type_VariantOrRecord;
/**
 * ```typescript
 * TLambda(TString(), TNat());
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-lambda
 *
 * @return {IType<TypeAtom.lambda>} A type
 */
export declare const TLambda: (left: IType, right: IType) => ContainerType<TypeAtom.lambda>;
/**
 * ```typescript
 * TTicket(TString());
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-ticket
 *
 * @return {IType<TypeAtom.ticket>} A type
 */
export declare const TTicket: (innerType: IType) => ContainerType<TypeAtom.ticket>;
/**
 * ```typescript
 * TContract(TString());
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-contract
 *
 * @return {IType<TypeAtom.contract>} A type
 */
export declare const TContract: (innerType: IType) => ContainerType<TypeAtom.contract>;
/**
 * ```typescript
 * TSapling_state(8);
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-sapling_state
 *
 * @return {IType<TypeAtom.sapling_state>} A type
 */
export declare const TSapling_state: (memo: number) => ContainerType<TypeAtom.sapling_state>;
/**
 * ```typescript
 * TSapling_transaction(8);
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-sapling_transaction
 *
 * @return {IType<TypeAtom.sapling_transaction>} A type
 */
export declare const TSapling_transaction: (memo: number) => ContainerType<TypeAtom.sapling_transaction>;
/**
 * ```typescript
 * TRecord({
 *  field1: TNat(),
 *  field2: TString(),
 * });
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-pair
 *
 * @return {IType<TypeAtom.pair>} A type
 */
export declare const TRecord: (fields: Record<string, IType>, layout?: ILayout | Layout | undefined) => Type_VariantOrRecord;
/**
 * ```typescript
 * TVariant({
 *  branch1: TNat(),
 *  branch1: TString(),
 * });
 * ```
 *
 * @see https://tezos.gitlab.io/michelson-reference/#type-or
 *
 * @return {IType<TypeAtom.or>} A type
 */
export declare const TVariant: (fields: Record<string, IType>, layout?: ILayout | Layout | undefined) => Type_VariantOrRecord;
declare const Types: {
    TUnknown: () => IType;
    TUnit: () => SimpleType<TypeAtom.unit>;
    TNat: () => SimpleType<TypeAtom.nat>;
    TInt: () => SimpleType<TypeAtom.int>;
    TMutez: () => SimpleType<TypeAtom.mutez>;
    TString: () => SimpleType<TypeAtom.string>;
    TBool: () => SimpleType<TypeAtom.bool>;
    TBytes: () => SimpleType<TypeAtom.bytes>;
    TAddress: () => SimpleType<TypeAtom.address>;
    TTimestamp: () => SimpleType<TypeAtom.timestamp>;
    TChain_id: () => SimpleType<TypeAtom.chain_id>;
    TBls12_381_fr: () => SimpleType<TypeAtom.bls12_381_fr>;
    TBls12_381_g1: () => SimpleType<TypeAtom.bls12_381_g1>;
    TBls12_381_g2: () => SimpleType<TypeAtom.bls12_381_g2>;
    TKey: () => SimpleType<TypeAtom.key>;
    TKey_hash: () => SimpleType<TypeAtom.key_hash>;
    TSignature: () => SimpleType<TypeAtom.signature>;
    TOperation: () => SimpleType<TypeAtom.operation>;
    TNever: () => SimpleType<TypeAtom.never>;
    TList: (innerType: IType) => ContainerType<TypeAtom.list>;
    TSet: (innerType: IType) => ContainerType<TypeAtom.set>;
    TOption: (innerType: IType) => ContainerType<TypeAtom.option>;
    TPair: (left: IType, right: IType, ...more: IType[]) => ContainerType<TypeAtom.tuple>;
    TOr: (left: IType, right: IType) => Type_VariantOrRecord;
    TMap: (keyType: IType, valueType: IType) => ContainerType<TypeAtom.map>;
    TBig_map: (keyType: IType, valueType: IType) => ContainerType<TypeAtom.big_map>;
    TLambda: (left: IType, right: IType) => ContainerType<TypeAtom.lambda>;
    TTicket: (innerType: IType) => ContainerType<TypeAtom.ticket>;
    TContract: (innerType: IType) => ContainerType<TypeAtom.contract>;
    TSapling_state: (memo: number) => ContainerType<TypeAtom.sapling_state>;
    TSapling_transaction: (memo: number) => ContainerType<TypeAtom.sapling_transaction>;
    TRecord: (fields: Record<string, IType>, layout?: ILayout | Layout | undefined) => Type_VariantOrRecord;
    TVariant: (fields: Record<string, IType>, layout?: ILayout | Layout | undefined) => Type_VariantOrRecord;
};
export default Types;