import { HybridDeleGator, MultiSigDeleGator, EIP7702StatelessDeleGator } from '@metamask/delegation-abis';
import { Address, Hex, PublicClient, WalletClient, Transport, Chain, Account, OneOf } from 'viem';
import { WebAuthnAccount, SmartAccount, SmartAccountImplementation, entryPoint07Abi } from 'viem/account-abstraction';
import { Prettify } from 'viem/chains';

declare enum Implementation {
    MultiSig = "MultiSig",
    Hybrid = "Hybrid",
    Stateless7702 = "Stateless7702"
}

type ExecutionStruct = {
    target: Address;
    value: bigint;
    callData: Hex;
};
type CreateExecutionArgs = {
    target: Address;
    value?: bigint;
    callData?: Hex;
};
declare const createExecution: ({ target, value, callData, }: CreateExecutionArgs) => ExecutionStruct;
declare enum ExecutionMode {
    SingleDefault = "0x0000000000000000000000000000000000000000000000000000000000000000",
    SingleTry = "0x0001000000000000000000000000000000000000000000000000000000000000",
    BatchDefault = "0x0100000000000000000000000000000000000000000000000000000000000000",
    BatchTry = "0x0101000000000000000000000000000000000000000000000000000000000000"
}
declare const encodeSingleExecution: (execution: ExecutionStruct) => Hex;
declare const encodeBatchExecution: (executions: ExecutionStruct[]) => Hex;
declare const encodeExecutionCalldata: (executions: ExecutionStruct[]) => Hex;
declare const encodeExecutionCalldatas: (executionsBatch: ExecutionStruct[][]) => Hex[];

type Caveat = {
    enforcer: Hex;
    terms: Hex;
    args: Hex;
};
type Delegation = {
    delegate: Hex;
    delegator: Hex;
    authority: Hex;
    caveats: Caveat[];
    salt: Hex;
    signature: Hex;
};
type DeleGatorEnvironment = {
    DelegationManager: Hex;
    EntryPoint: Hex;
    SimpleFactory: Hex;
    implementations: {
        [implementation: string]: Hex;
    };
    caveatEnforcers: {
        [enforcer: string]: Hex;
    };
};
type MultiSigDeleGatorDeployParams = [signers: Hex[], threshold: bigint];
type HybridDeleGatorDeployParams = [
    owner: Hex,
    keyIds: string[],
    xValues: bigint[],
    yValues: bigint[]
];
type Redemption = {
    permissionContext: Delegation[];
    executions: ExecutionStruct[];
    mode: ExecutionMode;
};
type DeployParams<TImplementation extends Implementation> = {
    [Implementation.MultiSig]: MultiSigDeleGatorDeployParams;
    [Implementation.Hybrid]: HybridDeleGatorDeployParams;
    [Implementation.Stateless7702]: never;
}[TImplementation];
type ToMetaMaskSmartAccountParameters<TImplementation extends Implementation> = {
    client: PublicClient;
    implementation: TImplementation;
    signatory: SignatoryConfigByImplementation<TImplementation>;
    environment?: DeleGatorEnvironment;
} & OneOf<{
    deployParams: DeployParams<TImplementation>;
    deploySalt: Hex;
} | {
    address: Address;
}>;
type SignUserOperationParams = Parameters<ToMetaMaskSmartAccountReturnType<Implementation>['signUserOperation']>[0];
type SignDelegationParams = {
    delegation: Omit<Delegation, 'signature'>;
} & {
    chainId?: number;
};
type MetaMaskSmartAccountImplementation<TImplementation extends Implementation> = SmartAccountImplementation<typeof entryPoint07Abi, '0.7', {
    abi: {
        [Implementation.Hybrid]: typeof HybridDeleGator.abi;
        [Implementation.MultiSig]: typeof MultiSigDeleGator.abi;
        [Implementation.Stateless7702]: typeof EIP7702StatelessDeleGator.abi;
    }[TImplementation];
    signDelegation: (params: SignDelegationParams) => Promise<Hex>;
    environment: DeleGatorEnvironment;
}>;
type MetaMaskSmartAccount<TImplementation extends Implementation = Implementation> = ToMetaMaskSmartAccountReturnType<TImplementation>;
type ToMetaMaskSmartAccountReturnType<TImplementation extends Implementation> = Prettify<SmartAccount<MetaMaskSmartAccountImplementation<TImplementation>>>;
type WalletSignatoryConfig = {
    walletClient: WalletClient<Transport, Chain | undefined, Account>;
};
type AccountSignatoryConfig = {
    account: Pick<Account, 'signMessage' | 'signTypedData' | 'address'>;
};
type WebAuthnSignatoryConfig = {
    webAuthnAccount: WebAuthnAccount;
    keyId: Hex;
};
type HybridSignatoryConfig = WalletSignatoryConfig | AccountSignatoryConfig | WebAuthnSignatoryConfig;
type MultiSigSignatoryConfig = (WalletSignatoryConfig | AccountSignatoryConfig)[];
type Stateless7702SignatoryConfig = WalletSignatoryConfig | AccountSignatoryConfig;
type SignatoryConfigByImplementation<TImplementation extends Implementation> = {
    [Implementation.Hybrid]: HybridSignatoryConfig;
    [Implementation.MultiSig]: MultiSigSignatoryConfig;
    [Implementation.Stateless7702]: Stateless7702SignatoryConfig;
}[TImplementation];
type Call = {
    to: Hex;
    data?: Hex | undefined;
    value?: bigint | undefined;
};

export { type AccountSignatoryConfig as A, type Caveat as C, type DeleGatorEnvironment as D, ExecutionMode as E, type HybridDeleGatorDeployParams as H, Implementation as I, type MultiSigDeleGatorDeployParams as M, type Redemption as R, type SignUserOperationParams as S, type ToMetaMaskSmartAccountParameters as T, type WalletSignatoryConfig as W, type ToMetaMaskSmartAccountReturnType as a, type SignDelegationParams as b, type MetaMaskSmartAccountImplementation as c, type MetaMaskSmartAccount as d, type WebAuthnSignatoryConfig as e, type HybridSignatoryConfig as f, type MultiSigSignatoryConfig as g, type Delegation as h, createExecution as i, type ExecutionStruct as j, type CreateExecutionArgs as k, type Call as l, type DeployParams as m, encodeExecutionCalldata as n, encodeExecutionCalldatas as o, encodeSingleExecution as p, encodeBatchExecution as q };