import { cryptly } from "cryptly";
import { isoly } from "isoly";
import { fx } from "../fx";
import { Operation } from "../Operation";
import { Rail } from "../Rail";
import type { Rule } from "../Rule";
import { Settlement } from "../Settlement";
import { Amount as TransactionAmount } from "./Amount";
import { Creatable as TransactionCreatable } from "./Creatable";
import { Exchange as TransactionExchange } from "./Exchange";
import { Identifier as TransactionIdentifier } from "./Identifier";
import { Note as TransactionNote } from "./Note";
import { PreTransaction as TransactionPreTransaction } from "./PreTransaction";
import { Reference as TransactionReference } from "./Reference";
import { Statistics as TransactionStatistics } from "./Statistics";
import { Status as TransactionStatus } from "./Status";
export interface Transaction {
    counterpart: Rail.Address & {
        code?: string;
    };
    currency: isoly.Currency;
    amount: Transaction.Amount;
    description: string;
    organization: string;
    accountId: string;
    accountName?: string;
    account: Rail.Address;
    type?: Transaction.Types;
    direction?: Transaction.Direction;
    id: cryptly.Identifier;
    reference?: Transaction.Reference;
    posted: isoly.DateTime;
    transacted?: isoly.DateTime;
    by?: string;
    balance: {
        actual: number;
        reserved: number;
        available: number;
    };
    operations?: Operation[];
    status: Transaction.Status;
    rail?: Rail;
    flags: string[];
    oldFlags: string[];
    notes: Transaction.Note[];
    risk?: number;
    state?: Rule.State;
}
export declare namespace Transaction {
    export import Identifier = TransactionIdentifier;
    export import Exchange = TransactionExchange;
    export import Amount = TransactionAmount;
    const types: readonly ["card", "internal", "external", "system"];
    type Types = (typeof types)[number];
    const directions: readonly ["inbound", "outbound"];
    type Direction = (typeof directions)[number];
    export import Creatable = TransactionCreatable;
    export import PreTransaction = TransactionPreTransaction;
    export import Reference = TransactionReference;
    export import Note = TransactionNote;
    export import Status = TransactionStatus;
    export import Statistics = TransactionStatistics;
    const type: import("isly/dist/cjs/object").IslyObject<Transaction, object>;
    function amountFromOperations(transaction: Transaction, operations: Operation[]): Amount;
    interface Legacy extends Omit<Transaction, "amount"> {
        amount: number;
    }
    namespace Legacy {
        const type: import("isly/dist/cjs/object").IslyObject<Legacy, Omit<Transaction, "amount">>;
    }
    function fromLegacy(transaction: Transaction | Legacy): Transaction;
    function toLegacy(transaction: Transaction | Legacy): Legacy;
    type Event = Omit<Transaction, "state">;
    namespace Event {
        const type: import("isly/dist/cjs/object").IslyObject<Omit<Transaction, "state">, object>;
        function from(transaction: Transaction): Event;
    }
    function fromCreatable(creatable: Creatable.Resolved, id: string, state: Rule.State.Evaluated, account: {
        id: string;
        name: string;
        organization: string;
        address: Rail.Address;
    }, balance: {
        actual: number;
        reserved: number;
        available: number;
    }, operation: Operation | Status.Reason, charges?: Amount.Charge, by?: string, quote?: fx.Quote): Transaction;
    function system(creatable: Creatable.Resolved, account: {
        id: string;
        name: string;
        organization: string;
        address: Rail.Address;
    }, balance: {
        actual: number;
        reserved: number;
        available: number;
    }, by: string | undefined): Transaction;
    function empty(creatable: Creatable.Resolved, account: {
        id: string;
        name: string;
        organization: string;
        address: Rail.Address;
    }, balance: {
        actual: number;
        reserved: number;
        available: number;
    }, by: string | undefined): Transaction;
    function buffer(id: Identifier, account: {
        id: string;
        name: string;
        organization: string;
        address: Rail.Address;
    }, currency: isoly.Currency, balance: {
        actual: number;
        reserved: number;
        available: number;
    }, by: string | undefined): Transaction;
    function fromIncoming(transaction: Transaction.PreTransaction.Incoming, state: Rule.State.Evaluated, account: {
        id: string;
        name: string;
        organization: string;
    }, balance: {
        actual: number;
        reserved: number;
        available: number;
    }): Transaction;
    function fromRefund(refund: Settlement.Entry.Creatable.Refund, id: string, account: {
        id: string;
        name: string;
        organization: string;
    }, card: Rail.Address.Card, balance: {
        actual: number;
        reserved: number;
        available: number;
    }, state: Rule.State.Evaluated): Transaction;
    function isIdentifier(value: string | any): value is string;
    function flag(transaction: Transaction, flags: string[] | undefined): void;
    function getType(counterpart: Rail.Address, accountName: string): Types;
    function toCsv(transactions: (Transaction | Transaction.Legacy)[]): string;
    type CardTransaction = Transaction & {
        account: Extract<Transaction["account"], Rail.Address.Card>;
        counterpart: Extract<Transaction["counterpart"], Rail.Address.Card.Counterpart>;
    };
    namespace CardTransaction {
        const type: import("isly/dist/cjs/object").IslyObject<CardTransaction, Omit<Transaction, "account" | "counterpart">>;
    }
}