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-BLdZ1xQ7.js'; import { h as Delegation, E as ExecutionMode, j as ExecutionStruct, R as Redemption } from './types-DvZXSma6.js'; 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$w: ({ client, delegationManagerAddress, delegation, }: SimulateDisableDelegationParameters$1) => Promise, "disableDelegation", [DelegationStruct], viem.Chain | undefined, viem.Account | undefined, undefined, undefined, readonly [never], viem.Account | undefined>>; declare const execute$i: ({ client, delegationManagerAddress, delegation, }: ExecuteDisableDelegationParameters$1) => Promise<`0x${string}`>; declare const encode$x: ({ 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$v: ({ client, delegationManagerAddress, delegation, }: SimulateEnableDelegationParameters$1) => Promise, "enableDelegation", [DelegationStruct], viem.Chain | undefined, viem.Account | undefined, undefined, undefined, readonly [never], viem.Account | undefined>>; declare const execute$h: ({ client, delegationManagerAddress, delegation, }: ExecuteEnableDelegationParameters$1) => Promise<`0x${string}`>; declare const encode$w: ({ 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$u: ({ 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$g: ({ client, delegationManagerAddress, delegations, modes, executions, }: ExecuteRedeemDelegationsParameters) => Promise<`0x${string}`>; declare const encode$v: ({ delegations, modes, executions, }: EncodeRedeemDelegationsParameters) => `0x${string}`; declare namespace encode$u { export { encode$x as disableDelegation, encode$w as enableDelegation, encode$v as redeemDelegations }; } declare namespace execute$f { export { execute$i as disableDelegation, execute$h as enableDelegation, execute$g as redeemDelegations }; } type ReadDisabledDelegationsParameters = { client: Client; contractAddress: Address; delegationHash: Hex; }; declare const read$I: ({ client, contractAddress, delegationHash, }: ReadDisabledDelegationsParameters) => Promise; type ReadGetAnyDelegateParameters = { client: Client; contractAddress: Address; }; declare const read$H: ({ client, contractAddress, }: ReadGetAnyDelegateParameters) => Promise<`0x${string}`>; type ReadGetRootAuthorityParameters = { client: Client; contractAddress: Address; }; declare const read$G: ({ client, contractAddress, }: ReadGetRootAuthorityParameters) => Promise<`0x${string}`>; declare namespace read$F { export { read$I as disabledDelegations, read$H as getAnyDelegate, read$G as getRootAuthority }; } declare namespace simulate$t { export { simulate$w as disableDelegation, simulate$v as enableDelegation, simulate$u as redeemDelegations }; } declare namespace index$e { export { constants$2 as constants, encode$u as encode, execute$f as execute, read$F as read, simulate$t 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$s: ({ client, delegationManagerAddress, delegation, }: SimulateDisableDelegationParameters) => Promise, "disableDelegation", [DelegationStruct], viem.Chain | undefined, viem.Account | undefined, undefined, undefined, readonly [never], viem.Account | undefined>>; declare const execute$e: ({ client, delegationManagerAddress, delegation, }: ExecuteDisableDelegationParameters) => Promise<`0x${string}`>; declare const encode$t: ({ 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$r: ({ client, delegationManagerAddress, delegation, }: SimulateEnableDelegationParameters) => Promise, "enableDelegation", [DelegationStruct], viem.Chain | undefined, viem.Account | undefined, undefined, undefined, readonly [never], viem.Account | undefined>>; declare const execute$d: ({ client, delegationManagerAddress, delegation, }: ExecuteEnableDelegationParameters) => Promise<`0x${string}`>; declare const encode$s: ({ 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$q: ({ client, contractAddress, execution, }: SimulateExecuteParameters) => Promise>; declare const execute$c: ({ client, contractAddress, execution, }: ExecuteExecuteParameters) => Promise<`0x${string}`>; declare const encode$r: ({ 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$p: ({ client, contractAddress, mode, executions, }: SimulateExecuteWithModeParameters) => Promise>; declare const execute$b: ({ client, contractAddress, mode, executions, }: ExecuteExecuteWithModeParameters) => Promise<`0x${string}`>; declare const encode$q: ({ mode, executions, }: EncodeExecuteWithModeParameters) => `0x${string}`; type IsValidSignatureParameters = { client: Client; contractAddress: Address; hash: Hex; signature: Hex; }; type EncodeIsValidSignatureParameters = { hash: Hex; signature: Hex; }; declare const read$E: ({ client, contractAddress, hash, signature, }: IsValidSignatureParameters) => Promise<`0x${string}`>; declare const encode$p: ({ 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$o: ({ client, contractAddress, implementation, data, }: SimulateUpgradeToAndCallParameters) => Promise>; declare const execute$a: ({ client, contractAddress, implementation, data, }: ExecuteUpgradeToAndCallParameters) => Promise<`0x${string}`>; declare const encode$o: ({ implementation, data, }: EncodeUpgradeToAndCallParameters) => `0x${string}`; declare namespace encode$n { export { encode$t as disableDelegation, encode$s as enableDelegation, encode$r as execute, encode$q as executeWithMode, encode$p as isValidSignature, encode$o as upgradeToAndCall }; } declare namespace execute$9 { export { execute$e as disableDelegation, execute$d as enableDelegation, execute$c as execute, execute$b as executeWithMode, execute$a as upgradeToAndCall }; } type ReadGetDelegationManagerParameters = { client: Client; contractAddress: Address; }; declare const read$D: ({ client, contractAddress, }: ReadGetDelegationManagerParameters) => Promise<`0x${string}`>; type ReadGetDepositParameters = { client: Client; contractAddress: Address; }; declare const read$C: ({ client, contractAddress, }: ReadGetDepositParameters) => Promise; type ReadGetEntryPointParameters = { client: Client; contractAddress: Address; }; declare const read$B: ({ client, contractAddress, }: ReadGetEntryPointParameters) => Promise<`0x${string}`>; type ReadGetNonceParameters$1 = { client: Client; contractAddress: Address; key?: bigint; }; declare const read$A: ({ client, contractAddress, key, }: ReadGetNonceParameters$1) => Promise; type ReadGetProxyImplementationParameters = { client: Client; contractAddress: Address; }; declare const read$z: ({ client, contractAddress, }: ReadGetProxyImplementationParameters) => Promise<`0x${string}`>; type ReadGetProxyVersionParameters = { client: Client; contractAddress: Address; }; declare const read$y: ({ client, contractAddress, }: ReadGetProxyVersionParameters) => Promise; declare namespace read$x { export { read$D as getDelegationManager, read$C as getDeposit, read$B as getEntryPoint, read$A as getNonce, read$z as getProxyImplementation, read$y as getProxyVersion, read$E as isValidSignature }; } declare namespace simulate$n { export { simulate$s as disableDelegation, simulate$r as enableDelegation, simulate$q as execute, simulate$p as executeWithMode, simulate$o as upgradeToAndCall }; } declare namespace index$d { export { encode$n as encode, execute$9 as execute, read$x as read, simulate$n as simulate }; } type ReadGetContractNameParameters = { client: Client; contractAddress: Address; }; declare const read$w: ({ client, contractAddress, }: ReadGetContractNameParameters) => Promise; type ReadGetContractVersionParameters = { client: Client; contractAddress: Address; }; declare const read$v: ({ client, contractAddress, }: ReadGetContractVersionParameters) => Promise; type ReadGetDomainVersionParameters = { client: Client; contractAddress: Address; }; declare const read$u: ({ client, contractAddress, }: ReadGetDomainVersionParameters) => Promise; declare namespace read$t { export { read$w as getContractName, read$v as getContractVersion, read$u as getDomainVersion }; } declare namespace index$c { export { read$t as read }; } type ReadGetNonceParameters = { client: Client; entryPoint: Address; contractAddress: Address; key: bigint; }; declare const read$s: ({ client, entryPoint, contractAddress, key, }: ReadGetNonceParameters) => Promise; declare namespace read$r { export { read$s as entryPointGetNonce }; } declare namespace index$b { export { read$r as read }; } type ReadGetAvailableAmountParameters$4 = { client: Client; contractAddress: Address; delegationHash: Hex; delegationManager: Address; terms: Hex; }; declare const read$q: ({ client, contractAddress, delegationHash, delegationManager, terms, }: ReadGetAvailableAmountParameters$4) => Promise<{ availableAmount: bigint; isNewPeriod: boolean; currentPeriod: bigint; }>; declare namespace read$p { export { read$q as getAvailableAmount }; } declare namespace index$a { export { read$p as read }; } type ReadGetAvailableAmountParameters$3 = { client: Client; contractAddress: Address; delegationManager: Address; delegationHash: Hex; terms: Hex; }; declare const read$o: ({ client, contractAddress, delegationManager, delegationHash, terms, }: ReadGetAvailableAmountParameters$3) => Promise<{ availableAmount: bigint; }>; declare namespace read$n { export { read$o as getAvailableAmount }; } declare namespace index$9 { export { read$n as read }; } type ReadGetKeyParameters = { client: Client; hybridDeleGatorAddress: Address; keyId: string; }; declare const read$m: ({ client, hybridDeleGatorAddress, keyId, }: ReadGetKeyParameters) => Promise; type ReadGetKeyIdHashesParameters = { client: Client; hybridDeleGatorAddress: Address; }; declare const read$l: ({ client, hybridDeleGatorAddress, }: ReadGetKeyIdHashesParameters) => Promise; type ReadGetKeyIdHashesCountParameters = { client: Client; hybridDeleGatorAddress: Address; }; declare const read$k: ({ client, hybridDeleGatorAddress, }: ReadGetKeyIdHashesCountParameters) => Promise; declare namespace read$j { export { read$m as getKey, read$l as getKeyIdHashes, read$k as getKeyIdHashesCount }; } type EncodeAddKeyParameters = { p256Owner: P256Owner; }; type SimulateAddKeyParameters = { client: Client; hybridDeleGatorAddress: Address; } & EncodeAddKeyParameters; declare const simulate$m: ({ client, hybridDeleGatorAddress, p256Owner, }: SimulateAddKeyParameters) => Promise>; declare const encode$m: ({ p256Owner }: EncodeAddKeyParameters) => `0x${string}`; type EncodeInitializeParameters$1 = { eoaOwner: Address; p256Owners: P256Owner[]; }; type SimulateInitializeParameters$1 = { client: Client; hybridDeleGatorAddress: Address; } & EncodeInitializeParameters$1; declare const simulate$l: ({ client, hybridDeleGatorAddress, eoaOwner, p256Owners, }: SimulateInitializeParameters$1) => Promise>; declare const encode$l: ({ 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$k: ({ client, hybridDeleGatorAddress, version, eoaOwner, p256Owners, removeExistingP256Owners, }: SimulateReinitializeParameters$1) => Promise>; declare const encode$k: ({ version, eoaOwner, p256Owners, removeExistingP256Owners, }: EncodeReinitializeParameters$1) => `0x${string}`; type EncodeRemoveKeyParameters = { keyId: string; }; type SimulateRemoveKeyParameters = { client: Client; hybridDeleGatorAddress: Address; } & EncodeRemoveKeyParameters; declare const simulate$j: ({ client, hybridDeleGatorAddress, keyId, }: SimulateRemoveKeyParameters) => Promise>; declare const encode$j: ({ keyId }: EncodeRemoveKeyParameters) => `0x${string}`; type EncodeUpdateSignersParameters = { eoaOwner: Address; p256Owners: P256Owner[]; }; type SimulateUpdateSignersParameters = { client: Client; hybridDeleGatorAddress: Address; } & EncodeUpdateSignersParameters; declare const simulate$i: ({ client, hybridDeleGatorAddress, eoaOwner, p256Owners, }: SimulateUpdateSignersParameters) => Promise>; declare const encode$i: ({ eoaOwner, p256Owners, }: EncodeUpdateSignersParameters) => `0x${string}`; declare namespace encode$h { export { encode$m as addKey, encode$l as initializeHybridDeleGator, encode$k as reinitializeHybridDeleGator, encode$j as removeKey, encode$i as updateSigners }; } declare namespace simulate$h { export { simulate$m as addKey, simulate$l as initializeHybridDeleGator, simulate$k as reinitializeHybridDeleGator, simulate$j as removeKey, simulate$i 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$8 { export { constants$1 as constants, encode$h as encode, read$j as read, simulate$h as simulate }; } type ReadGetMaxNumberOfSignersParameters = { client: Client; multiSigDeleGatorAddress: Address; }; declare const read$i: ({ client, multiSigDeleGatorAddress, }: ReadGetMaxNumberOfSignersParameters) => Promise; type ReadGetSignersParameters = { client: Client; multiSigDeleGatorAddress: Address; }; declare const read$h: ({ client, multiSigDeleGatorAddress, }: ReadGetSignersParameters) => Promise; type ReadGetSignersCountParameters = { client: Client; multiSigDeleGatorAddress: Address; }; declare const read$g: ({ client, multiSigDeleGatorAddress, }: ReadGetSignersCountParameters) => Promise; type ReadGetThresholdParameters = { client: Client; multiSigDeleGatorAddress: Address; }; declare const read$f: ({ client, multiSigDeleGatorAddress, }: ReadGetThresholdParameters) => Promise; type ReadIsSignerParameters = { client: Client; multiSigDeleGatorAddress: Address; signer: Address; }; declare const read$e: ({ client, multiSigDeleGatorAddress, signer, }: ReadIsSignerParameters) => Promise; declare namespace read$d { export { read$i as getMaxNumberOfSigners, read$h as getSigners, read$g as getSignersCount, read$f as getThreshold, read$e as isSigner }; } type EncodeAddSignerParameters = { signer: Address; }; type SimulateAddSignerParameters = { client: Client; multiSigDeleGatorAddress: Address; } & EncodeAddSignerParameters; declare const simulate$g: ({ client, multiSigDeleGatorAddress, signer, }: SimulateAddSignerParameters) => Promise>; declare const encode$g: ({ signer }: EncodeAddSignerParameters) => `0x${string}`; type EncodeInitializeParameters = { owners: Address[]; threshold: bigint; }; type SimulateInitializeParameters = { client: Client; multiSigDeleGatorAddress: Address; } & EncodeInitializeParameters; declare const simulate$f: ({ client, multiSigDeleGatorAddress, owners, threshold, }: SimulateInitializeParameters) => Promise>; declare const encode$f: ({ 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$e: ({ client, multiSigDeleGatorAddress, version, owners, threshold, removeExistingOwners, }: SimulateReinitializeParameters) => Promise>; declare const encode$e: ({ version, owners, threshold, removeExistingOwners, }: EncodeReinitializeParameters) => `0x${string}`; type EncodeRemoveSignerParameters = { signer: Address; }; type SimulateRemoveSignerParameters = { client: Client; multiSigDeleGatorAddress: Address; } & EncodeRemoveSignerParameters; declare const simulate$d: ({ client, multiSigDeleGatorAddress, signer, }: SimulateRemoveSignerParameters) => Promise>; declare const encode$d: ({ signer }: EncodeRemoveSignerParameters) => `0x${string}`; type EncodeReplaceSignerParameters = { oldSigner: Address; newSigner: Address; }; type SimulateReplaceSignerParameters = { client: Client; multiSigDeleGatorAddress: Address; } & EncodeReplaceSignerParameters; declare const simulate$c: ({ client, multiSigDeleGatorAddress, oldSigner, newSigner, }: SimulateReplaceSignerParameters) => Promise>; declare const encode$c: ({ oldSigner, newSigner, }: EncodeReplaceSignerParameters) => `0x${string}`; type EncodeUpdateMultiSigParametersParameters = { owners: Address[]; threshold: bigint; removeExistingOwners: boolean; }; type SimulateUpdateMultiSigParametersParameters = { client: Client; multiSigDeleGatorAddress: Address; } & EncodeUpdateMultiSigParametersParameters; declare const simulate$b: ({ client, multiSigDeleGatorAddress, owners, threshold, removeExistingOwners, }: SimulateUpdateMultiSigParametersParameters) => Promise>; declare const encode$b: ({ owners, threshold, removeExistingOwners, }: EncodeUpdateMultiSigParametersParameters) => `0x${string}`; type EncodeUpdateThresholdParameters = { threshold: bigint; }; type SimulateUpdateThresholdParameters = { client: Client; multiSigDeleGatorAddress: Address; } & EncodeUpdateThresholdParameters; declare const simulate$a: ({ client, multiSigDeleGatorAddress, threshold, }: SimulateUpdateThresholdParameters) => Promise>; declare const encode$a: ({ threshold }: EncodeUpdateThresholdParameters) => `0x${string}`; declare namespace encode$9 { export { encode$g as addSigner, encode$f as initializeMultiSigDeleGator, encode$e as reinitializeMultiSigDeleGator, encode$d as removeSigner, encode$c as replaceSigner, encode$b as updateMultiSigParameters, encode$a as updateThreshold }; } declare namespace simulate$9 { export { simulate$g as addSigner, simulate$f as initializeMultiSigDeleGator, simulate$e as reinitializeMultiSigDeleGator, simulate$d as removeSigner, simulate$c as replaceSigner, simulate$b as updateMultiSigParameters, simulate$a 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$7_constants: typeof constants; declare namespace index$7 { export { index$7_constants as constants, encode$9 as encode, read$d as read, simulate$9 as simulate }; } type ReadGetAvailableAmountParameters$2 = { client: Client; contractAddress: Address; delegationHash: Hex; delegationManager: Address; terms: Hex; args: Hex; }; declare const read$c: ({ client, contractAddress, delegationHash, delegationManager, terms, args, }: ReadGetAvailableAmountParameters$2) => Promise<{ availableAmount: bigint; isNewPeriod: boolean; currentPeriod: bigint; }>; declare namespace read$b { export { read$c as getAvailableAmount }; } declare namespace index$6 { export { read$b as read }; } type ReadGetAvailableAmountParameters$1 = { client: Client; contractAddress: Address; delegationHash: Hex; delegationManager: Address; terms: Hex; }; declare const read$a: ({ client, contractAddress, delegationHash, delegationManager, terms, }: ReadGetAvailableAmountParameters$1) => Promise<{ availableAmount: bigint; isNewPeriod: boolean; currentPeriod: bigint; }>; declare namespace read$9 { export { read$a as getAvailableAmount }; } declare namespace index$5 { export { read$9 as read }; } type ReadGetAvailableAmountParameters = { client: Client; contractAddress: Address; delegationManager: Address; delegationHash: Hex; terms: Hex; }; declare const read$8: ({ client, contractAddress, delegationManager, delegationHash, terms, }: ReadGetAvailableAmountParameters) => Promise<{ availableAmount: bigint; }>; declare namespace read$7 { export { read$8 as getAvailableAmount }; } declare namespace index$4 { export { read$7 as read }; } type ReadGetOwnerParameters = { client: Client; contractAddress: Address; }; declare const read$6: ({ client, contractAddress, }: ReadGetOwnerParameters) => Promise<`0x${string}`>; type ReadGetPendingOwnerParameters = { client: Client; contractAddress: Address; }; declare const read$5: ({ client, contractAddress, }: ReadGetPendingOwnerParameters) => Promise<`0x${string}`>; declare namespace read$4 { export { read$6 as getOwner, read$5 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$3 { export { encode$5 as encode, execute$5 as execute, read$4 as read, simulate$5 as simulate }; } type ReadIsPausedParameters = { client: Client; contractAddress: Address; }; declare const read$3: ({ client, contractAddress, }: ReadIsPausedParameters) => Promise; declare namespace read$2 { export { read$3 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$2 { export { encode$2 as encode, execute$2 as execute, read$2 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$1: (client: Client, factoryAddress: Address, creationCode: Hex, salt: Hex) => Promise<`0x${string}`>; declare namespace read { export { read$1 as getCreate2Address }; } declare namespace simulate { export { simulate$1 as create2Deploy }; } declare const index$1_encode: typeof encode; declare const index$1_execute: typeof execute; declare const index$1_read: typeof read; declare const index$1_simulate: typeof simulate; declare namespace index$1 { export { index$1_encode as encode, index$1_execute as execute, index$1_read as read, index$1_simulate as simulate }; } 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$d as DeleGatorCore, index$e as DelegationManager, index$c as EIP712, index$a as ERC20PeriodTransferEnforcer, index$9 as ERC20StreamingEnforcer, index$b as EntryPoint, index$8 as HybridDeleGator, type index_InitializedClient as InitializedClient, index$7 as MultiSigDeleGator, index$6 as MultiTokenPeriodEnforcer, type index_NarrowAbiToFunction as NarrowAbiToFunction, index$5 as NativeTokenPeriodTransferEnforcer, index$4 as NativeTokenStreamingEnforcer, index$3 as Ownable2Step, type index_P256Owner as P256Owner, index$2 as Pausable, index_Redemption as Redemption, index$1 as SimpleFactory, 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$e as a, index$d as b, index$c as c, index$b as d, index$8 as e, index$7 as f, index$3 as g, index$2 as h, index as i, index$1 as j, index$a as k, index$6 as l, index$5 as m, index$9 as n, index$4 as o, isContractDeployed as p, isImplementationExpected as q, encodeProxyCreationCode as r };