import * as gracely from "gracely";
import * as isoly from "isoly";
import * as model from "@payfunc/model-card";
import { Authorization } from "../Authorization";
import { Settlement } from "../Settlement";
import { Base as MerchantBase } from "./Base";
import { Creatable as MerchantCreatable } from "./Creatable";
import { Fee as MerchantFee } from "./Fee";
import { Operation as MerchantOperation } from "./Operation";
import { Processor as MerchantProcessor } from "./Processor";
import { Reconciliation as MerchantReconciliation } from "./Reconciliation";
import { Risk as MerchantRisk } from "./Risk";
import { Rule as MerchantRule } from "./Rule";
import { Rules as MerchantRules } from "./Rules";
export interface Merchant extends MerchantBase {
    agent: string;
    created?: isoly.Date;
    processor: MerchantProcessor | {
        visa: MerchantProcessor;
        mastercard: MerchantProcessor;
    };
    risk?: MerchantRisk;
}
export declare namespace Merchant {
    function is(value: any | Merchant): value is Merchant;
    function flaw(value: any | Merchant): gracely.Flaw;
    function getDescriptor(merchant: Merchant | Merchant.Creatable): string | undefined;
    function getReference(merchant: Merchant | Merchant.Creatable, processor: Settlement.Processor | Authorization.Processor.Name, scheme?: "visa" | "mastercard"): string | undefined;
    function getProcessor(merchant: Merchant | Merchant.Creatable, scheme?: model.Card.Scheme): MerchantProcessor | undefined;
    function getProcessorName(merchant: Merchant | Merchant.Creatable, scheme?: model.Card.Scheme): Authorization.Processor.Name | undefined;
    function toCsv(merchants: Merchant[]): string;
    const template: import("selectively/dist/Type/Object").TObject;
    type Base = MerchantBase;
    namespace Base {
        const from: typeof MerchantBase.from;
        const flaw: typeof MerchantBase.flaw;
    }
    type Creatable = MerchantCreatable;
    namespace Creatable {
        const is: typeof MerchantCreatable.is;
        const flaw: typeof MerchantCreatable.flaw;
    }
    type Operation = MerchantOperation;
    namespace Operation {
        const is: typeof MerchantOperation.is;
        const types: readonly ["authorization", "capture", "refund", "void", "all", "payout"];
    }
    type Fee = MerchantFee;
    namespace Fee {
        const is: typeof MerchantFee.is;
        const apply: typeof MerchantFee.apply;
        type Transaction = MerchantFee.Transaction;
        namespace Transaction {
            const is: typeof import("./Fee/Transaction").Transaction.is;
            const isUnified: typeof import("./Fee/Transaction").Transaction.isUnified;
            const apply: typeof import("./Fee/Transaction").Transaction.apply;
        }
    }
    type Rules = MerchantRules;
    namespace Rules {
        const is: typeof MerchantRules.is;
        const flaw: typeof MerchantRules.flaw;
        const apply: typeof MerchantRules.apply;
        const parse: typeof MerchantRules.parse;
    }
    namespace Risk {
        type Risk = MerchantRisk;
        const is: typeof MerchantRisk.is;
    }
    type Rule = MerchantRule;
    namespace Rule {
        const is: typeof MerchantRule.is;
        const apply: typeof MerchantRule.apply;
        const parse: typeof MerchantRule.parse;
        const stringify: typeof MerchantRule.stringify;
        const toFlaw: typeof MerchantRule.toFlaw;
    }
    type Reconciliation = MerchantReconciliation;
    namespace Reconciliation {
        const is: typeof MerchantReconciliation.is;
        const flaw: typeof MerchantReconciliation.flaw;
        type Transaction = MerchantReconciliation.Transaction;
        type Account = MerchantReconciliation.Account;
        namespace Transaction {
            const is: typeof import("./Reconciliation/Transaction").Transaction.is;
            const toCsv: typeof import("./Reconciliation/Transaction").Transaction.toCsv;
        }
        namespace Account {
            const is: typeof import("./Account").Account.is;
        }
    }
    type Processor = MerchantProcessor;
    namespace Processor {
        type Acceptor = MerchantProcessor.Acceptor;
        namespace Acceptor {
            const is: typeof import("./Processor/Acceptor").Acceptor.is;
            const flaw: typeof import("./Processor/Acceptor").Acceptor.flaw;
        }
        type Configuration = MerchantProcessor.Configuration;
        namespace Configuration {
            const is: typeof import("./Processor/Configuration").Configuration.is;
            const flaw: typeof import("./Processor/Configuration").Configuration.flaw;
        }
    }
}