import { O as OethToken, x as OethPool, y as OethToken$1, z as OethPool$1, H as OethToken$2, I as OethToken$3, F as Fee, T as Target, f as Annotation, C as ContractInput } from './types-BevOfOBc.mjs';
import * as zod from 'zod';
import { C as CircleChain, a as CircleChain$1 } from './types-DC4uV3e0.mjs';
import * as zodiac_roles_sdk__ from 'zodiac-roles-sdk/.';

declare const allow: {
    circle_v1: {
        bridge: (args_0: {
            targets: (CircleChain["chain"] | CircleChain["description"])[];
            recipient: `0x${string}`;
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
        receive: (args_0: {
            targets: (CircleChain["chain"] | CircleChain["description"])[];
            recipient: `0x${string}`;
            sender: `0x${string}`;
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
    };
    circle_v2: {
        bridge: (args_0: {
            targets: (CircleChain$1["chain"] | CircleChain$1["description"])[];
            recipient: `0x${string}`;
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
        receive: (args_0: {
            targets: (CircleChain$1["chain"] | CircleChain$1["description"])[];
            recipient: `0x${string}`;
            sender: `0x${string}`;
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
    };
    aave_v3: {
        deposit: (args_0: {
            targets: ("ETH" | OethToken["symbol"] | OethToken["token"])[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
        borrow: (args_0: {
            targets: ("ETH" | OethToken["symbol"] | OethToken["token"])[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
    };
    aura: {
        deposit: (args_0: {
            targets: (OethPool["name"] | OethPool["bpt"] | OethPool["id"])[];
            tokens?: (OethToken$1["address"] | OethToken$1["symbol"])[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
    };
    balancer_v2: {
        deposit: (args_0: {
            targets: (OethPool$1["name"] | OethPool$1["bpt"] | OethPool$1["id"])[];
            tokens?: (OethToken$2["address"] | OethToken$2["symbol"])[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
        stake: (options: {
            targets: (OethPool$1["name"] | OethPool$1["bpt"] | OethPool$1["id"])[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
    };
    uniswap_v3: {
        deposit: (args_0: {
            targets?: string[];
            tokens?: (OethToken$3["address"] | OethToken$3["symbol"])[];
            fees?: Fee[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
    };
};
declare const schema: {
    circle_v1: {
        bridge: zod.ZodObject<{
            targets: zod.ZodArray<zod.ZodEnum<[string, string, ...string[]]>, "many">;
            recipient: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            targets: string[];
            recipient: string;
        }, {
            targets: string[];
            recipient: string;
        }>;
        receive: zod.ZodObject<{
            targets: zod.ZodArray<zod.ZodEnum<[string, string, ...string[]]>, "many">;
            recipient: zod.ZodString;
            sender: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            targets: string[];
            recipient: string;
            sender: string;
        }, {
            targets: string[];
            recipient: string;
            sender: string;
        }>;
    };
    circle_v2: {
        bridge: zod.ZodObject<{
            targets: zod.ZodArray<zod.ZodEnum<[string, string, ...string[]]>, "many">;
            recipient: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            targets: string[];
            recipient: string;
        }, {
            targets: string[];
            recipient: string;
        }>;
        receive: zod.ZodObject<{
            targets: zod.ZodArray<zod.ZodEnum<[string, string, ...string[]]>, "many">;
            recipient: zod.ZodString;
            sender: zod.ZodString;
        }, "strip", zod.ZodTypeAny, {
            targets: string[];
            recipient: string;
            sender: string;
        }, {
            targets: string[];
            recipient: string;
            sender: string;
        }>;
    };
    aave_v3: {
        deposit: zod.ZodObject<{
            targets: zod.ZodArray<zod.ZodEnum<[string, string, ...string[]]>, "many">;
        }, "strip", zod.ZodTypeAny, {
            targets: string[];
        }, {
            targets: string[];
        }>;
        borrow: zod.ZodObject<{
            targets: zod.ZodArray<zod.ZodEnum<[string, string, ...string[]]>, "many">;
        }, "strip", zod.ZodTypeAny, {
            targets: string[];
        }, {
            targets: string[];
        }>;
    };
    aura: {
        deposit: zod.ZodObject<{
            targets: zod.ZodArray<zod.ZodEnum<[string, string, ...string[]]>, "many">;
            tokens: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<[string, string, ...string[]]>, "many">>;
        }, "strip", zod.ZodTypeAny, {
            targets: string[];
            tokens?: string[] | undefined;
        }, {
            targets: string[];
            tokens?: string[] | undefined;
        }>;
    };
    balancer_v2: {
        deposit: zod.ZodObject<{
            targets: zod.ZodArray<zod.ZodEnum<[string, string, ...string[]]>, "many">;
            tokens: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<[string, string, ...string[]]>, "many">>;
        }, "strip", zod.ZodTypeAny, {
            targets: string[];
            tokens?: string[] | undefined;
        }, {
            targets: string[];
            tokens?: string[] | undefined;
        }>;
        stake: zod.ZodObject<{
            targets: zod.ZodArray<zod.ZodEnum<[string, string, ...string[]]>, "many">;
        }, "strip", zod.ZodTypeAny, {
            targets: string[];
        }, {
            targets: string[];
        }>;
    };
    uniswap_v3: {
        deposit: zod.ZodObject<{
            targets: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
            tokens: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<[string, string, ...string[]]>, "many">>;
            fees: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<["0.01%", "0.05%", "0.3%", "1%"]>, "many">>;
        }, "strip", zod.ZodTypeAny, {
            targets?: string[] | undefined;
            tokens?: string[] | undefined;
            fees?: ("0.01%" | "0.05%" | "0.3%" | "1%")[] | undefined;
        }, {
            targets?: string[] | undefined;
            tokens?: string[] | undefined;
            fees?: ("0.01%" | "0.05%" | "0.3%" | "1%")[] | undefined;
        }>;
    };
};
declare const repertoire: {
    allow: {
        aave_v3: {
            deposit: (args_0: {
                token: "ETH" | OethToken["symbol"] | OethToken["token"];
            }) => Promise<zodiac_roles_sdk__.PermissionSet>;
            withdraw: (args_0: {
                token: "ETH" | OethToken["symbol"] | OethToken["token"];
            }) => Promise<zodiac_roles_sdk__.PermissionSet>;
            set_collateralisation: (args_0: {
                token: "ETH" | OethToken["symbol"] | OethToken["token"];
                useAsCollateral: boolean;
            }) => Promise<zodiac_roles_sdk__.PermissionSet>;
        };
        aura: {
            unstake: (args_0: {
                rewarder: `0x${string}`;
            }) => Promise<zodiac_roles_sdk__.PermissionSet>;
            unstake_withdraw_proportional: (args_0: {
                rewarder: `0x${string}`;
            }) => Promise<zodiac_roles_sdk__.PermissionSet>;
            unstake_withdraw_single_token: (args_0: {
                rewarder: `0x${string}`;
                exitTokenAddress: `0x${string}`;
            }) => Promise<zodiac_roles_sdk__.PermissionSet>;
        };
        balancer_v2: {
            withdraw_proportional: (args_0: {
                bpt: `0x${string}`;
            }) => Promise<zodiac_roles_sdk__.PermissionSet>;
            withdraw_single: (args_0: {
                bpt: `0x${string}`;
                exitTokenAddress: `0x${string}`;
            }) => Promise<zodiac_roles_sdk__.PermissionSet>;
            unstake_withdraw_proportional: (args_0: {
                gauge: `0x${string}`;
            }) => Promise<zodiac_roles_sdk__.PermissionSet>;
            unstake_withdraw_single: (args_0: {
                gauge: `0x${string}`;
                exitTokenAddress: `0x${string}`;
            }) => Promise<zodiac_roles_sdk__.PermissionSet>;
        };
    };
    schema: {
        aave_v3: {
            deposit: zod.ZodObject<{
                token: zod.ZodEnum<[string, string, ...string[]]>;
            }, "strip", zod.ZodTypeAny, {
                token: string;
            }, {
                token: string;
            }>;
            withdraw: zod.ZodObject<{
                token: zod.ZodEnum<[string, string, ...string[]]>;
            }, "strip", zod.ZodTypeAny, {
                token: string;
            }, {
                token: string;
            }>;
            set_collateralisation: zod.ZodObject<{
                token: zod.ZodEnum<[string, string, ...string[]]>;
                useAsCollateral: zod.ZodBoolean;
            }, "strip", zod.ZodTypeAny, {
                token: string;
                useAsCollateral: boolean;
            }, {
                token: string;
                useAsCollateral: boolean;
            }>;
        };
        aura: {
            unstake: zod.ZodObject<{
                rewarder: zod.ZodEnum<[string, string, ...string[]]>;
            }, "strip", zod.ZodTypeAny, {
                rewarder: string;
            }, {
                rewarder: string;
            }>;
            unstake_withdraw_proportional: zod.ZodObject<{
                rewarder: zod.ZodEnum<[string, string, ...string[]]>;
            }, "strip", zod.ZodTypeAny, {
                rewarder: string;
            }, {
                rewarder: string;
            }>;
            unstake_withdraw_single_token: zod.ZodObject<{
                rewarder: zod.ZodEnum<[string, string, ...string[]]>;
                exitTokenAddress: zod.ZodEnum<[string, string, ...string[]]>;
            }, "strip", zod.ZodTypeAny, {
                rewarder: string;
                exitTokenAddress: string;
            }, {
                rewarder: string;
                exitTokenAddress: string;
            }>;
        };
        balancer_v2: {
            withdraw_proportional: zod.ZodObject<{
                bpt: zod.ZodEnum<[string, string, ...string[]]>;
            }, "strip", zod.ZodTypeAny, {
                bpt: string;
            }, {
                bpt: string;
            }>;
            withdraw_single: zod.ZodObject<{
                bpt: zod.ZodEnum<[string, string, ...string[]]>;
                exitTokenAddress: zod.ZodEnum<[string, string, ...string[]]>;
            }, "strip", zod.ZodTypeAny, {
                bpt: string;
                exitTokenAddress: string;
            }, {
                bpt: string;
                exitTokenAddress: string;
            }>;
            unstake_withdraw_proportional: zod.ZodObject<{
                gauge: zod.ZodEnum<[string, string, ...string[]]>;
            }, "strip", zod.ZodTypeAny, {
                gauge: string;
            }, {
                gauge: string;
            }>;
            unstake_withdraw_single: zod.ZodObject<{
                gauge: zod.ZodEnum<[string, string, ...string[]]>;
                exitTokenAddress: zod.ZodEnum<[string, string, ...string[]]>;
            }, "strip", zod.ZodTypeAny, {
                gauge: string;
                exitTokenAddress: string;
            }, {
                gauge: string;
                exitTokenAddress: string;
            }>;
        };
    };
};
declare const apply: (roleKey: `0x${string}`, permissions: (zodiac_roles_sdk__.Permission | zodiac_roles_sdk__.PermissionSet | Promise<zodiac_roles_sdk__.PermissionSet>)[], options: {
    address: `0x${string}`;
    mode: "replace" | "extend" | "remove";
    log?: boolean | ((message: string) => void);
    currentTargets?: Target[];
    currentAnnotations?: Annotation[];
}) => Promise<{
    to: `0x${string}`;
    data: `0x${string}`;
}[]>;
declare const exportToSafeTransactionBuilder: (transactions: {
    to: `0x${string}`;
    data: `0x${string}`;
}[], meta?: {
    name?: string;
    description?: string;
}) => {
    readonly version: "1.0";
    readonly chainId: string;
    readonly createdAt: number;
    readonly meta: {
        readonly name: string;
        readonly description: string;
        readonly txBuilderVersion: "1.16.2";
    };
    readonly transactions: {
        to: `0x${string}`;
        value: string;
        contractMethod: {
            inputs: ContractInput[];
            name: string;
            payable: boolean;
        };
        contractInputsValues: Record<string, string>;
    }[];
};

export { allow, apply, exportToSafeTransactionBuilder, repertoire, schema };