import { HexString, OutpointString, PubKeyHex, Base64String, WalletInterface } from '../wallet/index.js';
/**
 * Types for core Remittance protocol.
 *
 * The goal is to keep the core protocol:
 * - UTXO-friendly (transactions and partial transactions can be carried as artifacts)
 * - Denomination-agnostic (amounts are typed, not forced to satoshis)
 * - Module-oriented (remittance option payloads are opaque to the core)
 */
export type ThreadId = Base64String;
export type RemittanceOptionId = Base64String;
export type UnixMillis = number;
/**
 * Remittance thread state machine.
 *
 * States:
 * - new: thread exists but no identity/invoice/settlement activity yet.
 * - identityRequested: identity request sent or received.
 * - identityResponded: identity response sent or received.
 * - identityAcknowledged: identity response acknowledged (required before proceeding).
 * - invoiced: invoice sent or received.
 * - settled: settlement sent or received.
 * - receipted: receipt issued or received.
 * - terminated: thread terminated with a reason.
 * - errored: unexpected error occurred while processing the thread.
 */
export type RemittanceThreadState = 'new' | 'identityRequested' | 'identityResponded' | 'identityAcknowledged' | 'invoiced' | 'settled' | 'receipted' | 'terminated' | 'errored';
/**
 * Allowed remittance state transitions.
 *
 * This is the canonical state machine for remittance threads.
 * Use it to validate transitions and to build audits/visualizations.
 */
export declare const REMITTANCE_STATE_TRANSITIONS: Record<RemittanceThreadState, RemittanceThreadState[]>;
export interface Unit {
    /** Namespace for disambiguation, e.g. 'bsv', 'iso4217', 'token'. */
    namespace: string;
    /** Unit code within the namespace, e.g. 'sat', 'USD', 'mnee'. */
    code: string;
    /** Optional decimal places for display/normalization. */
    decimals?: number;
}
export interface Amount {
    /** Decimal string. Avoid floats at the protocol layer. */
    value: string;
    unit: Unit;
}
export declare const SAT_UNIT: Unit;
export interface LineItem {
    id?: string;
    description: string;
    /** Decimal string, e.g. '1', '2', '0.5'. */
    quantity?: string;
    unitPrice?: Amount;
    /** Total amount for the line (optional if derivable). */
    amount?: Amount;
    metadata?: Record<string, unknown>;
}
/**
 * Shared commercial/metadata fields for invoice and receipt-like instruments.
 *
 * NOTE: "payee" and "payer" are identity keys, not addresses.
 * Payment addresses / scripts are settlement-module concerns.
 */
export interface InstrumentBase {
    threadId: ThreadId;
    payee: PubKeyHex;
    payer: PubKeyHex;
    note?: string;
    lineItems: LineItem[];
    total: Amount;
    invoiceNumber: string;
    createdAt: UnixMillis;
    arbitrary?: Record<string, unknown>;
}
/**
 * Invoice (solicitation) that contains N remittance options.
 *
 * Each remittance option is keyed by a module id.
 * The payload for each option is module-defined and opaque to the core.
 *
 * This is where “UTXO offers” live: a module option payload can include a partial tx template,
 * UTXO references, scripts, overlay anchors, SPV, etc. The manager does not interpret them.
 */
export interface Invoice extends InstrumentBase {
    kind: 'invoice';
    expiresAt?: UnixMillis;
    options: Record<RemittanceOptionId, unknown>;
}
/**
 * An identity certificate request.
 *
 * Contains a list of requested certificate types, fields from each, plus acceptable certifiers.
 */
export interface IdentityVerificationRequest {
    kind: 'identityVerificationRequest';
    threadId: ThreadId;
    /** Details of the requested certificates. */
    request: {
        /** Map of certificate types to requested fields from each. */
        types: Record<string, string[]>;
        /** List of acceptable certifier identity keys. */
        certifiers: PubKeyHex[];
    };
}
/**
 * An identity certificate response.
 *
 * Contains certificates issued by the certifiers named in the corresponding request, with fields revealed to the counterparty.
 */
