import { Address, Hex } from 'viem';
import type { UserOperation } from 'viem/account-abstraction';
export type SupportedTestnet = 11155111 | 84532 | 421614 | 11155420 | 80002;
export type SupportedMainnet = 1 | 8453 | 42161 | 10 | 137;
export type SupportedChain = SupportedMainnet | SupportedTestnet;
export type SupportedTokens = 'ETH' | 'WETH' | 'USDC';
export type SupportedTokenIdentitfiers = SupportedTokens | Address;
export type AccountAccessListV1 = {
    chainId: number;
    tokenAddress: Address;
}[];
export type MappedChainTokenAccessList = {
    chainTokens?: {
        [chainId in SupportedChain]?: SupportedTokenIdentitfiers[];
    };
};
export type UnmappedChainTokenAccessList = {
    chainIds?: SupportedChain[];
    tokens?: SupportedTokens[];
};
export type AccountAccessListV2 = MappedChainTokenAccessList | UnmappedChainTokenAccessList;
export type AccountAccessList = AccountAccessListV1 | AccountAccessListV2;
export type MultiChainCompact = {
    sponsor: Address;
    nonce: bigint;
    expires: bigint;
    segments: Segment[];
};
export type Segment = {
    arbiter: Address;
    chainId: bigint;
    idsAndAmounts: [bigint, bigint][];
    witness: Witness;
};
export type Witness = {
    recipient: Address;
    tokenOut: [bigint, bigint][];
    depositId: bigint;
    targetChain: bigint;
    fillDeadline: number;
    execs: Execution[];
    userOpHash: Hex;
    maxFeeBps: number;
};
export type Execution = {
    to: Address;
    value: bigint;
    data: Hex;
};
export type BatchCompact = {
    arbiter: Address;
    sponsor: Address;
    nonce: bigint;
    expires: bigint;
    idsAndAmounts: [bigint, bigint][];
    witness: Witness;
};
export type QualificationWitness = {
    claimHash: Hex;
    targetChainSignatureHash: Hex;
    targetWETHAddress: Address;
};
export type ChainNotarization = {
    originAccount: Address;
    originModule: Address;
    notarizedChainId: bigint;
    nonce: bigint;
    expires: bigint;
    notarizedWitness: Hex;
    idsAndAmountsTokenInHash: Hex;
};
export type TargetChainAttributes = {
    recipient: Address;
    tokenOut: [bigint, bigint][];
    targetWETHAddress: Address;
    depositId: bigint;
    fillDeadline: number;
};
export type MultiOriginMessage = {
    notarization: ChainNotarization;
    targetChain: TargetChainAttributes;
    otherSegments: Hex[];
    executions: Execution[];
    userSig: Hex;
};
export type SingleOriginMessage = {
    notarization: ChainNotarization;
    targetChain: TargetChainAttributes;
    executions: Execution[];
    userSig: Hex;
};
export type UserOperationMessage = {
    targetChain: TargetChainAttributes;
    userOp: PackedUserOperation;
    nonce: bigint;
};
export type TokenArrays6909 = readonly (readonly [bigint, bigint])[];
export type IntentFillPayload = {
    segments: SegmentData[];
    message: Hex;
    orchestratorSig: Hex;
};
export type SegmentData = {
    tokenIn: [bigint, bigint][];
    tokenOut: [bigint, bigint][];
    originWETHAddress: Address;
    originChainId: bigint;
    baseDepositId: bigint;
};
export type SignedMultiChainCompact = MultiChainCompact & {
    originSignatures: Hex[];
    targetSignature: Hex;
};
export type TokenTransfer = {
    tokenAddress: Address;
    amount: bigint;
};
type WithUserOp = {
    userOp: UserOperation;
    targetExecutions?: never;
};
type WithExecutions = {
    userOp?: never;
    targetExecutions: Execution[];
};
type WithoutOperation = {
    userOp?: never;
    targetExecutions?: never;
};
type MetaIntentBase = {
    targetChainId: number;
    tokenTransfers: TokenTransfer[];
    targetAccount: Address;
    targetGasUnits?: bigint;
    accountAccessList?: AccountAccessList;
    omniLock?: boolean;
};
export type MetaIntentEmpty = MetaIntentBase & WithoutOperation;
export type MetaIntentWithUserOp = MetaIntentBase & WithUserOp;
export type MetaIntentWithExecutions = MetaIntentBase & WithExecutions;
export type MetaIntent = MetaIntentEmpty | MetaIntentWithUserOp | MetaIntentWithExecutions;
export type ChainExecution = Execution & {
    chainId: number;
};
export type BundleEvent = {
    bundleId: bigint;
    type: string;
    targetFillPayload: ChainExecution;
    acrossDepositEvents: DepositEvent[];
};
export type DepositEvent = {
    originClaimPayload: ChainExecution;
    inputToken: Address;
    outputToken: Address;
    inputAmount: bigint;
    outputAmount: bigint;
    destinationChainId: number;
    originChainId: number;
    depositId: bigint;
    quoteTimestamp: number;
    fillDeadline: number;
    exclusivityDeadline: number;
    depositor: Address;
    recipient: Address;
    exclusiveRelayer: Address;
    message: Hex;
};
export type SignedTokenUnlock = {
    chainId: number;
    tokenAddress: Address;
    amount: bigint;
    timestamp: number;
    nonce: bigint;
    signature: Hex;
    verifyingContract: Address;
};
export type Token = {
    symbol: string;
    address: Address;
    chainId: number;
};
export type UserTokenBalance = {
    tokenName: string;
    tokenDecimals: number;
    balance: bigint;
    tokenChainBalance: {
        chainId: number;
        tokenAddress: Address;
        balance: bigint;
    }[];
};
export type UserChainBalances = {
    [chainId: number]: {
        [tokenAddress: Address]: bigint;
    };
};
export type OrderFeeInput = {
    targetChainId: number;
    targetGasUnits?: bigint;
    userOp?: {
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
    };
    tokenTransfers: {
        tokenAddress: Address;
        amount?: bigint;
    }[];
    accountAccessList?: AccountAccessList;
};
export type TokenFulfillmentStatus = {
    hasFulfilled: boolean;
    tokenAddress: Address;
    amountSpent: bigint;
    targetAmount: bigint;
    fee: bigint;
};
export type OrderCost = {
    hasFulfilledAll: true;
    tokensSpent: UserChainBalances;
    tokensReceived: TokenFulfillmentStatus[];
};
export type InsufficientBalanceResult = {
    hasFulfilledAll: false;
    tokenShortfall: {
        tokenAddress: Address;
        targetAmount: bigint;
        amountSpent: bigint;
        fee: bigint;
        tokenSymbol: string;
        tokenDecimals: number;
    }[];
    totalTokenShortfallInUSD: bigint;
};
export type OrderCostResult = OrderCost | InsufficientBalanceResult;
export declare enum BundleStatus {
    PENDING = "PENDING",// bundle is created and all claims are pending
    EXPIRED = "EXPIRED",// bundle is created and call claims are expired
    PARTIALLY_COMPLETED = "PARTIALLY_COMPLETED",// = not completed :D (at least one claim made or fill happened)
    PRECONFRIMED = "PRECONFRIMED",// fill confirmed by relayers
    FILLED = "FILLED",// fill happened, deposits are not claimed yet
    COMPLETED = "COMPLETED",// fill tx received, all deposits claimed
    FAILED = "FAILED",// either fill expired with at least one claim, or claims expired and fill happened
    UNKNOWN = "UNKNOWN"
}
export declare enum ClaimStatus {
    PENDING = "PENDING",// not expired and not yet claimed
    EXPIRED = "EXPIRED",// claim is not possible as it is expired
    CLAIMED = "CLAIMED"
}
export type SimulationResult = {
    success: true;
} | {
    success: false;
    call: Execution;
    details: {
        blockNumber: bigint;
    };
};
export type PostOrderBundleResult = ({
    bundleId: bigint;
    status: BundleStatus.PENDING;
} | {
    bundleId: bigint;
    status: BundleStatus.FAILED;
    error: SimulationResult;
})[];
export type BundleResult = {
    status: BundleStatus;
    fillTimestamp?: number;
    fillTransactionHash?: Hex;
    claims: Claim[];
};
export type Claim = {
    depositId: bigint;
    chainId: number;
    status: ClaimStatus;
    claimTimestamp?: number;
    claimTransactionHash?: Hex;
};
export type PackedUserOperation = {
    sender: Address;
    nonce: bigint;
    initCode: Hex;
    callData: Hex;
    accountGasLimits: Hex;
    preVerificationGas: bigint;
    gasFees: Hex;
    paymasterAndData: Hex;
    signature: Hex;
};
export type OrchestratorChainConfig = {
    spokepool: Address;
    hook: Address;
    originModule: Address;
    targetModule: Address;
    sameChainModule: Address;
    weth: Address;
    supportedTokens: TokenConfig[];
};
export type TokenConfig = {
    symbol: string;
    address: Address;
    decimals: number;
    balanceSlot: (address: Address) => Hex;
};
export {};
//# sourceMappingURL=types.d.ts.map