import { ANY_BENEFICIARY, ROOT_AUTHORITY } from '@metamask/delegation-core'; import * as viem from 'viem'; import { Client, Transport, Chain, Account, Abi, Address, Hex } from 'viem'; import { l as DelegationStruct } from './delegation-NENcKigs.cjs'; import { h as Delegation, E as ExecutionMode, j as ExecutionStruct, R as Redemption } from './types-DXRahfjU.cjs'; declare const NAME$1 = "DelegationManager"; declare const VERSION$1 = "1.3.0"; declare const DOMAIN_VERSION$1 = "1"; declare const constants$2_ANY_BENEFICIARY: typeof ANY_BENEFICIARY; declare const constants$2_ROOT_AUTHORITY: typeof ROOT_AUTHORITY; declare namespace constants$2 { export { constants$2_ANY_BENEFICIARY as ANY_BENEFICIARY, DOMAIN_VERSION$1 as DOMAIN_VERSION, NAME$1 as NAME, constants$2_ROOT_AUTHORITY as ROOT_AUTHORITY, VERSION$1 as VERSION }; } type P256Owner = { keyId: string; x: bigint; y: bigint; }; type InitializedClient = Client; type NarrowAbiToFunction = [ Extract[] ]; declare function isContractDeployed({ client, contractAddress, }: { client: Client; contractAddress: Address; }): Promise; declare function isImplementationExpected({ client, contractAddress, expectedImplementationAddress, }: { client: Client; contractAddress: Address; expectedImplementationAddress: Address; }): Promise; declare const encodeProxyCreationCode: ({ implementationAddress, initcode, }: { implementationAddress: Address; initcode: Hex; }) => Hex; type EncodeDisableDelegationParameters$1 = { delegation: Delegation; }; type SimulateDisableDelegationParameters$1 = { client: Client; delegationManagerAddress: Address; } & EncodeDisableDelegationParameters$1; type ExecuteDisableDelegationParameters$1 = { client: InitializedClient; delegationManagerAddress: Address; } & EncodeDisableDelegationParameters$1; declare const simulate$y: ({ client, delegationManagerAddress, delegation, }: SimulateDisableDelegationParameters$1) => Promise, "disableDelegation", [DelegationStruct], viem.Chain | undefined, viem.Account | undefined, undefined, undefined, readonly [never], viem.Account | undefined>>; declare const execute$k: ({ client, delegationManagerAddress, delegation, }: ExecuteDisableDelegationParameters$1) => Promise<`0x${string}`>; declare const encode$z: ({ delegation }: EncodeDisableDelegationParameters$1) => `0x${string}`; type EncodeEnableDelegationParameters$1 = { delegation: Delegation; }; type SimulateEnableDelegationParameters$1 = { client: Client; delegationManagerAddress: Address; } & EncodeEnableDelegationParameters$1; type ExecuteEnableDelegationParameters$1 = { client: InitializedClient; delegationManagerAddress: Address; } & EncodeEnableDelegationParameters$1; declare const simulate$x: ({ client, delegationManagerAddress, delegation, }: SimulateEnableDelegationParameters$1) => Promise, "enableDelegation", [DelegationStruct], viem.Chain | undefined, viem.Account | undefined, undefined, undefined, readonly [never], viem.Account | undefined>>; declare const execute$j: ({ client, delegationManagerAddress, delegation, }: ExecuteEnableDelegationParameters$1) => Promise<`0x${string}`>; declare const encode$y: ({ delegation }: EncodeEnableDelegationParameters$1) => `0x${string}`; type EncodeRedeemDelegationsParameters = { delegations: Delegation[][]; modes: ExecutionMode[]; executions: ExecutionStruct[][]; }; type SimulateRedeemDelegationsParameters = { client: Client; delegationManagerAddress: Address; } & EncodeRedeemDelegationsParameters; type ExecuteRedeemDelegationsParameters = { client: InitializedClient; delegationManagerAddress: Address; } & EncodeRedeemDelegationsParameters; declare const simulate$w: ({ client, delegationManagerAddress, delegations, modes, executions, }: SimulateRedeemDelegationsParameters) => Promise, "redeemDelegations", [`0x${string}`[], ExecutionMode[], `0x${string}`[]], viem.Chain | undefined, viem.Account | undefined, undefined, undefined, readonly [never], viem.Account | undefined>>; declare const execute$i: ({ client, delegationManagerAddress, delegations, modes, executions, }: ExecuteRedeemDelegationsParameters) => Promise<`0x${string}`>; declare const encode$x: ({ delegations, modes, executions, }: EncodeRedeemDelegationsParameters) => `0x${string}`; declare namespace encode$w { export { encode$z as disableDelegation, encode$y as enableDelegation, encode$x as redeemDelegations }; } declare namespace execute$h { export { execute$k as disableDelegation, execute$j as enableDelegation, execute$i as redeemDelegations }; } type ReadDisabledDelegationsParameters = { client: Client; contractAddress: Address; delegationHash: Hex; }; declare const read$_: ({ client, contractAddress, delegationHash, }: ReadDisabledDelegationsParameters) => Promise; type ReadGetAnyDelegateParameters = { client: Client; contractAddress: Address; }; declare const read$Z: ({ client, contractAddress, }: ReadGetAnyDelegateParameters) => Promise<`0x${string}`>; type ReadGetRootAuthorityParameters = { client: Client; contractAddress: Address; }; declare const read$Y: ({ client, contractAddress, }: ReadGetRootAuthorityParameters) => Promise<`0x${string}`>; declare namespace read$X { export { read$_ as disabledDelegations, read$Z as getAnyDelegate, read$Y as getRootAuthority }; } declare namespace simulate$v { export { simulate$y as disableDelegation, simulate$x as enableDelegation, simulate$w as redeemDelegations }; } declare namespace index$k { export { constants$2 as constants, encode$w as encode, execute$h as execute, read$X as read, simulate$v as simulate }; } type SimulateDisableDelegationParameters = { client: Client; delegationManagerAddress: Address; delegation: Delegation; }; type EncodeDisableDelegationParameters = { delegation: Delegation; }; type ExecuteDisableDelegationParameters = { client: InitializedClient; delegationManagerAddress: Address; delegation: Delegation; }; declare const simulate$u: ({ client, delegationManagerAddress, delegation, }: SimulateDisableDelegationParameters) => Promise, "disableDelegation", [DelegationStruct], viem.Chain | undefined, viem.Account | undefined, undefined, undefined, readonly [never], viem.Account | undefined>>; declare const execute$g: ({ client, delegationManagerAddress, delegation, }: ExecuteDisableDelegationParameters) => Promise<`0x${string}`>; declare const encode$v: ({ delegation }: EncodeDisableDelegationParameters) => `0x${string}`; type SimulateEnableDelegationParameters = { client: Client; delegationManagerAddress: Address; delegation: Delegation; }; type EncodeEnableDelegationParameters = { delegation: Delegation; }; type ExecuteEnableDelegationParameters = { client: InitializedClient; delegationManagerAddress: Address; delegation: Delegation; }; declare const simulate$t: ({ client, delegationManagerAddress, delegation, }: SimulateEnableDelegationParameters) => Promise, "enableDelegation", [DelegationStruct], viem.Chain | undefined, viem.Account | undefined, undefined, undefined, readonly [never], viem.Account | undefined>>; declare const execute$f: ({ client, delegationManagerAddress, delegation, }: ExecuteEnableDelegationParameters) => Promise<`0x${string}`>; declare const encode$u: ({ delegation }: EncodeEnableDelegationParameters) => `0x${string}`; type SimulateExecuteParameters = { client: Client; contractAddress: Address; execution: ExecutionStruct; }; type EncodeExecuteParameters = { execution: ExecutionStruct; }; type ExecuteExecuteParameters = { client: InitializedClient; contractAddress: Address; execution: ExecutionStruct; }; declare const simulate$s: ({ client, contractAddress, execution, }: SimulateExecuteParameters) => Promise>; declare const execute$e: ({ client, contractAddress, execution, }: ExecuteExecuteParameters) => Promise<`0x${string}`>; declare const encode$t: ({ execution }: EncodeExecuteParameters) => `0x${string}`; type SimulateExecuteWithModeParameters = { client: Client; contractAddress: Address; } & EncodeExecuteWithModeParameters; type EncodeExecuteWithModeParameters = { mode: ExecutionMode; executions: ExecutionStruct[]; }; type ExecuteExecuteWithModeParameters = { client: InitializedClient; contractAddress: Address; } & EncodeExecuteWithModeParameters; declare const simulate$r: ({ client, contractAddress, mode, executions, }: SimulateExecuteWithModeParameters) => Promise>; declare const execute$d: ({ client, contractAddress, mode, executions, }: ExecuteExecuteWithModeParameters) => Promise<`0x${string}`>; declare const encode$s: ({ mode, executions, }: EncodeExecuteWithModeParameters) => `0x${string}`; type IsValidSignatureParameters = { client: Client; contractAddress: Address; hash: Hex; signature: Hex; }; type EncodeIsValidSignatureParameters = { hash: Hex; signature: Hex; }; declare const read$W: ({ client, contractAddress, hash, signature, }: IsValidSignatureParameters) => Promise<`0x${string}`>; declare const encode$r: ({ hash, signature, }: EncodeIsValidSignatureParameters) => `0x${string}`; type SimulateUpgradeToAndCallParameters = { client: Client; contractAddress: Address; } & EncodeUpgradeToAndCallParameters; type EncodeUpgradeToAndCallParameters = { implementation: Address; data: Hex; }; type ExecuteUpgradeToAndCallParameters = { client: InitializedClient; contractAddress: Address; } & EncodeUpgradeToAndCallParameters; declare const simulate$q: ({ client, contractAddress, implementation, data, }: SimulateUpgradeToAndCallParameters) => Promise>; declare const execute$c: ({ client, contractAddress, implementation, data, }: ExecuteUpgradeToAndCallParameters) => Promise<`0x${string}`>; declare const encode$q: ({ implementation, data, }: EncodeUpgradeToAndCallParameters) => `0x${string}`; declare namespace encode$p { export { encode$v as disableDelegation, encode$u as enableDelegation, encode$t as execute, encode$s as executeWithMode, encode$r as isValidSignature, encode$q as upgradeToAndCall }; } declare namespace execute$b { export { execute$g as disableDelegation, execute$f as enableDelegation, execute$e as execute, execute$d as executeWithMode, execute$c as upgradeToAndCall }; } type ReadGetDelegationManagerParameters = { client: Client; contractAddress: Address; }; declare const read$V: ({ client, contractAddress, }: ReadGetDelegationManagerParameters) => Promise<`0x${string}`>; type ReadGetDepositParameters = { client: Client; contractAddress: Address; }; declare const read$U: ({ client, contractAddress, }: ReadGetDepositParameters) => Promise; type ReadGetEntryPointParameters = { client: Client; contractAddress: Address; }; declare const read$T: ({ client, contractAddress, }: ReadGetEntryPointParameters) => Promise<`0x${string}`>; type ReadGetNonceParameters$1 = { client: Client; contractAddress: Address; key?: bigint; }; declare const read$S: ({ client, contractAddress, key, }: ReadGetNonceParameters$1) => Promise; type ReadGetProxyImplementationParameters = { client: Client; contractAddress: Address; }; declare const read$R: ({ client, contractAddress, }: ReadGetProxyImplementationParameters) => Promise<`0x${string}`>; type ReadGetProxyVersionParameters = { client: Client; contractAddress: Address; }; declare const read$Q: ({ client, contractAddress, }: ReadGetProxyVersionParameters) => Promise; declare namespace read$P { export { read$V as getDelegationManager, read$U as getDeposit, read$T as getEntryPoint, read$S as getNonce, read$R as getProxyImplementation, read$Q as getProxyVersion, read$W as isValidSignature }; } declare namespace simulate$p { export { simulate$u as disableDelegation, simulate$t as enableDelegation, simulate$s as execute, simulate$r as executeWithMode, simulate$q as upgradeToAndCall }; } declare namespace index$j { export { encode$p as encode, execute$b as execute, read$P as read, simulate$p as simulate }; } type ReadGetContractNameParameters = { client: Client; contractAddress: Address; }; declare const read$O: ({ client, contractAddress, }: ReadGetContractNameParameters) => Promise; type ReadGetContractVersionParameters = { client: Client; contractAddress: Address; }; declare const read$N: ({ client, contractAddress, }: ReadGetContractVersionParameters) => Promise; type ReadGetDomainVersionParameters = { client: Client; contractAddress: Address; }; declare const read$M: ({ client, contractAddress, }: ReadGetDomainVersionParameters) => Promise; declare namespace read$L { export { read$O as getContractName, read$N as getContractVersion, read$M as getDomainVersion }; } declare namespace index$i { export { read$L as read }; } type ReadGetNonceParameters = { client: Client; entryPoint: Address; contractAddress: Address; key: bigint; }; declare const read$K: ({ client, entryPoint, contractAddress, key, }: ReadGetNonceParameters) => Promise; declare namespace read$J { export { read$K as entryPointGetNonce }; } declare namespace index$h { export { read$J as read }; } type ReadGetAvailableAmountParameters$4 = { client: Client; contractAddress: Address; delegationHash: Hex; delegationManager: Address; terms: Hex; }; declare const read$I: ({ client, contractAddress, delegationHash, delegationManager, terms, }: ReadGetAvailableAmountParameters$4) => Promise<{ availableAmount: bigint; isNewPeriod: boolean; currentPeriod: bigint; }>; declare namespace read$H { export { read$I as getAvailableAmount }; } declare namespace index$g { export { read$H as read }; } type ReadGetAvailableAmountParameters$3 = { client: Client; contractAddress: Address; delegationManager: Address; delegationHash: Hex; terms: Hex; }; declare const read$G: ({ client, contractAddress, delegationManager, delegationHash, terms, }: ReadGetAvailableAmountParameters$3) => Promise<{ availableAmount: bigint; }>; declare namespace read$F { export { read$G as getAvailableAmount }; } declare namespace index$f { export { read$F as read }; } type ReadGetSpentAmountParameters$1 = { client: Client; contractAddress: Address; delegationManager: Address; delegationHash: Hex; }; declare const read$E: ({ client, contractAddress, delegationManager, delegationHash, }: ReadGetSpentAmountParameters$1) => Promise; type ReadGetTermsInfoParameters$5 = { client: Client; contractAddress: Address; terms: Hex; }; type TermsData$1 = { allowedContract: Address; maxTokens: bigint; }; declare const read$D: ({ client, contractAddress, terms, }: ReadGetTermsInfoParameters$5) => Promise; declare namespace read$C { export { read$E as getSpentAmount, read$D as getTermsInfo }; } declare namespace index$e { export { read$C as read }; } type ReadGetKeyParameters = { client: Client; hybridDeleGatorAddress: Address; keyId: string; }; declare const read$B: ({ client, hybridDeleGatorAddress, keyId, }: ReadGetKeyParameters) => Promise; type ReadGetKeyIdHashesParameters = { client: Client; hybridDeleGatorAddress: Address; }; declare const read$A: ({ client, hybridDeleGatorAddress, }: ReadGetKeyIdHashesParameters) => Promise; type ReadGetKeyIdHashesCountParameters = { client: Client; hybridDeleGatorAddress: Address; }; declare const read$z: ({ client, hybridDeleGatorAddress, }: ReadGetKeyIdHashesCountParameters) => Promise; declare namespace read$y { export { read$B as getKey, read$A as getKeyIdHashes, read$z as getKeyIdHashesCount }; } type EncodeAddKeyParameters = { p256Owner: P256Owner; }; type SimulateAddKeyParameters = { client: Client; hybridDeleGatorAddress: Address; } & EncodeAddKeyParameters; declare const simulate$o: ({ client, hybridDeleGatorAddress, p256Owner, }: SimulateAddKeyParameters) => Promise>; declare const encode$o: ({ p256Owner }: EncodeAddKeyParameters) => `0x${string}`; type EncodeInitializeParameters$1 = { eoaOwner: Address; p256Owners: P256Owner[]; }; type SimulateInitializeParameters$1 = { client: Client; hybridDeleGatorAddress: Address; } & EncodeInitializeParameters$1; declare const simulate$n: ({ client, hybridDeleGatorAddress, eoaOwner, p256Owners, }: SimulateInitializeParameters$1) => Promise>; declare const encode$n: ({ eoaOwner, p256Owners, }: EncodeInitializeParameters$1) => `0x${string}`; type EncodeReinitializeParameters$1 = { version: number; eoaOwner: Address; p256Owners: P256Owner[]; removeExistingP256Owners: boolean; }; type SimulateReinitializeParameters$1 = { client: Client; hybridDeleGatorAddress: Address; } & EncodeReinitializeParameters$1; declare const simulate$m: ({ client, hybridDeleGatorAddress, version, eoaOwner, p256Owners, removeExistingP256Owners, }: SimulateReinitializeParameters$1) => Promise>; declare const encode$m: ({ version, eoaOwner, p256Owners, removeExistingP256Owners, }: EncodeReinitializeParameters$1) => `0x${string}`; type EncodeRemoveKeyParameters = { keyId: string; }; type SimulateRemoveKeyParameters = { client: Client; hybridDeleGatorAddress: Address; } & EncodeRemoveKeyParameters; declare const simulate$l: ({ client, hybridDeleGatorAddress, keyId, }: SimulateRemoveKeyParameters) => Promise>; declare const encode$l: ({ keyId }: EncodeRemoveKeyParameters) => `0x${string}`; type EncodeUpdateSignersParameters = { eoaOwner: Address; p256Owners: P256Owner[]; }; type SimulateUpdateSignersParameters = { client: Client; hybridDeleGatorAddress: Address; } & EncodeUpdateSignersParameters; declare const simulate$k: ({ client, hybridDeleGatorAddress, eoaOwner, p256Owners, }: SimulateUpdateSignersParameters) => Promise>; declare const encode$k: ({ eoaOwner, p256Owners, }: EncodeUpdateSignersParameters) => `0x${string}`; declare namespace encode$j { export { encode$o as addKey, encode$n as initializeHybridDeleGator, encode$m as reinitializeHybridDeleGator, encode$l as removeKey, encode$k as updateSigners }; } declare namespace simulate$j { export { simulate$o as addKey, simulate$n as initializeHybridDeleGator, simulate$m as reinitializeHybridDeleGator, simulate$l as removeKey, simulate$k as updateSigners }; } declare const NAME = "HybridDeleGator"; declare const VERSION = "1.3.0"; declare const DOMAIN_VERSION = "1"; declare const constants$1_ANY_BENEFICIARY: typeof ANY_BENEFICIARY; declare const constants$1_DOMAIN_VERSION: typeof DOMAIN_VERSION; declare const constants$1_NAME: typeof NAME; declare const constants$1_ROOT_AUTHORITY: typeof ROOT_AUTHORITY; declare const constants$1_VERSION: typeof VERSION; declare namespace constants$1 { export { constants$1_ANY_BENEFICIARY as ANY_BENEFICIARY, constants$1_DOMAIN_VERSION as DOMAIN_VERSION, constants$1_NAME as NAME, constants$1_ROOT_AUTHORITY as ROOT_AUTHORITY, constants$1_VERSION as VERSION }; } declare namespace index$d { export { constants$1 as constants, encode$j as encode, read$y as read, simulate$j as simulate }; } type ReadGetIsUsedParameters = { client: Client; contractAddress: Address; delegationManager: Address; delegator: Address; id: bigint; }; declare const read$x: ({ client, contractAddress, delegationManager, delegator, id, }: ReadGetIsUsedParameters) => Promise; type ReadGetTermsInfoParameters$4 = { client: Client; contractAddress: Address; terms: Hex; }; declare const read$w: ({ client, contractAddress, terms, }: ReadGetTermsInfoParameters$4) => Promise; declare namespace read$v { export { read$x as getIsUsed, read$w as getTermsInfo }; } declare namespace index$c { export { read$v as read }; } type ReadCallCountsParameters = { client: Client; contractAddress: Address; delegationManager: Address; delegationHash: Hex; }; declare const read$u: ({ client, contractAddress, delegationManager, delegationHash, }: ReadCallCountsParameters) => Promise; type ReadGetTermsInfoParameters$3 = { client: Client; contractAddress: Address; terms: Hex; }; declare const read$t: ({ client, contractAddress, terms, }: ReadGetTermsInfoParameters$3) => Promise; declare namespace read$s { export { read$u as callCounts, read$t as getTermsInfo }; } declare namespace index$b { export { read$s as read }; } type ReadGetMaxNumberOfSignersParameters = { client: Client; multiSigDeleGatorAddress: Address; }; declare const read$r: ({ client, multiSigDeleGatorAddress, }: ReadGetMaxNumberOfSignersParameters) => Promise; type ReadGetSignersParameters = { client: Client; multiSigDeleGatorAddress: Address; }; declare const read$q: ({ client, multiSigDeleGatorAddress, }: ReadGetSignersParameters) => Promise; type ReadGetSignersCountParameters = { client: Client; multiSigDeleGatorAddress: Address; }; declare const read$p: ({ client, multiSigDeleGatorAddress, }: ReadGetSignersCountParameters) => Promise; type ReadGetThresholdParameters = { client: Client; multiSigDeleGatorAddress: Address; }; declare const read$o: ({ client, multiSigDeleGatorAddress, }: ReadGetThresholdParameters) => Promise; type ReadIsSignerParameters = { client: Client; multiSigDeleGatorAddress: Address; signer: Address; }; declare const read$n: ({ client, multiSigDeleGatorAddress, signer, }: ReadIsSignerParameters) => Promise; declare namespace read$m { export { read$r as getMaxNumberOfSigners, read$q as getSigners, read$p as getSignersCount, read$o as getThreshold, read$n as isSigner }; } type EncodeAddSignerParameters = { signer: Address; }; type SimulateAddSignerParameters = { client: Client; multiSigDeleGatorAddress: Address; } & EncodeAddSignerParameters; declare const simulate$i: ({ client, multiSigDeleGatorAddress, signer, }: SimulateAddSignerParameters) => Promise>; declare const encode$i: ({ signer }: EncodeAddSignerParameters) => `0x${string}`; type EncodeInitializeParameters = { owners: Address[]; threshold: bigint; }; type SimulateInitializeParameters = { client: Client; multiSigDeleGatorAddress: Address; } & EncodeInitializeParameters; declare const simulate$h: ({ client, multiSigDeleGatorAddress, owners, threshold, }: SimulateInitializeParameters) => Promise>; declare const encode$h: ({ owners, threshold }: EncodeInitializeParameters) => `0x${string}`; type EncodeReinitializeParameters = { version: bigint; owners: Address[]; threshold: bigint; removeExistingOwners: boolean; }; type SimulateReinitializeParameters = { client: Client; multiSigDeleGatorAddress: Address; } & EncodeReinitializeParameters; declare const simulate$g: ({ client, multiSigDeleGatorAddress, version, owners, threshold, removeExistingOwners, }: SimulateReinitializeParameters) => Promise>; declare const encode$g: ({ version, owners, threshold, removeExistingOwners, }: EncodeReinitializeParameters) => `0x${string}`; type EncodeRemoveSignerParameters = { signer: Address; }; type SimulateRemoveSignerParameters = { client: Client; multiSigDeleGatorAddress: Address; } & EncodeRemoveSignerParameters; declare const simulate$f: ({ client, multiSigDeleGatorAddress, signer, }: SimulateRemoveSignerParameters) => Promise>; declare const encode$f: ({ signer }: EncodeRemoveSignerParameters) => `0x${string}`; type EncodeReplaceSignerParameters = { oldSigner: Address; newSigner: Address; }; type SimulateReplaceSignerParameters = { client: Client; multiSigDeleGatorAddress: Address; } & EncodeReplaceSignerParameters; declare const simulate$e: ({ client, multiSigDeleGatorAddress, oldSigner, newSigner, }: SimulateReplaceSignerParameters) => Promise>; declare const encode$e: ({ oldSigner, newSigner, }: EncodeReplaceSignerParameters) => `0x${string}`; type EncodeUpdateMultiSigParametersParameters = { owners: Address[]; threshold: bigint; removeExistingOwners: boolean; }; type SimulateUpdateMultiSigParametersParameters = { client: Client; multiSigDeleGatorAddress: Address; } & EncodeUpdateMultiSigParametersParameters; declare const simulate$d: ({ client, multiSigDeleGatorAddress, owners, threshold, removeExistingOwners, }: SimulateUpdateMultiSigParametersParameters) => Promise>; declare const encode$d: ({ owners, threshold, removeExistingOwners, }: EncodeUpdateMultiSigParametersParameters) => `0x${string}`; type EncodeUpdateThresholdParameters = { threshold: bigint; }; type SimulateUpdateThresholdParameters = { client: Client; multiSigDeleGatorAddress: Address; } & EncodeUpdateThresholdParameters; declare const simulate$c: ({ client, multiSigDeleGatorAddress, threshold, }: SimulateUpdateThresholdParameters) => Promise>; declare const encode$c: ({ threshold }: EncodeUpdateThresholdParameters) => `0x${string}`; declare namespace encode$b { export { encode$i as addSigner, encode$h as initializeMultiSigDeleGator, encode$g as reinitializeMultiSigDeleGator, encode$f as removeSigner, encode$e as replaceSigner, encode$d as updateMultiSigParameters, encode$c as updateThreshold }; } declare namespace simulate$b { export { simulate$i as addSigner, simulate$h as initializeMultiSigDeleGator, simulate$g as reinitializeMultiSigDeleGator, simulate$f as removeSigner, simulate$e as replaceSigner, simulate$d as updateMultiSigParameters, simulate$c as updateThreshold }; } declare const MAX_NUMBER_OF_SIGNERS = 30; declare const constants_MAX_NUMBER_OF_SIGNERS: typeof MAX_NUMBER_OF_SIGNERS; declare namespace constants { export { constants_MAX_NUMBER_OF_SIGNERS as MAX_NUMBER_OF_SIGNERS }; } declare const index$a_constants: typeof constants; declare namespace index$a { export { index$a_constants as constants, encode$b as encode, read$m as read, simulate$b as simulate }; } type ReadGetAvailableAmountParameters$2 = { client: Client; contractAddress: Address; delegationHash: Hex; delegationManager: Address; terms: Hex; args: Hex; }; declare const read$l: ({ client, contractAddress, delegationHash, delegationManager, terms, args, }: ReadGetAvailableAmountParameters$2) => Promise<{ availableAmount: bigint; isNewPeriod: boolean; currentPeriod: bigint; }>; declare namespace read$k { export { read$l as getAvailableAmount }; } declare namespace index$9 { export { read$k as read }; } type ReadGetAvailableAmountParameters$1 = { client: Client; contractAddress: Address; delegationHash: Hex; delegationManager: Address; terms: Hex; }; declare const read$j: ({ client, contractAddress, delegationHash, delegationManager, terms, }: ReadGetAvailableAmountParameters$1) => Promise<{ availableAmount: bigint; isNewPeriod: boolean; currentPeriod: bigint; }>; declare namespace read$i { export { read$j as getAvailableAmount }; } declare namespace index$8 { export { read$i as read }; } type ReadGetAvailableAmountParameters = { client: Client; contractAddress: Address; delegationManager: Address; delegationHash: Hex; terms: Hex; }; declare const read$h: ({ client, contractAddress, delegationManager, delegationHash, terms, }: ReadGetAvailableAmountParameters) => Promise<{ availableAmount: bigint; }>; declare namespace read$g { export { read$h as getAvailableAmount }; } declare namespace index$7 { export { read$g as read }; } type ReadGetSpentAmountParameters = { client: Client; contractAddress: Address; delegationManager: Address; delegationHash: Hex; }; declare const read$f: ({ client, contractAddress, delegationManager, delegationHash, }: ReadGetSpentAmountParameters) => Promise; type ReadGetTermsInfoParameters$2 = { client: Client; contractAddress: Address; terms: Hex; }; declare const read$e: ({ client, contractAddress, terms, }: ReadGetTermsInfoParameters$2) => Promise; declare namespace read$d { export { read$f as getSpentAmount, read$e as getTermsInfo }; } declare namespace index$6 { export { read$d as read }; } type SimulateIncrementNonceParameters = { client: Client; contractAddress: Address; delegationManager: Address; }; declare const encode$a: (delegationManager: Address) => `0x${string}`; declare const simulate$a: ({ client, contractAddress, delegationManager, }: SimulateIncrementNonceParameters) => Promise>; declare const execute$a: ({ client, contractAddress, delegationManager, }: SimulateIncrementNonceParameters) => Promise<`0x${string}`>; declare namespace encode$9 { export { encode$a as incrementNonce }; } declare namespace execute$9 { export { execute$a as incrementNonce }; } type ReadCurrentNonceParameters = { client: Client; contractAddress: Address; delegationManager: Address; delegator: Address; }; declare const read$c: ({ client, contractAddress, delegationManager, delegator, }: ReadCurrentNonceParameters) => Promise; type ReadGetTermsInfoParameters$1 = { client: Client; contractAddress: Address; terms: Hex; }; declare const read$b: ({ client, contractAddress, terms, }: ReadGetTermsInfoParameters$1) => Promise; declare namespace read$a { export { read$c as currentNonce, read$b as getTermsInfo }; } declare namespace simulate$9 { export { simulate$a as incrementNonce }; } declare namespace index$5 { export { encode$9 as encode, execute$9 as execute, read$a as read, simulate$9 as simulate }; } type ReadGetOwnerParameters = { client: Client; contractAddress: Address; }; declare const read$9: ({ client, contractAddress, }: ReadGetOwnerParameters) => Promise<`0x${string}`>; type ReadGetPendingOwnerParameters = { client: Client; contractAddress: Address; }; declare const read$8: ({ client, contractAddress, }: ReadGetPendingOwnerParameters) => Promise<`0x${string}`>; declare namespace read$7 { export { read$9 as getOwner, read$8 as getPendingOwner }; } type SimulateAcceptOwnershipParameters = { client: Client; contractAddress: Address; }; type ExecuteAcceptOwnershipParameters = { client: InitializedClient; contractAddress: Address; }; declare const simulate$8: ({ client, contractAddress, }: SimulateAcceptOwnershipParameters) => Promise>; declare const execute$8: ({ client, contractAddress, }: ExecuteAcceptOwnershipParameters) => Promise<`0x${string}`>; declare const encode$8: () => `0x${string}`; type SimulateRenounceOwnershipParameters = { client: Client; contractAddress: Address; }; type ExecuteRenounceOwnershipParameters = { client: InitializedClient; contractAddress: Address; }; declare const simulate$7: ({ client, contractAddress, }: SimulateRenounceOwnershipParameters) => Promise>; declare const execute$7: ({ client, contractAddress, }: ExecuteRenounceOwnershipParameters) => Promise<`0x${string}`>; declare const encode$7: () => `0x${string}`; type SimulateTransferOwnershipParameters = { client: Client; contractAddress: Address; account: Address; }; type ExecuteTransferOwnershipParameters = { client: InitializedClient; contractAddress: Address; account: Address; }; declare const simulate$6: ({ client, contractAddress, account, }: SimulateTransferOwnershipParameters) => Promise>; declare const execute$6: ({ client, contractAddress, account, }: ExecuteTransferOwnershipParameters) => Promise<`0x${string}`>; declare const encode$6: (account: Address) => `0x${string}`; declare namespace execute$5 { export { execute$8 as acceptOwnership, execute$7 as renounceOwnership, execute$6 as transferOwnership }; } declare namespace encode$5 { export { encode$8 as acceptOwnership, encode$7 as renounceOwnership, encode$6 as transferOwnership }; } declare namespace simulate$5 { export { simulate$8 as acceptOwnership, simulate$7 as renounceOwnership, simulate$6 as transferOwnership }; } declare namespace index$4 { export { encode$5 as encode, execute$5 as execute, read$7 as read, simulate$5 as simulate }; } type ReadIsPausedParameters = { client: Client; contractAddress: Address; }; declare const read$6: ({ client, contractAddress, }: ReadIsPausedParameters) => Promise; declare namespace read$5 { export { read$6 as isPaused }; } type SimulatePauseParameters = { client: Client; contractAddress: Address; }; type ExecutePauseParameters = { client: InitializedClient; contractAddress: Address; }; declare const simulate$4: ({ client, contractAddress, }: SimulatePauseParameters) => Promise>; declare const execute$4: ({ client, contractAddress, }: ExecutePauseParameters) => Promise<`0x${string}`>; declare const encode$4: () => `0x${string}`; type SimulateUnpauseParameters = { client: Client; contractAddress: Address; }; type ExecuteUnpauseParameters = { client: InitializedClient; contractAddress: Address; }; declare const simulate$3: ({ client, contractAddress, }: SimulateUnpauseParameters) => Promise>; declare const execute$3: ({ client, contractAddress, }: ExecuteUnpauseParameters) => Promise<`0x${string}`>; declare const encode$3: () => `0x${string}`; declare namespace execute$2 { export { execute$4 as pause, execute$3 as unpause }; } declare namespace encode$2 { export { encode$4 as pause, encode$3 as unpause }; } declare namespace simulate$2 { export { simulate$4 as pause, simulate$3 as unpause }; } declare namespace index$3 { export { encode$2 as encode, execute$2 as execute, read$5 as read, simulate$2 as simulate }; } type SimulateCreate2DeployParameters = { client: Client; factoryAddress: Address; creationCode: Hex; salt: Hex; }; type ExecuteCreate2DeployParameters = { client: InitializedClient; factoryAddress: Address; creationCode: Hex; salt: Hex; }; declare const simulate$1: ({ client, factoryAddress, creationCode, salt, }: SimulateCreate2DeployParameters) => Promise>; declare const encode$1: (creationCode: Hex, salt: Hex) => `0x${string}`; declare const execute$1: ({ client, factoryAddress, creationCode, salt, }: ExecuteCreate2DeployParameters) => Promise<`0x${string}`>; declare namespace encode { export { encode$1 as create2Deploy }; } declare namespace execute { export { execute$1 as create2Deploy }; } declare const read$4: (client: Client, factoryAddress: Address, creationCode: Hex, salt: Hex) => Promise<`0x${string}`>; declare namespace read$3 { export { read$4 as getCreate2Address }; } declare namespace simulate { export { simulate$1 as create2Deploy }; } declare const index$2_encode: typeof encode; declare const index$2_execute: typeof execute; declare const index$2_simulate: typeof simulate; declare namespace index$2 { export { index$2_encode as encode, index$2_execute as execute, read$3 as read, index$2_simulate as simulate }; } type ReadGetTermsInfoParameters = { client: Client; contractAddress: Address; terms: Hex; }; type TermsData = { tokenAddress: Address; recipient: Address; amount: bigint; firstTarget: Address; firstCalldata: Hex; }; declare const read$2: ({ client, contractAddress, terms, }: ReadGetTermsInfoParameters) => Promise; type ReadUsedDelegationsParameters = { client: Client; contractAddress: Address; delegationManager: Address; delegationHash: Hex; }; declare const read$1: ({ client, contractAddress, delegationManager, delegationHash, }: ReadUsedDelegationsParameters) => Promise; declare namespace read { export { read$2 as getTermsInfo, read$1 as usedDelegations }; } declare const index$1_read: typeof read; declare namespace index$1 { export { index$1_read as read }; } type index_InitializedClient = InitializedClient; type index_NarrowAbiToFunction = NarrowAbiToFunction; type index_P256Owner = P256Owner; declare const index_Redemption: typeof Redemption; declare const index_encodeProxyCreationCode: typeof encodeProxyCreationCode; declare const index_isContractDeployed: typeof isContractDeployed; declare const index_isImplementationExpected: typeof isImplementationExpected; declare namespace index { export { index$j as DeleGatorCore, index$k as DelegationManager, index$i as EIP712, index$g as ERC20PeriodTransferEnforcer, index$f as ERC20StreamingEnforcer, index$e as ERC20TransferAmountEnforcer, index$h as EntryPoint, index$d as HybridDeleGator, index$c as IdEnforcer, type index_InitializedClient as InitializedClient, index$b as LimitedCallsEnforcer, index$a as MultiSigDeleGator, index$9 as MultiTokenPeriodEnforcer, type index_NarrowAbiToFunction as NarrowAbiToFunction, index$8 as NativeTokenPeriodTransferEnforcer, index$7 as NativeTokenStreamingEnforcer, index$6 as NativeTokenTransferAmountEnforcer, index$5 as NonceEnforcer, index$4 as Ownable2Step, type index_P256Owner as P256Owner, index$3 as Pausable, index_Redemption as Redemption, index$2 as SimpleFactory, index$1 as SpecificActionERC20TransferBatchEnforcer, index_encodeProxyCreationCode as encodeProxyCreationCode, index_isContractDeployed as isContractDeployed, index_isImplementationExpected as isImplementationExpected }; } export { type InitializedClient as I, type NarrowAbiToFunction as N, type P256Owner as P, index$k as a, index$j as b, index$i as c, index$h as d, index$d as e, index$c as f, index$b as g, index$a as h, index as i, index$5 as j, index$4 as k, index$3 as l, index$2 as m, index$1 as n, index$g as o, index$f as p, index$e as q, index$9 as r, index$8 as s, index$7 as t, index$6 as u, isContractDeployed as v, isImplementationExpected as w, encodeProxyCreationCode as x };