import { ExecutionUnits } from '@cardano-ogmios/schema';
import { Address as BechAddress, BigNumber, HexString, PubKeyHash, ScriptHash, StakingHash as StakingHashType, TxDatum, TxRedeemerTag } from "../../types";
import { BaseDatumConstr } from './BaseDatumConstr';
type MaybeDecoder<T extends TxDatum> = (data: any) => T;
export declare class Unit extends BaseDatumConstr {
    static readonly CONSTR = 0;
    constructor();
    static decodeSchema(data: any): Unit;
}
export declare class EmptyRedeemer extends Unit {
}
export declare const EMPTY_TX_EX_UNITS: ExecutionUnits;
export declare const emptyMintRedeemer: {
    readonly tag: TxRedeemerTag.MINT;
    readonly data: EmptyRedeemer;
    readonly exUnits: ExecutionUnits;
};
export declare abstract class Maybe<_T> extends BaseDatumConstr {
    static decodeSchema<V extends TxDatum>(data: any, decoder: MaybeDecoder<V>): Maybe<V>;
}
export declare class Just<T extends TxDatum> extends Maybe<T> {
    readonly value: T;
    static readonly CONSTR = 0;
    constructor(value: T);
    static decodeSchema<V extends TxDatum>(data: any, decoder: MaybeDecoder<V>): Just<V>;
}
export declare class Nothing<T extends TxDatum> extends Maybe<T> {
    static readonly CONSTR = 1;
    constructor();
    static decodeSchema<V extends TxDatum>(data: any): Nothing<V>;
}
export declare class AssetClass extends BaseDatumConstr {
    readonly policyId: HexString;
    readonly assetName: HexString;
    static readonly CONSTR = 0;
    constructor(policyId: HexString, assetName: HexString);
    static decodeSchema(data: any): AssetClass;
}
export declare class AdaAssetClass extends AssetClass {
    constructor();
}
export type POSIXTime = number;
export type ValidatorHash = HexString;
export declare abstract class AddressCredential extends BaseDatumConstr {
    static decodeSchema(data: any): AddressCredential;
}
export declare class PubKeyCredential extends AddressCredential {
    readonly pubKeyHash: PubKeyHash;
    static readonly CONSTR = 0;
    constructor(pubKeyHash: PubKeyHash);
    static decodeSchema(data: any): PubKeyCredential;
}
export declare class StakingHashCredential extends BaseDatumConstr {
    readonly stakingHash: StakingHashType;
    static readonly CONSTR = 0;
    constructor(stakingHash: StakingHashType);
    static decodeSchema(data: any): StakingHashCredential;
}
export declare class ScriptCredential extends AddressCredential {
    readonly scriptHash: ScriptHash;
    static readonly CONSTR = 1;
    constructor(scriptHash: ScriptHash);
    static decodeSchema(data: any): ScriptCredential;
}
export declare abstract class StakingCredential extends BaseDatumConstr {
    static decodeSchema(data: any): StakingCredential;
}
export declare class StakingHash extends StakingCredential {
    readonly credential: AddressCredential;
    static readonly CONSTR = 0;
    constructor(credential: AddressCredential);
    static decodeSchema(data: any): StakingHash;
}
export declare class StakingPtr extends StakingCredential {
    readonly blockIndex: BigNumber;
    readonly txIndex: BigNumber;
    readonly certificateIndex: BigNumber;
    static readonly CONSTR = 1;
    constructor(blockIndex: BigNumber, txIndex: BigNumber, certificateIndex: BigNumber);
    static decodeSchema(data: any): StakingPtr;
}
export declare class Address extends BaseDatumConstr {
    readonly addressCredential: AddressCredential;
    readonly addressStakingCredential: Maybe<StakingCredential>;
    static readonly CONSTR = 0;
    constructor(addressCredential: AddressCredential, addressStakingCredential: Maybe<StakingCredential>);
    static fromAddress(address: BechAddress): Address;
    static fromAddressHex(address: HexString): Address;
    static decodeSchema(data: any): Address;
}
export {};
//# sourceMappingURL=datumTypes.d.ts.map