import { Bip32Account, GroupedAddress, SignTransactionContext, SignTransactionOptions, TransactionSigner, WitnessedTx, Witnesser } from '@cardano-sdk/key-management';
import { Cardano, Handle, HandleProvider, HandleResolution } from '@cardano-sdk/core';
import { CustomError } from 'ts-custom-error';
import { Hash32ByteBase16 } from '@cardano-sdk/crypto';
import { HexBlob } from '@cardano-sdk/util';
import { InitializeTxWitness, RewardAccountWithPoolId, TxBodyPreInputSelection, TxBuilderProviders } from '../types';
import { InputSelectionError, InputSelector, SelectionSkeleton } from '@cardano-sdk/input-selection';
import { Logger } from 'ts-log';
import { OutputBuilderValidator } from './OutputBuilder';
import { OutputValidation } from '../output-validation';
export declare type PartialTxOut = Partial<Pick<Cardano.TxOut, 'address' | 'datumHash' | 'datum' | 'scriptReference'> & {
    value: Partial<Cardano.Value>;
    handle?: Handle;
}>;
export declare enum TxOutputFailure {
    MinimumCoin = "Minimum coin not met",
    TokenBundleSizeExceedsLimit = "Token Bundle Exceeds Limit",
    MissingRequiredFields = "Mandatory fields address or coin are missing",
    MissingHandleProviderError = "Missing 'HandleProvider'",
    HandleNotFound = "Handle not found",
    NegativeAssetQty = "Negative or zero asset quantity"
}
export declare enum TxValidityIntervalFailure {
    Expired = "Transaction expired"
}
export declare class InvalidConfigurationError extends CustomError {
    message: string;
    constructor(message: string);
}
export declare class HandleNotFoundError extends CustomError {
    txOut: PartialTxOut;
    constructor(txOut: PartialTxOut);
}
export declare class InsufficientRewardAccounts extends CustomError {
    constructor(poolIds: Cardano.PoolId[], rewardAccounts: Cardano.RewardAccount[]);
}
export declare type DataOfKeyWithLockedRewards = {
    cbor?: HexBlob;
    key: Cardano.RewardAccount;
};
export declare class DeRegistrationsWithRewardsLocked extends CustomError {
    keysWithLockedRewards: DataOfKeyWithLockedRewards[];
    constructor(rewardAccounts: Pick<RewardAccountWithPoolId, 'address'>[]);
}
export declare class OutOfSyncRewardAccounts extends CustomError {
    constructor(rewardAccounts: Cardano.RewardAccount[]);
}
export declare class OutputValidationMissingRequiredError extends CustomError {
    txOut: PartialTxOut;
    constructor(txOut: PartialTxOut);
}
export declare class OutputValidationMinimumCoinError extends CustomError {
    txOut: PartialTxOut;
    outputValidation: OutputValidation;
    constructor(txOut: PartialTxOut, outputValidation: OutputValidation);
}
export declare class OutputValidationTokenBundleSizeError extends CustomError {
    txOut: PartialTxOut;
    outputValidation: OutputValidation;
    constructor(txOut: PartialTxOut, outputValidation: OutputValidation);
}
export declare class OutputValidationNegativeAssetQtyError extends CustomError {
    txOut: PartialTxOut;
    outputValidation: OutputValidation;
    constructor(txOut: PartialTxOut, outputValidation: OutputValidation);
}
export declare class InvalidHereafterError extends CustomError {
    constructor();
}
export declare type TxOutValidationError = OutputValidationMissingRequiredError | OutputValidationMinimumCoinError | OutputValidationTokenBundleSizeError;
export declare type TxValidityIntervalValidationError = InvalidHereafterError;
export declare type TxBodyValidationError = TxOutValidationError | InputSelectionError | TxValidityIntervalValidationError;
export declare type OutputBuilderTxOut = Cardano.TxOut & {
    handle?: Handle;
    handleResolution?: HandleResolution;
};
export interface OutputBuilder {
    inspect(): Promise<PartialTxOut>;
    value(value: Cardano.Value): OutputBuilder;
    coin(coin: Cardano.Lovelace): OutputBuilder;
    assets(assets: Cardano.TokenMap): OutputBuilder;
    asset(assetId: Cardano.AssetId, quantity: bigint): OutputBuilder;
    address(address: Cardano.PaymentAddress): OutputBuilder;
    datum(datum: Hash32ByteBase16): OutputBuilder;
    build(): Promise<OutputBuilderTxOut>;
    handle(handle: Handle): OutputBuilder;
}
export interface TxContext {
    signingOptions?: SignTransactionOptions;
    signingContext: SignTransactionContext;
    auxiliaryData?: Cardano.AuxiliaryData;
    witness?: InitializeTxWitness;
}
export declare type TxInspection = Cardano.TxBodyWithHash & {
    handleResolutions?: HandleResolution[];
    auxiliaryData?: Cardano.AuxiliaryData;
    inputSelection: SelectionSkeleton;
    ownAddresses: GroupedAddress[];
    witness?: Cardano.Witness;
};
export interface UnwitnessedTx {
    inspect(): Promise<TxInspection>;
    sign(): Promise<WitnessedTx>;
}
export interface PartialTx {
    body: Partial<Cardano.TxBody>;
    auxiliaryData?: Cardano.AuxiliaryData;
    extraSigners?: TransactionSigner[];
    signingOptions?: SignTransactionOptions;
}
declare type CustomizeCbProps = {
    txBody: Readonly<TxBodyPreInputSelection>;
};
export declare type CustomizeCb = (props: CustomizeCbProps) => TxBodyPreInputSelection;
export declare type ResolveDatum = (datumHash: Cardano.DatumHash) => Promise<Cardano.PlutusData | null>;
export interface DatumResolver {
    resolve: ResolveDatum;
}
export declare type TxEvaluationResult = Array<{
    purpose: Cardano.RedeemerPurpose;
    index: number;
    budget: Cardano.ExUnits;
}>;
export interface TxEvaluator {
    evaluate(tx: Cardano.Tx, resolvedInputs: Array<Cardano.Utxo>): Promise<TxEvaluationResult>;
}
export declare type ScriptUnlockProps = {
    redeemer?: Cardano.PlutusData;
    script?: Cardano.Script;
    datum?: Cardano.PlutusData;
};
export declare type MintProps = {
    policy: Cardano.Script;
    assets: Map<Cardano.AssetName, bigint>;
    redeemer?: Cardano.PlutusData;
};
export interface TxBuilder {
    inspect(): Promise<PartialTx>;
    addReferenceInput(input: Cardano.TxIn | Cardano.Utxo): TxBuilder;
    addInput(input: Cardano.TxIn | Cardano.Utxo, scriptUnlockProps?: ScriptUnlockProps): TxBuilder;
    addMint(props: MintProps): TxBuilder;
    addDatum(datum: Cardano.PlutusData): TxBuilder;
    addOutput(txOut: Cardano.TxOut): TxBuilder;
    removeOutput(txOut: Cardano.TxOut): TxBuilder;
    buildOutput(txOut?: PartialTxOut): OutputBuilder;
    delegateFirstStakeCredential(poolId: Cardano.PoolId | null): TxBuilder;
    delegatePortfolio(portfolio: Pick<Cardano.Cip17DelegationPortfolio, 'pools'> | null): TxBuilder;
    metadata(metadata: Cardano.TxMetadata): TxBuilder;
    extraSigners(signers: TransactionSigner[]): TxBuilder;
    signingOptions(options: SignTransactionOptions): TxBuilder;
    customize(cb: CustomizeCb): TxBuilder;
    build(): UnwitnessedTx;
    setValidityInterval(validityInterval: Cardano.ValidityInterval): TxBuilder;
}
export interface TxBuilderDependencies {
    inputSelector?: InputSelector;
    datumResolver?: DatumResolver;
    txEvaluator: TxEvaluator;
    inputResolver: Cardano.InputResolver;
    bip32Account?: Bip32Account;
    witnesser: Witnesser;
    txBuilderProviders: TxBuilderProviders;
    logger: Logger;
    outputValidator?: OutputBuilderValidator;
    handleProvider?: HandleProvider;
}
export {};
//# sourceMappingURL=types.d.ts.map