import { Schema, SchemaAST } from "effect";
/**
 * Plutus data types and schemas for serialization/deserialization between
 * TypeScript types and Cardano's Plutus data format
 *
 * @since 1.0.0
 */
export type Data = Integer | ByteArray | List | Map | Constr;
export interface List extends ReadonlyArray<Data> {
}
export interface Integer {
    readonly int: number;
}
export interface ByteArray {
    readonly bytes: string;
}
export interface Constr {
    readonly constructor: number;
    readonly fields: readonly Data[];
}
export interface mkConstr<T extends Data> {
    readonly constructor: number;
    readonly fields: readonly T[];
}
export type Map = {
    readonly [key: string]: Data;
};
export declare const ByteArray: Schema.Struct<{
    bytes: Schema.filter<Schema.Schema<string, string, never>>;
}>;
export declare const Integer: Schema.Struct<{
    int: typeof Schema.Number;
}>;
export declare const isInteger: (u: unknown, overrideOptions?: SchemaAST.ParseOptions | number) => u is {
    readonly int: number;
};
export declare const isByteArray: (u: unknown, overrideOptions?: SchemaAST.ParseOptions | number) => u is {
    readonly bytes: string;
};
export declare const List: Schema.Array$<Schema.suspend<Data, Data, never>>;
export declare const isList: (u: unknown, overrideOptions?: SchemaAST.ParseOptions | number) => u is readonly Data[];
export declare const Map: Schema.Record$<typeof Schema.String, Schema.suspend<Data, Data, never>>;
export declare const isMap: (u: unknown, overrideOptions?: SchemaAST.ParseOptions | number) => u is {
    readonly [x: string]: Data;
};
export declare const Constr: Schema.Struct<{
    constructor: typeof Schema.Number;
    fields: Schema.Array$<Schema.suspend<Data, Data, never>>;
}>;
export declare const isConstr: (u: unknown, overrideOptions?: SchemaAST.ParseOptions | number) => u is {
    readonly fields: readonly Data[];
    readonly constructor: number;
};
export declare const Data: Schema.Schema<Data>;
export declare const mkByteArray: (bytes: string) => ByteArray;
export declare const mkMap: (map: Record<string, Data>) => Readonly<Map>;
export declare const mkInteger: (int: number) => Integer;
export declare const mkConstr: <T extends Data>(constructor: number, fields: readonly T[]) => {
    readonly constructor: number;
    readonly fields: readonly T[];
};
/**
 * Converts TypeScript data into CBOR hex string
 *
 * @example
 * import { Data, Type } from "@lucid-evolution/experimental"
 *
 * const Token = Type.Struct({
 *   policyId: Type.ByteArray,
 *   assetName: Type.ByteArray,
 *   amount: Type.Integer
 * })
 *
 * const token = {
 *   policyId: "deadbeef",
 *   assetName: "cafe",
 *   amount: 1000n
 * }
 *
 * // Convert to canonical CBOR
 * const cbor = Data.toCBOR(token, Token, { canonical: true })
 *
 * @since 1.0.0
 */
export declare const toCBOR: <Source, Target extends Data>(input: unknown, schema?: Schema.Schema<Source, Target>, options?: {
    canonical?: boolean;
    parseOptions?: SchemaAST.ParseOptions;
}) => string;
/**
 * Decodes a CBOR hex string to a TypeScript type
 *
 * @example
 * import { Data } from "@lucid-evolution/experimental";
 * const data = Data.fromCBOR(cborHexString, schema);
 *
 * @since 1.0.0
 */
export declare function fromCBOR(input: string): Data;
export declare function fromCBOR<Source, Target extends Data>(input: string, schema: Schema.Schema<Source, Target>): Source;
export declare const resolveCBOR: (input: string) => Data;
/**
 * Decodes an unknown value from Plutus Data Constructor to a TypeScript type
 *
 * @example
 * import { Type , Data } from "@lucid-evolution/experimental";
 *
 * const Token = Type.Struct({
 *   policyId: Type.ByteArray,
 *   assetName: Type.ByteArray,
 *   amount: Type.Integer
 * });
 *
 * const data : unknown = { index: 0n, fields: ["deadbeef", "cafe", 1000n] };
 * const token = Data.fromData(data, Token);
 * // { policyId: "deadbeef", assetName: "cafe", amount: 1000n }
 *
 * @since 1.0.0
 */
export declare const fromData: <Source, Target extends Data>(input: unknown, schema: Schema.Schema<Source, Target>, options?: SchemaAST.ParseOptions) => Source;
/**
 * Encodes a TypeScript value to Plutus Data Constructor
 *
 * @example
 * import { Data } from "@lucid-evolution/experimental";
 *
 * const token : unknown = {
 *   policyId: "deadbeef",
 *   assetName: "cafe",
 *   amount: 1000n
 * };
 * const data = Data.toData(token, Token);
 * // { index: 0n, fields: ["deadbeef", "cafe", 1000n] }
 *
 * @since 1.0.0
 */
export declare const toData: <Source, Target extends Data>(input: unknown, schema: Schema.Schema<Source, Target>, options?: SchemaAST.ParseOptions) => Target;
//# sourceMappingURL=DataJson.d.ts.map