import { BytesLike, Hex } from '@metamask/utils';
export { Hex } from '@metamask/utils';

type CaveatStruct<TBytes extends BytesLike = BytesLike> = {
    enforcer: TBytes;
    terms: TBytes;
    args: TBytes;
};
type DelegationStruct<TBytes extends BytesLike = BytesLike> = {
    delegate: TBytes;
    delegator: TBytes;
    authority: TBytes;
    caveats: CaveatStruct<TBytes>[];
    salt: bigint;
    signature: TBytes;
};

type ResultValue = 'hex' | 'bytes';
type ResultType<TResultValue extends ResultValue> = TResultValue extends 'hex' ? Hex : Uint8Array;
type DecodedBytesLike<TResultValue extends ResultValue> = ResultType<TResultValue>;
type EncodingOptions<TResultValue extends ResultValue> = {
    out: TResultValue;
};

type ValueLteTerms = {
    maxValue: bigint;
};
declare function createValueLteTerms(terms: ValueLteTerms, options?: EncodingOptions<'hex'>): Hex;
declare function createValueLteTerms(terms: ValueLteTerms, options: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeValueLteTerms(terms: BytesLike): ValueLteTerms;

type TimestampTerms = {
    afterThreshold: number;
    beforeThreshold: number;
};
declare function createTimestampTerms(terms: TimestampTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createTimestampTerms(terms: TimestampTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeTimestampTerms(terms: BytesLike): TimestampTerms;

type NativeTokenPeriodTransferTerms = {
    periodAmount: bigint;
    periodDuration: number;
    startDate: number;
};
declare function createNativeTokenPeriodTransferTerms(terms: NativeTokenPeriodTransferTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createNativeTokenPeriodTransferTerms(terms: NativeTokenPeriodTransferTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeNativeTokenPeriodTransferTerms(terms: BytesLike): NativeTokenPeriodTransferTerms;

type ExactCalldataTerms<TBytesLike extends BytesLike = BytesLike> = {
    calldata: TBytesLike;
};
declare function createExactCalldataTerms(terms: ExactCalldataTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createExactCalldataTerms(terms: ExactCalldataTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeExactCalldataTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ExactCalldataTerms<DecodedBytesLike<'hex'>>;
declare function decodeExactCalldataTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ExactCalldataTerms<DecodedBytesLike<'bytes'>>;

type ExactCalldataBatchTerms<TBytesLike extends BytesLike = BytesLike> = {
    executions: {
        target: TBytesLike;
        value: bigint;
        callData: TBytesLike;
    }[];
};
declare function createExactCalldataBatchTerms(terms: ExactCalldataBatchTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createExactCalldataBatchTerms(terms: ExactCalldataBatchTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeExactCalldataBatchTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ExactCalldataBatchTerms<DecodedBytesLike<'hex'>>;
declare function decodeExactCalldataBatchTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ExactCalldataBatchTerms<DecodedBytesLike<'bytes'>>;

type ExactExecutionTerms<TBytesLike extends BytesLike = BytesLike> = {
    execution: {
        target: TBytesLike;
        value: bigint;
        callData: TBytesLike;
    };
};
declare function createExactExecutionTerms(terms: ExactExecutionTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createExactExecutionTerms(terms: ExactExecutionTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeExactExecutionTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ExactExecutionTerms<DecodedBytesLike<'hex'>>;
declare function decodeExactExecutionTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ExactExecutionTerms<DecodedBytesLike<'bytes'>>;

type ExactExecutionBatchTerms<TBytesLike extends BytesLike = BytesLike> = {
    executions: {
        target: TBytesLike;
        value: bigint;
        callData: TBytesLike;
    }[];
};
declare function createExactExecutionBatchTerms(terms: ExactExecutionBatchTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createExactExecutionBatchTerms(terms: ExactExecutionBatchTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeExactExecutionBatchTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ExactExecutionBatchTerms<DecodedBytesLike<'hex'>>;
declare function decodeExactExecutionBatchTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ExactExecutionBatchTerms<DecodedBytesLike<'bytes'>>;

type NativeTokenStreamingTerms = {
    initialAmount: bigint;
    maxAmount: bigint;
    amountPerSecond: bigint;
    startTime: number;
};
declare function createNativeTokenStreamingTerms(terms: NativeTokenStreamingTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createNativeTokenStreamingTerms(terms: NativeTokenStreamingTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeNativeTokenStreamingTerms(terms: BytesLike): NativeTokenStreamingTerms;

type NativeTokenTransferAmountTerms = {
    maxAmount: bigint;
};
declare function createNativeTokenTransferAmountTerms(terms: NativeTokenTransferAmountTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createNativeTokenTransferAmountTerms(terms: NativeTokenTransferAmountTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeNativeTokenTransferAmountTerms(terms: BytesLike): NativeTokenTransferAmountTerms;

type NativeTokenPaymentTerms<TBytesLike extends BytesLike = BytesLike> = {
    recipient: TBytesLike;
    amount: bigint;
};
declare function createNativeTokenPaymentTerms(terms: NativeTokenPaymentTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createNativeTokenPaymentTerms(terms: NativeTokenPaymentTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeNativeTokenPaymentTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): NativeTokenPaymentTerms<DecodedBytesLike<'hex'>>;
declare function decodeNativeTokenPaymentTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): NativeTokenPaymentTerms<DecodedBytesLike<'bytes'>>;

type NativeBalanceChangeTerms<TBytesLike extends BytesLike = BytesLike> = {
    recipient: TBytesLike;
    balance: bigint;
    changeType: number;
};
declare function createNativeBalanceChangeTerms(terms: NativeBalanceChangeTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createNativeBalanceChangeTerms(terms: NativeBalanceChangeTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeNativeBalanceChangeTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): NativeBalanceChangeTerms<DecodedBytesLike<'hex'>>;
declare function decodeNativeBalanceChangeTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): NativeBalanceChangeTerms<DecodedBytesLike<'bytes'>>;

type ERC20StreamingTerms<TBytesLike extends BytesLike = BytesLike> = {
    tokenAddress: TBytesLike;
    initialAmount: bigint;
    maxAmount: bigint;
    amountPerSecond: bigint;
    startTime: number;
};
declare function createERC20StreamingTerms(terms: ERC20StreamingTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createERC20StreamingTerms(terms: ERC20StreamingTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeERC20StreamingTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ERC20StreamingTerms<DecodedBytesLike<'hex'>>;
declare function decodeERC20StreamingTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ERC20StreamingTerms<DecodedBytesLike<'bytes'>>;

type ERC20TokenPeriodTransferTerms<TBytesLike extends BytesLike = BytesLike> = {
    tokenAddress: TBytesLike;
    periodAmount: bigint;
    periodDuration: number;
    startDate: number;
};
declare function createERC20TokenPeriodTransferTerms(terms: ERC20TokenPeriodTransferTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createERC20TokenPeriodTransferTerms(terms: ERC20TokenPeriodTransferTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeERC20TokenPeriodTransferTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ERC20TokenPeriodTransferTerms<DecodedBytesLike<'hex'>>;
declare function decodeERC20TokenPeriodTransferTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ERC20TokenPeriodTransferTerms<DecodedBytesLike<'bytes'>>;

type ERC20TransferAmountTerms<TBytesLike extends BytesLike = BytesLike> = {
    tokenAddress: TBytesLike;
    maxAmount: bigint;
};
declare function createERC20TransferAmountTerms(terms: ERC20TransferAmountTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createERC20TransferAmountTerms(terms: ERC20TransferAmountTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeERC20TransferAmountTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ERC20TransferAmountTerms<DecodedBytesLike<'hex'>>;
declare function decodeERC20TransferAmountTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ERC20TransferAmountTerms<DecodedBytesLike<'bytes'>>;

type ERC20BalanceChangeTerms<TBytesLike extends BytesLike = BytesLike> = {
    tokenAddress: TBytesLike;
    recipient: TBytesLike;
    balance: bigint;
    changeType: number;
};
declare function createERC20BalanceChangeTerms(terms: ERC20BalanceChangeTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createERC20BalanceChangeTerms(terms: ERC20BalanceChangeTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeERC20BalanceChangeTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ERC20BalanceChangeTerms<DecodedBytesLike<'hex'>>;
declare function decodeERC20BalanceChangeTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ERC20BalanceChangeTerms<DecodedBytesLike<'bytes'>>;

type ERC721BalanceChangeTerms<TBytesLike extends BytesLike = BytesLike> = {
    tokenAddress: TBytesLike;
    recipient: TBytesLike;
    amount: bigint;
    changeType: number;
};
declare function createERC721BalanceChangeTerms(terms: ERC721BalanceChangeTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createERC721BalanceChangeTerms(terms: ERC721BalanceChangeTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeERC721BalanceChangeTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ERC721BalanceChangeTerms<DecodedBytesLike<'hex'>>;
declare function decodeERC721BalanceChangeTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ERC721BalanceChangeTerms<DecodedBytesLike<'bytes'>>;

type ERC721TransferTerms<TBytesLike extends BytesLike = BytesLike> = {
    tokenAddress: TBytesLike;
    tokenId: bigint;
};
declare function createERC721TransferTerms(terms: ERC721TransferTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createERC721TransferTerms(terms: ERC721TransferTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeERC721TransferTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ERC721TransferTerms<DecodedBytesLike<'hex'>>;
declare function decodeERC721TransferTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ERC721TransferTerms<DecodedBytesLike<'bytes'>>;

type ERC1155BalanceChangeTerms<TBytesLike extends BytesLike = BytesLike> = {
    tokenAddress: TBytesLike;
    recipient: TBytesLike;
    tokenId: bigint;
    balance: bigint;
    changeType: number;
};
declare function createERC1155BalanceChangeTerms(terms: ERC1155BalanceChangeTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createERC1155BalanceChangeTerms(terms: ERC1155BalanceChangeTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeERC1155BalanceChangeTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ERC1155BalanceChangeTerms<DecodedBytesLike<'hex'>>;
declare function decodeERC1155BalanceChangeTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ERC1155BalanceChangeTerms<DecodedBytesLike<'bytes'>>;

type NonceTerms<TBytesLike extends BytesLike = BytesLike> = {
    nonce: TBytesLike;
};
declare function createNonceTerms(terms: NonceTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createNonceTerms(terms: NonceTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeNonceTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): NonceTerms<DecodedBytesLike<'hex'>>;
declare function decodeNonceTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): NonceTerms<DecodedBytesLike<'bytes'>>;

type AllowedCalldataTerms<TBytesLike extends BytesLike = BytesLike> = {
    startIndex: number;
    value: TBytesLike;
};
declare function createAllowedCalldataTerms(terms: AllowedCalldataTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createAllowedCalldataTerms(terms: AllowedCalldataTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeAllowedCalldataTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): AllowedCalldataTerms<DecodedBytesLike<'hex'>>;
declare function decodeAllowedCalldataTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): AllowedCalldataTerms<DecodedBytesLike<'bytes'>>;

type AllowedMethodsTerms<TBytesLike extends BytesLike = BytesLike> = {
    selectors: TBytesLike[];
};
declare function createAllowedMethodsTerms(terms: AllowedMethodsTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createAllowedMethodsTerms(terms: AllowedMethodsTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeAllowedMethodsTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): AllowedMethodsTerms<DecodedBytesLike<'hex'>>;
declare function decodeAllowedMethodsTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): AllowedMethodsTerms<DecodedBytesLike<'bytes'>>;

type AllowedTargetsTerms<TBytesLike extends BytesLike = BytesLike> = {
    targets: TBytesLike[];
};
declare function createAllowedTargetsTerms(terms: AllowedTargetsTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createAllowedTargetsTerms(terms: AllowedTargetsTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeAllowedTargetsTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): AllowedTargetsTerms<DecodedBytesLike<'hex'>>;
declare function decodeAllowedTargetsTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): AllowedTargetsTerms<DecodedBytesLike<'bytes'>>;

type ArgsEqualityCheckTerms<TBytesLike extends BytesLike = BytesLike> = {
    args: TBytesLike;
};
declare function createArgsEqualityCheckTerms(terms: ArgsEqualityCheckTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createArgsEqualityCheckTerms(terms: ArgsEqualityCheckTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeArgsEqualityCheckTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): ArgsEqualityCheckTerms<DecodedBytesLike<'hex'>>;
declare function decodeArgsEqualityCheckTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): ArgsEqualityCheckTerms<DecodedBytesLike<'bytes'>>;

type BlockNumberTerms = {
    afterThreshold: bigint;
    beforeThreshold: bigint;
};
declare function createBlockNumberTerms(terms: BlockNumberTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createBlockNumberTerms(terms: BlockNumberTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeBlockNumberTerms(terms: BytesLike): BlockNumberTerms;

type DeployedTerms<TBytesLike extends BytesLike = BytesLike> = {
    contractAddress: TBytesLike;
    salt: TBytesLike;
    bytecode: TBytesLike;
};
declare function createDeployedTerms(terms: DeployedTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createDeployedTerms(terms: DeployedTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeDeployedTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): DeployedTerms<DecodedBytesLike<'hex'>>;
declare function decodeDeployedTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): DeployedTerms<DecodedBytesLike<'bytes'>>;

type IdTerms = {
    id: bigint | number;
};
declare function createIdTerms(terms: IdTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createIdTerms(terms: IdTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeIdTerms(terms: BytesLike): IdTerms;

type LimitedCallsTerms = {
    limit: number;
};
declare function createLimitedCallsTerms(terms: LimitedCallsTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createLimitedCallsTerms(terms: LimitedCallsTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeLimitedCallsTerms(terms: BytesLike): LimitedCallsTerms;

type TokenPeriodConfig<TBytesLike extends BytesLike = BytesLike> = {
    token: TBytesLike;
    periodAmount: bigint;
    periodDuration: number;
    startDate: number;
};
type MultiTokenPeriodTerms<TBytesLike extends BytesLike = BytesLike> = {
    tokenConfigs: TokenPeriodConfig<TBytesLike>[];
};
declare function createMultiTokenPeriodTerms(terms: MultiTokenPeriodTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createMultiTokenPeriodTerms(terms: MultiTokenPeriodTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeMultiTokenPeriodTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): MultiTokenPeriodTerms<DecodedBytesLike<'hex'>>;
declare function decodeMultiTokenPeriodTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): MultiTokenPeriodTerms<DecodedBytesLike<'bytes'>>;

type OwnershipTransferTerms<TBytesLike extends BytesLike = BytesLike> = {
    contractAddress: TBytesLike;
};
declare function createOwnershipTransferTerms(terms: OwnershipTransferTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createOwnershipTransferTerms(terms: OwnershipTransferTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeOwnershipTransferTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): OwnershipTransferTerms<DecodedBytesLike<'hex'>>;
declare function decodeOwnershipTransferTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): OwnershipTransferTerms<DecodedBytesLike<'bytes'>>;

type RedeemerTerms<TBytesLike extends BytesLike = BytesLike> = {
    redeemers: TBytesLike[];
};
declare function createRedeemerTerms(terms: RedeemerTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createRedeemerTerms(terms: RedeemerTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeRedeemerTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): RedeemerTerms<DecodedBytesLike<'hex'>>;
declare function decodeRedeemerTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): RedeemerTerms<DecodedBytesLike<'bytes'>>;

type SpecificActionERC20TransferBatchTerms<TBytesLike extends BytesLike = BytesLike> = {
    tokenAddress: TBytesLike;
    recipient: TBytesLike;
    amount: bigint;
    target: TBytesLike;
    calldata: TBytesLike;
};
declare function createSpecificActionERC20TransferBatchTerms(terms: SpecificActionERC20TransferBatchTerms, encodingOptions?: EncodingOptions<'hex'>): Hex;
declare function createSpecificActionERC20TransferBatchTerms(terms: SpecificActionERC20TransferBatchTerms, encodingOptions: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeSpecificActionERC20TransferBatchTerms(terms: BytesLike, encodingOptions?: EncodingOptions<'hex'>): SpecificActionERC20TransferBatchTerms<DecodedBytesLike<'hex'>>;
declare function decodeSpecificActionERC20TransferBatchTerms(terms: BytesLike, encodingOptions: EncodingOptions<'bytes'>): SpecificActionERC20TransferBatchTerms<DecodedBytesLike<'bytes'>>;

declare const ANY_BENEFICIARY: "0x0000000000000000000000000000000000000a11";
declare const ROOT_AUTHORITY: "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
declare const DELEGATION_TYPEHASH: "0x88c1d2ecf185adf710588203a5f263f0ff61be0d33da39792cde19ba9aa4331e";
declare const CAVEAT_TYPEHASH: "0x80ad7e1b04ee6d994a125f4714ca0720908bd80ed16063ec8aee4b88e9253e2d";
declare function encodeDelegations(delegations: DelegationStruct[], options?: EncodingOptions<'hex'>): Hex;
declare function encodeDelegations(delegations: DelegationStruct[], options: EncodingOptions<'bytes'>): Uint8Array;
declare function encodeDelegation(delegation: DelegationStruct, options?: EncodingOptions<'hex'>): Hex;
declare function encodeDelegation(delegation: DelegationStruct, options: EncodingOptions<'bytes'>): Uint8Array;
declare function decodeDelegations(encoded: BytesLike, options?: EncodingOptions<'hex'>): DelegationStruct<Hex>[];
declare function decodeDelegations(encoded: BytesLike, options: EncodingOptions<'bytes'>): DelegationStruct<Uint8Array>[];
declare function decodeDelegation(encoded: BytesLike, options?: EncodingOptions<'hex'>): DelegationStruct<Hex>;
declare function decodeDelegation(encoded: BytesLike, options: EncodingOptions<'bytes'>): DelegationStruct<Uint8Array>;
declare function hashDelegation(delegation: DelegationStruct, options?: EncodingOptions<'hex'>): Hex;
declare function hashDelegation(delegation: DelegationStruct, options: EncodingOptions<'bytes'>): Uint8Array;

export { ANY_BENEFICIARY, CAVEAT_TYPEHASH, type CaveatStruct as Caveat, DELEGATION_TYPEHASH, type DelegationStruct as Delegation, ROOT_AUTHORITY, createAllowedCalldataTerms, createAllowedMethodsTerms, createAllowedTargetsTerms, createArgsEqualityCheckTerms, createBlockNumberTerms, createDeployedTerms, createERC1155BalanceChangeTerms, createERC20BalanceChangeTerms, createERC20StreamingTerms, createERC20TokenPeriodTransferTerms, createERC20TransferAmountTerms, createERC721BalanceChangeTerms, createERC721TransferTerms, createExactCalldataBatchTerms, createExactCalldataTerms, createExactExecutionBatchTerms, createExactExecutionTerms, createIdTerms, createLimitedCallsTerms, createMultiTokenPeriodTerms, createNativeBalanceChangeTerms, createNativeTokenPaymentTerms, createNativeTokenPeriodTransferTerms, createNativeTokenStreamingTerms, createNativeTokenTransferAmountTerms, createNonceTerms, createOwnershipTransferTerms, createRedeemerTerms, createSpecificActionERC20TransferBatchTerms, createTimestampTerms, createValueLteTerms, decodeAllowedCalldataTerms, decodeAllowedMethodsTerms, decodeAllowedTargetsTerms, decodeArgsEqualityCheckTerms, decodeBlockNumberTerms, decodeDelegation, decodeDelegations, decodeDeployedTerms, decodeERC1155BalanceChangeTerms, decodeERC20BalanceChangeTerms, decodeERC20StreamingTerms, decodeERC20TokenPeriodTransferTerms, decodeERC20TransferAmountTerms, decodeERC721BalanceChangeTerms, decodeERC721TransferTerms, decodeExactCalldataBatchTerms, decodeExactCalldataTerms, decodeExactExecutionBatchTerms, decodeExactExecutionTerms, decodeIdTerms, decodeLimitedCallsTerms, decodeMultiTokenPeriodTerms, decodeNativeBalanceChangeTerms, decodeNativeTokenPaymentTerms, decodeNativeTokenPeriodTransferTerms, decodeNativeTokenStreamingTerms, decodeNativeTokenTransferAmountTerms, decodeNonceTerms, decodeOwnershipTransferTerms, decodeRedeemerTerms, decodeSpecificActionERC20TransferBatchTerms, decodeTimestampTerms, decodeValueLteTerms, encodeDelegation, encodeDelegations, hashDelegation };