import type { AnyAmount, AssetKind, DisplayInfo, Issuer, NatValue, Payment } from '@agoric/ertp';
import type { Subscriber } from '@agoric/notifier';
import type { ERef, EReturn } from '@endo/eventual-send';
import type { Bundle, BundleID } from '@agoric/swingset-vat';
import type { ContractStartFunction, StartParams } from './utils.js';
import type { Keyword, InvitationHandle, BrandKeywordRecord, Handle, IssuerKeywordRecord } from '../types.js';
import type { Allocation } from '../types-index.js';
/**
 * @see {@link https://github.com/sindresorhus/type-fest/blob/main/source/is-any.d.ts}
 */
type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
/**
 * Zoe provides a framework for deploying and working with smart
 * contracts. It is accessed as a long-lived and well-trusted service
 * that enforces offer safety for the contracts that use it. Zoe has a
 * single `invitationIssuer` for the entirety of its lifetime. By
 * having a reference to Zoe, a user can get the `invitationIssuer`
 * and thus validate any `invitation` they receive from someone else.
 *
 * Zoe has two different facets: the public Zoe service and the
 * contract facet (ZCF). Each contract instance has a copy of ZCF
 * within its vat. The contract and ZCF never have direct access to
 * the users' payments or the Zoe purses.
 */
export type ZoeService = {
    /**
     * Zoe has a single `invitationIssuer` for the entirety of its
     * lifetime. By having a reference to Zoe, a user can get the
     * `invitationIssuer` and thus validate any `invitation` they receive
     * from someone else. The mint associated with the invitationIssuer
     * creates the ERTP payments that represent the right to interact with
     * a smart contract in particular ways.
     */
    getInvitationIssuer: GetInvitationIssuer;
    install: InstallBundle;
    installBundleID: InstallBundleID;
    startInstance: import('./utils.js').StartInstance;
    offer: Offer;
    getPublicFacet: <I extends Instance>(instance: ERef<I>) => Promise<IsAny<I> extends true ? any : I extends import('./utils.js').Instance<infer SF extends ContractStartFunction> ? IsAny<SF> extends true ? unknown : EReturn<SF>['publicFacet'] : never>;
    getIssuers: GetIssuers;
    getBrands: GetBrands;
    getTerms: <I extends ERef<Instance>>(instance: I) => IsAny<I> extends true ? Promise<any> : I extends ERef<import('./utils.js').Instance<infer SF extends ContractStartFunction>> ? IsAny<SF> extends true ? Promise<unknown> : Promise<StartParams<SF>['terms']> : never;
    getOfferFilter: (instance: ERef<Instance>) => Promise<string[]>;
    getInstallationForInstance: GetInstallationForInstance;
    getInstance: GetInstance;
    getInstallation: GetInstallation;
    /**
     *   Return an object with the instance, installation, description, invitation
     *   handle, and any custom properties specific to the contract.
     */
    getInvitationDetails: GetInvitationDetails;
    getFeeIssuer: GetFeeIssuer;
    getConfiguration: GetConfiguration;
    getBundleIDFromInstallation: GetBundleIDFromInstallation;
    /**
     *   Return the pattern (if any) associated with the invitationHandle that a
     *   proposal is required to match to be accepted by zoe.offer().
     */
    getProposalShapeForInvitation: (invitationHandle: InvitationHandle) => import('@endo/patterns').Pattern | undefined;
};
type GetInvitationIssuer = () => Promise<Issuer<'set', InvitationDetails>>;
type GetFeeIssuer = () => Promise<Issuer<'nat'>>;
type GetConfiguration = () => {
    feeIssuerConfig: FeeIssuerConfig;
};
export type GetIssuers = (instance: import('./utils.js').Instance<any>) => Promise<IssuerKeywordRecord>;
export type GetBrands = (instance: import('./utils.js').Instance<any>) => Promise<BrandKeywordRecord>;
type GetInstallationForInstance = (instance: import('./utils.js').Instance<any>) => Promise<Installation>;
export type GetInstance = (invitation: ERef<import('../types-index.js').Invitation>) => Promise<import('./utils.js').Instance<any>>;
export type GetInstallation = (invitation: ERef<import('../types-index.js').Invitation>) => Promise<Installation>;
export type GetInvitationDetails = (invitation: ERef<import('../types-index.js').Invitation<any, any>>) => Promise<InvitationDetails>;
/**
 * Create an installation by safely evaluating the code and
 * registering it with Zoe. Returns an installation.
 */
export type InstallBundle = (bundle: Bundle | SourceBundle, bundleLabel?: string | undefined) => Promise<Installation>;
/**
 * Create an installation from a Bundle ID. Returns an installation.
 */
export type InstallBundleID = (bundleID: BundleID, bundleLabel?: string | undefined) => Promise<Installation>;
/**
 * Verify that an alleged Installation is real, and return the Bundle ID it
 * will use for contract code.
 */
export type GetBundleIDFromInstallation = (allegedInstallation: ERef<Installation>) => Promise<string>;
/**
 * To redeem an invitation, the user normally provides a proposal (their
 * rules for the offer) as well as payments to be escrowed by Zoe.  If
 * either the proposal or payments would be empty, indicate this by
 * omitting that argument or passing undefined, rather than passing an
 * empty record.
 *
 * The proposal has three parts: `want` and `give` are used by Zoe to
 * enforce offer safety, and `exit` is used to specify the particular
 * payout-liveness policy that Zoe can guarantee. `want` and `give`
 * are objects with keywords as keys and amounts as values.
 * `paymentKeywordRecord` is a record with keywords as keys, and the
 * values are the actual payments to be escrowed. A payment is
 * expected for every rule under `give`.
 */