export interface IdentityVerificationResponse {
    kind: 'identityVerificationResponse';
    threadId: ThreadId;
    /** List of certificates issued by the certifiers named in the corresponding request, with fields revealed to the counterparty. */
    certificates: Array<{
        /** Certificate type, e.g. base64 Type ID corresponding to 'personalId', 'businessId', etc. */
        type: Base64String;
        /** Certifier identity key. */
        certifier: PubKeyHex;
        /** Subject identity key. */
        subject: PubKeyHex;
        /** The certificate's encrypted fields that have been signed. */
        fields: Record<string, Base64String>;
        /** Signature over the cert. */
        signature: HexString;
        /** Certificate serial number. */
        serialNumber: Base64String;
        /** Revocation outpoint. If spent on-chain, the certificate is invalid. */
        revocationOutpoint: OutpointString;
        /** Field revelation keys for the counterparty. */
        keyringForVerifier: Record<string, Base64String>;
    }>;
}
/**
 * An identity verification acknowledgment.
 *
 * A simple ack message indicating that a requested identity verification has been completed successfully.
 */
export interface IdentityVerificationAcknowledgment {
    kind: 'identityVerificationAcknowledgment';
    threadId: ThreadId;
}
/**
 * A settlement attempt.
 *
 * This is module-agnostic: "artifact" can be a transaction, a partial transaction,
 * a stablecoin transfer result, even a fiat card-payment approval code, etc.
 */
export interface Settlement {
    kind: 'settlement';
    threadId: ThreadId;
    moduleId: RemittanceOptionId;
    optionId: RemittanceOptionId;
    sender: PubKeyHex;
    createdAt: UnixMillis;
    artifact: unknown;
    note?: string;
}
/**
 * Receipt issued by the payee (or service provider).
 *
 * A receipt could be a PDF, a photo/oroof-of-delivery, a copy of the payment transaction, etc.
*
 * A receipt should NOT be issued when a settlement is rejected/failed. Use a Termination instead.
 */
export interface Receipt {
    kind: 'receipt';
    threadId: ThreadId;
    moduleId: RemittanceOptionId;
    optionId: RemittanceOptionId;
    payee: PubKeyHex;
    payer: PubKeyHex;
    createdAt: UnixMillis;
    receiptData: unknown;
}
/**
 * Termination details for failed operations.
 */
export interface Termination {
    /** Reason code (module-specific). */
    code: string;
    /** Human-readable message. */
    message: string;
    /** Optional module-specific details or refund information. */
    details?: unknown;
}
/**
 * Transport message format expected from the CommsLayer.
 *
 * It closely matches the message-box-client shapes:
 * messageId, sender, body, etc.
 */
export interface PeerMessage {
    messageId: string;
    sender: PubKeyHex;
    recipient: PubKeyHex;
    messageBox: string;
    body: string;
}
/**
 * Protocol envelope kinds.
 * Everything runs in “threads” and carries a threadId.
 */
export type RemittanceKind = 'invoice' | 'identityVerificationRequest' | 'identityVerificationResponse' | 'identityVerificationAcknowledgment' | 'settlement' | 'receipt' | 'termination';
/**
 * Protocol envelope.
 *
 * This is what RemittanceManager serializes into the CommsLayer message body.
 */
export interface RemittanceEnvelope<K extends RemittanceKind = RemittanceKind, P = unknown> {
    /** Protocol version. */
    v: 1;
    /** Envelope id (idempotency key). Not the transport messageId. */
    id: string;
    kind: K;
    threadId: ThreadId;
    createdAt: UnixMillis;
    payload: P;
}
/**
 * Simple logger interface.
 */
export interface LoggerLike {
    log: (...args: any[]) => void;
    warn: (...args: any[]) => void;
    error: (...args: any[]) => void;
}
/**
 * Context object passed to module methods.
 */
export interface ModuleContext {
    wallet: WalletInterface;
    /** Optional originator domain forwarded to wallet methods. */
    originator?: unknown;
    now: () => number;
    logger?: LoggerLike;
}
//# sourceMappingURL=types.d.ts.map