import type { Address, Hex, SignedAuthorization } from 'viem';
import type { AccountRuntimePort } from '../../accounts/adapter.js';
import type { UnresolvedCall } from '../../calls/types.js';
import type { ChainReference, EvmChainReference } from '../../chains/types.js';
import type { IntentQuotePort, IntentStatusPort, IntentSubmissionPort } from '../../clients/orchestrator/port.js';
import type { IntentOpStatus, OriginSignature, Quote } from '../../clients/orchestrator/public.js';
import type { OrchestratorAccount, OrchestratorAccountAccessList, OrchestratorIntentOptions, OrchestratorIntentRequest, OrchestratorOriginSignature, OrchestratorQuote } from '../../clients/orchestrator/types.js';
import type { Transaction } from '../../config/account.js';
import type { ResolvedSessionSignerSet, Session, SessionEnableData } from '../../modules/validators/smart-sessions/types.js';
import type { IntentSigningInput } from '../../signing/intent-plans/types.js';
import type { OwnerSignerSelection, SignerInvocationPort, SigningCheckpointPort, SigningTranscript } from '../../signing/types.js';
export interface IntentTokenRequest {
    readonly token: Address | string;
    readonly amount?: bigint;
}
export interface IntentSourceCall<CompatibilityConfig> {
    readonly call: UnresolvedCall<CompatibilityConfig>;
    readonly provides?: readonly {
        readonly token: Address;
        readonly amount: bigint;
    }[];
}
export interface IntentSessionSelection {
    readonly kind: 'smart-session';
    readonly byChain: Readonly<Record<number, {
        readonly session: Session;
        readonly enableData?: SessionEnableData;
    }>>;
}
export interface IntentInput<CompatibilityConfig = unknown> {
    readonly destination: ChainReference;
    readonly sourceChains?: readonly EvmChainReference[];
    readonly calls: readonly UnresolvedCall<CompatibilityConfig>[];
    readonly tokenRequests: readonly IntentTokenRequest[];
    readonly recipient?: OrchestratorAccount;
    readonly gasLimit?: bigint;
    readonly eip7702InitSignature?: Hex;
    readonly accountAccessList?: OrchestratorAccountAccessList;
    readonly options?: Omit<OrchestratorIntentOptions, 'signatureMode'>;
    readonly signatureMode?: number;
    readonly sourceCalls?: Readonly<Record<number, readonly IntentSourceCall<CompatibilityConfig>[]>>;
    readonly accountSetupOverride?: readonly {
        readonly to: Address;
        readonly data: Hex;
    }[];
    readonly signers?: OwnerSignerSelection | IntentSessionSelection;
}
export interface PreparedIntent<CompatibilityConfig = unknown> {
    readonly traceId: string;
    readonly input: IntentInput<CompatibilityConfig>;
    readonly request: OrchestratorIntentRequest;
    readonly quote: OrchestratorQuote;
    readonly quotes: readonly OrchestratorQuote[];
    readonly signing: IntentSigningInput;
    readonly accountChain: EvmChainReference;
    readonly resolvedSessions?: Readonly<Record<number, ResolvedSessionSignerSet>>;
    readonly sessionEnvironment?: 'production' | 'development';
}
export interface SignedIntent<CompatibilityConfig = unknown> {
    readonly prepared: PreparedIntent<CompatibilityConfig>;
    readonly originSignatures: readonly OrchestratorOriginSignature[];
    readonly destinationSignature: Hex;
    readonly targetSignature?: Hex;
    readonly transcript: SigningTranscript;
    readonly authorizations?: readonly SignedAuthorization[];
    readonly dryRun?: boolean;
}
export interface SubmittedIntent {
    readonly type: 'intent';
    readonly traceId: string;
    readonly intentId: string;
    readonly sourceChains?: readonly number[];
    readonly targetChain: number;
}
export interface IntentStatus {
    readonly traceId: string;
    readonly intentId: string;
    readonly status: IntentOpStatus['status'];
    readonly account: Address;
    readonly operations: readonly IntentOpStatus['operations'][number][];
    readonly terminal: boolean;
}
export interface IntentWorkflowContext<CompatibilityConfig = unknown> {
    readonly compatibilityConfig: CompatibilityConfig;
    readonly account: AccountRuntimePort;
    readonly quoteClient: IntentQuotePort;
    readonly submissionClient: IntentSubmissionPort;
    readonly statusClient: IntentStatusPort;
    readonly signerInvoker: SignerInvocationPort;
    readonly checkpoints: SigningCheckpointPort;
    readonly signAuthorizations: (input: {
        readonly chains: readonly ChainReference[];
        readonly eip7702InitSignature: Hex;
    }) => Promise<readonly SignedAuthorization[]>;
    readonly clock: {
        readonly now: () => number;
        readonly sleep: (milliseconds: number) => Promise<void>;
    };
}
export interface TransactionResult {
    type: 'intent';
    id: string;
    traceId: string;
    sourceChains?: number[];
    targetChain: number;
}
export interface PreparedQuotes {
    traceId: string;
    best: Quote;
    all: Quote[];
}
export interface PreparedTransactionData {
    quotes: PreparedQuotes;
    intentInput: unknown;
    transaction: Transaction;
}
export interface QuoteSelection {
    intentId: string;
}
export interface SignedTransactionData extends PreparedTransactionData {
    quote: Quote;
    originSignatures: OriginSignature[];
    destinationSignature: Hex;
    targetExecutionSignature: Hex | undefined;
}
export interface TransactionStatus {
    /** OpenTelemetry trace ID for correlating the status response. */
    traceId: IntentOpStatus['traceId'];
    /** High-level intent status. */
    status: IntentOpStatus['status'];
    /** The account address that owns this intent. */
    accountAddress: Address;
    /** Per-chain operation status. One entry per chain. */
    operations: IntentOpStatus['operations'];
}
//# sourceMappingURL=types.d.ts.map