export type Offer = <Result, Args = undefined>(invitation: ERef<import('../types-index.js').Invitation<Result, Args>>, proposal?: Proposal, paymentKeywordRecord?: PaymentPKeywordRecord, offerArgs?: Args) => Promise<UserSeat<Result>>;
/**
 * Zoe uses seats to access or manipulate offers. They let contracts and users
 * interact with them. Zoe has two kinds of seats. ZCFSeats are used within
 * contracts and with zcf methods. UserSeats represent offers external to Zoe
 * and the contract. The party who exercises an invitation and sends the offer()
 * message to Zoe gets a UserSeat that can check payouts' status or retrieve the
 * result of processing the offer in the contract. This varies, but examples are
 * a string and an invitation for another seat.
 *
 * Also, a UserSeat can be handed to an agent outside Zoe and the contract,
 * letting them query or monitor the current state, access the payouts and
 * result, and, if it's allowed for this seat, call tryExit().
 *
 * Since anyone can attempt to exit the seat if they have a reference to it, you
 * should only share a UserSeat with trusted parties.
 *
 * UserSeat includes queries for the associated offer's current state and an
 * operation to request that the offer exit, as follows:
 */
export type UserSeat<OR = unknown> = {
    getProposal: () => Promise<ProposalRecord>;
    /**
     * returns a promise for a KeywordPaymentRecord containing all the payouts from
     * this seat. The promise will resolve after the seat has exited.
     */
    getPayouts: () => Promise<PaymentPKeywordRecord>;
    /**
     * returns a promise for the Payment corresponding to the indicated keyword.
     * The promise will resolve after the seat has exited. If there is no payment
     * corresponding to the keyword, an error will be thrown. (It used to return
     * undefined.)
     */
    getPayout: (keyword: Keyword) => Promise<Payment<any, any>>;
    getOfferResult: () => Promise<OR>;
    /**
     * Note: Only works if the seat's `proposal` has an `OnDemand` `exit` clause. Zoe's
     * offer-safety guarantee applies no matter how a seat's interaction with a
     * contract ends. Under normal circumstances, the participant might be able to
     * call `tryExit()`, or the contract might do something explicitly. On exiting,
     * the seat holder gets its current `allocation` and the `seat` can no longer
     * interact with the contract.
     */
    tryExit?: (() => void) | undefined;
    /**
     * Returns true if the seat has exited, false if it is still active.
     */
    hasExited: () => Promise<boolean>;
    /**
     * returns 1 if the proposal's
     * want clause was satisfied by the final allocation, otherwise 0. This is
     * numeric to support a planned enhancement called "multiples" which will allow
     * the return value to be any non-negative number. The promise will resolve
     * after the seat has exited.
     */
    numWantsSatisfied: () => Promise<0 | 1>;
    /**
     * return a promise for the final allocation. The promise will resolve after the
     * seat has exited.
     */
    getFinalAllocation: () => Promise<Allocation>;
    /**
     * returns a subscriber that
     * will be notified when the seat has exited or failed.
     */
    getExitSubscriber: () => Subscriber<import('../types-index.js').Completion>;
};
export type Proposal = Partial<ProposalRecord>;
export type ProposalRecord = {
    give: AmountKeywordRecord;
    want: AmountKeywordRecord;
    exit: ExitRule;
};
/**
 * The keys are keywords, and the values are amounts. For example:
 * { Asset: AmountMath.make(assetBrand, 5n), Price:
 * AmountMath.make(priceBrand, 9n) }
 */
export type AmountKeywordRecord = Record<Keyword, AnyAmount>;
export type Waker = {
    wake: () => void;
};
export type OnDemandExitRule = {
    onDemand: null;
};
export type WaivedExitRule = {
    waived: null;
};
export type AfterDeadlineExitRule = {
    afterDeadline: {
        timer: import('@agoric/time').TimerService;
        deadline: import('@agoric/time').Timestamp;
    };
};
/**
 * The possible keys are 'waived', 'onDemand', and 'afterDeadline'.
 * `timer` and `deadline` only are used for the `afterDeadline` key.
 * The possible records are:
 * `{ waived: null }`
 * `{ onDemand: null }`
 * `{ afterDeadline: { timer :Timer<Deadline>, deadline :Deadline } }`
 */
export type ExitRule = OnDemandExitRule | WaivedExitRule | AfterDeadlineExitRule;
export type Instance<SF = any> = import('./utils.js').Instance<SF>;
export type ZCFSpec = {
    bundleCap: import('@agoric/swingset-vat').BundleCap;
} | {
    name: string;
} | {
    /** Bundle ID */
    id: string;
};
/**
 * Opaque type for a JSONable source bundle
 */
export type SourceBundle = Record<string, any>;
export type PaymentPKeywordRecord = Record<Keyword, ERef<Payment<any>>>;
export type PaymentKeywordRecord = Record<Keyword, Payment<any>>;
export type InvitationDetails = {
    installation: Installation;
    instance: import('./utils.js').Instance<any>;
    handle: InvitationHandle;
    description: string;
    customDetails?: Record<string, any> | undefined;
};
export type Installation<SF = any> = import('./utils.js').Installation<SF>;
export type InstallationStart<I extends Installation> = import('./utils.js').InstallationStart<I>;
export type FeeIssuerConfig = {
    name: string;
    assetKind: AssetKind;
    displayInfo: DisplayInfo;
};
export type ZoeFeesConfig = {
    getPublicFacetFee: NatValue;
};
export type FeeMintAccess = Handle<'feeMintAccess'>;
export {};
//# sourceMappingURL=types.d.ts.map