import { G as GnoToken, s as GnoPool, t as GnoToken$1, u as GnoPool$1, v as GnoToken$2, w as GnoToken$4, F as Fee, T as Target, f as Annotation, C as ContractInput } from './types-BevOfOBc.mjs';
import * as zod from 'zod';
import { G as GnoToken$3, b as GnoVault } from './types-CboiguBL.mjs';
import * as zodiac_roles_sdk__ from 'zodiac-roles-sdk/.';

declare const allow: {
    aave_v3: {
        deposit: (args_0: {
            targets: ("XDAI" | GnoToken["symbol"] | GnoToken["token"])[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
        borrow: (args_0: {
            targets: ("XDAI" | GnoToken["symbol"] | GnoToken["token"])[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
    };
    aura: {
        deposit: (args_0: {
            targets: (GnoPool["name"] | GnoPool["bpt"] | GnoPool["id"])[];
            tokens?: (GnoToken$1["address"] | GnoToken$1["symbol"])[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
    };
    balancer_v2: {
        deposit: (args_0: {
            targets: (GnoPool$1["name"] | GnoPool$1["bpt"] | GnoPool$1["id"])[];
            tokens?: (GnoToken$2["address"] | GnoToken$2["symbol"])[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
        stake: (options: {
            targets: (GnoPool$1["name"] | GnoPool$1["bpt"] | GnoPool$1["id"])[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
    };
    cowswap: {
        swap: (options: {
            sell: (`0x${string}` | "XDAI")[];
            buy?: (`0x${string}` | "XDAI")[];
            feeAmountBp?: number;
            twap?: boolean;
            receiver?: `0x${string}`;
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
    };
    spark: {
        deposit: (args_0: {
            targets: ("DSR_sDAI" | "XDAI" | GnoToken$3["symbol"] | GnoToken$3["token"])[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
        borrow: (args_0: {
            targets: ("XDAI" | GnoToken$3["symbol"] | GnoToken$3["token"])[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
    };
    stakewise_v3: {
        stake: (options: {
            targets: (GnoVault["name"] | GnoVault["id"])[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
    };
    uniswap_v3: {
        deposit: (args_0: {
            targets?: string[];
            tokens?: (GnoToken$4["address"] | GnoToken$4["symbol"])[];
            fees?: Fee[];
        }) => Promise<zodiac_roles_sdk__.PermissionSet>;
    };
};
declare const schema: {
    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[];
        }>;
    };
    cowswap: {
        swap: zod.ZodObject<{
            sell: zod.ZodArray<zod.ZodUnion<[zod.ZodEffects<zod.ZodString, `0x${string}`, string>, zod.ZodLiteral<"XDAI" | "ETH">]>, "many">;
            buy: zod.ZodOptional<zod.ZodArray<zod.ZodUnion<[zod.ZodEffects<zod.ZodString, `0x${string}`, string>, zod.ZodLiteral<"XDAI" | "ETH">]>, "many">>;
            feeAmountBp: zod.ZodOptional<zod.ZodNumber>;
            twap: zod.ZodOptional<zod.ZodBoolean>;
            receiver: zod.ZodOptional<zod.ZodEffects<zod.ZodString, `0x${string}`, string>>;
        }, "strip", zod.ZodTypeAny, {
            sell: ("XDAI" | `0x${string}` | "ETH")[];
            buy?: ("XDAI" | `0x${string}` | "ETH")[] | undefined;
            feeAmountBp?: number | undefined;
            twap?: boolean | undefined;
            receiver?: `0x${string}` | undefined;
        }, {
            sell: string[];
            buy?: string[] | undefined;
            feeAmountBp?: number | undefined;
            twap?: boolean | undefined;
            receiver?: string | undefined;
        }>;
    };
    spark: {
        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[];
        }>;
    };
    stakewise_v3: {
        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: "XDAI" | GnoToken["symbol"] | GnoToken["token"];
            }) => Promise<zodiac_roles_sdk__.PermissionSet>;
            withdraw: (args_0: {
                token: "XDAI" | GnoToken["symbol"] | GnoToken["token"];
            }) => Promise<zodiac_roles_sdk__.PermissionSet>;
            set_collateralisation: (args_0: {
                token: "XDAI" | GnoToken["symbol"] | GnoToken["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 };