/// <reference types="node" />
import { Buffer } from "buffer";
import BigNumber from "bignumber.js";
import { CardanoAddress, CollateralInput, HashCredential, Mint, NativeScript, PlutusData, PlutusScriptType, ProtocolParams, BipPath, AuxiliaryData, Certificate, Input, Output, Withdrawal, Token, VKeyWitness, ReferenceInput, VotingProcedure, ProposalProcedure } from "../types";
export declare class Transaction {
    protected _protocolParams: ProtocolParams;
    protected inputs: Array<Input>;
    protected referenceInputs: Array<ReferenceInput>;
    protected outputs: Array<Output>;
    protected certificates: Array<Certificate>;
    protected withdrawals: Array<Withdrawal>;
    protected requiredWitnesses: Map<string, BipPath | undefined>;
    protected requiredNativeScriptWitnesses: Map<string, undefined>;
    protected fee: BigNumber;
    protected ttl: number | undefined;
    protected witnesses: Array<VKeyWitness>;
    protected plutusScriptMap: Map<string, PlutusScriptType>;
    protected nativeScriptList: Array<NativeScript>;
    protected auxiliaryData: AuxiliaryData | undefined;
    protected collaterals: Array<CollateralInput>;
    protected collateralOutput: Output | undefined;
    protected totalCollateral: BigNumber | undefined;
    protected requiredSigners: Map<string, BipPath | undefined>;
    protected plutusDataList: Array<PlutusData>;
    protected _isPlutusV1Transaction: boolean;
    protected _isPlutusV2Transaction: boolean;
    protected _isPlutusV3Transaction: boolean;
    protected mints: Array<Mint>;
    protected validityIntervalStart: number | undefined;
    protected votingProcedures: Array<VotingProcedure>;
    protected proposalProcedures: Array<ProposalProcedure>;
    protected donationAmount: BigNumber | undefined;
    protected treasuryAmount: BigNumber | undefined;
    constructor({ protocolParams }: {
        protocolParams: ProtocolParams;
    });
    get protocolParams(): ProtocolParams;
    getTTL(): number | undefined;
    setTTL(ttl: number): void;
    getValidityIntervalStart(): number | undefined;
    setValidityIntervalStart(validityIntervalStart: number): void;
    addInput(input: Input): void;
    addReferenceInput(input: ReferenceInput): void;
    addRequiredSigner(credential: HashCredential): void;
    addCollateral(input: CollateralInput): void;
    addMint(mint: Mint): void;
    /**
     * The method will add a certificate to the transaction to be included in cbor
     * This method will automatically scan and include each unique required witnesses in the map
     * to help sign the transaction
     * @param certificate a certificate to include in the transaction
     */
    addCertificate(certificate: Certificate): void;
    addOutput(output: Output): void;
    addWithdrawal(withdrawal: Withdrawal): void;
    addVotingProcedure(votingProcedure: VotingProcedure): void;
    addProposalProcedure(proposalProcedure: ProposalProcedure): void;
    setCollateralOutput(output: Output): void;
    getCollateralOutput(): Output | undefined;
    setTotalCollateral(amount: BigNumber): void;
    getTotalCollateral(): BigNumber | undefined;
    setDonationAmount(amount: BigNumber): void;
    getDonationAmount(): BigNumber | undefined;
    setTreasuryAmount(amount: BigNumber): void;
    getTreasuryAmount(): BigNumber | undefined;
    /**
     * This method will encode the transaction body to be included in the cbor
     */
    protected encodeTransactionBody({ extraOutputs, scriptDataHash, }: {
        extraOutputs?: Array<Output>;
        scriptDataHash?: Buffer;
    }): unknown;
    private transactionFee;
    private contractFee;
    private calculateRefScriptFee;
    calculateTxSize(extraOutputs?: Array<Output>): number;
    calculateFee(extraOutputs?: Array<Output>): BigNumber;
    setFee(fee: BigNumber): void;
    getFee(): BigNumber;
    calculateMinUtxoAmountBabbage(output: Output): BigNumber;
    addWitness(witness: VKeyWitness): void;
    getTransactionHash(): Buffer;
    getAuxiliaryData(): AuxiliaryData | undefined;
    getAuxiliaryDataHashHex(): string | undefined;
    buildTransaction(): {
        hash: string;
        payload: string;
    };
    getInputs(): Array<Input>;
    getCertificates(): Array<Certificate>;
    getMints(): Array<Mint>;
    getMintTokens(): Array<Token>;
    getBurnTokens(): Array<Token>;
    getInputAmount(): {
        ada: BigNumber;
        tokens: Array<Token>;
    };
    getCollaterals(): Array<CollateralInput>;
    getScriptIntegrityHash(): Buffer | undefined;
    getCollateralAmount(): BigNumber;
    getOutputs(): Array<Output>;
    getOutputAmount(): {
        ada: BigNumber;
        tokens: Array<Token>;
    };
    /**
     * This method scans the certificates and proposal procedures added in the transaction
     * to calculate additional ADA required for transaction validity.
     * 1. stake key registration deposit ADA
     * 2. proposal procedure deposit ADA
     * 3. donation amount
     * @returns additional ADA required for a valid transaction
     */
    getAdditionalOutputAda(): BigNumber;
    /**
     * This method scans the certificates added in the transaction to calculate
     * additional ADA available in inputs as part of the deposit refund.
     * Essentially ADA to be considered as additional input due to deposit refunds.
     * @returns additional ADA available as input
     */
    getAdditionalInputAda(): BigNumber;
    getWithdrawals(): Array<Withdrawal>;
    getRequiredWitnesses(): Map<string, BipPath | undefined>;
    getRequiredNativeScriptWitnesses(): Map<string, undefined>;
    getRequiredSigners(): Map<string, BipPath | undefined>;
    getVotingProcedures(): Array<VotingProcedure>;
    getProposalProcedures(): Array<ProposalProcedure>;
    setAuxiliaryData(auxData: AuxiliaryData): void;
    isPlutusTransaction(): boolean;
    /**
     * Function to prepare transaction automatically
     * There are other helper methods for preparing transactions that use this method
     * This method should be used when you know what you are doing
     * sets required inputs,
     * fees,
     * change etc
     * resulting transaction is the final tx that can be built for signing
     */
    prepareTransaction({ inputs, changeAddress, collateralInputs, }: {
        inputs: Array<Input>;
        changeAddress: CardanoAddress;
        collateralInputs?: Array<CollateralInput>;
    }): Transaction;
    /**
     * Function for a simple send ADA transaction
     * Provide necessary outputs, and available inputs, returns a final tx
     */
    paymentTransaction({ inputs, outputs, changeAddress, auxiliaryData, ttl, }: {
        inputs: Array<Input>;
        outputs: Array<Output>;
        changeAddress: CardanoAddress;
        auxiliaryData?: AuxiliaryData;
        ttl: number;
    }): Transaction;
}
export default Transaction;
