import { TransactionResponse, ethers, ContractRunner, TransactionReceipt } from 'ethers';
import { UndefinedOr } from '@devprotocol/util-ts';

declare const addresses: {
    readonly eth: {
        readonly main: {
            readonly registry: "0x1D415aa39D647834786EB9B5a333A50e9935b796";
            readonly sTokens: "0x50489Ff5f879A44C87bBA85287729D663b18CeD5";
        };
        readonly ropsten: {
            readonly registry: "0xD6D07f1c048bDF2B3d5d9B6c25eD1FC5348D0A70";
            readonly sTokens: "0x7224e918923984b430eA4B96C4C523Da6e8d7F9D";
        };
    };
    readonly arbitrum: {
        readonly one: {
            readonly token: "0x91F5dC90979b058eBA3be6B7B7e523df7e84e137";
            readonly lockup: "0x1A2B49e10013C40AAC9b6f9e785837bfd329e5e0";
            readonly marketFactory: "0xaF490bA3EaFf9495f01407EC22027bD90eaFABb1";
            readonly metricsFactory: "0xEdCF7765B7Be6415D02173e4645604bB1A377929";
            readonly policyFactory: "0x2ef61A14284A0f45813e492b3696F4BD2cc51B6f";
            readonly propertyFactory: "0xa4C8A1E3012E8fBE21f2936DEab6dD50A0A05774";
            readonly registry: "0xbeF4DeEA3AE863739Bd402E025c749536f491ffa";
            readonly sTokens: "0x40d999931f7055F670511860e24624939e71a96a";
            readonly withdraw: "0x1c2699e43F0Bc47b45F27BFc84e99c64851A4BF0";
        };
        readonly rinkeby: {
            readonly token: "0xc28BBE3B5ec1b06FDe258864f12c1577DaDFadDC";
            readonly lockup: "0x4944CA0423f42DF7c77ad8Cd53F30f31A097F4fa";
            readonly marketFactory: "0x6EA7a231dc747fBEf931639B15908625f31287bf";
            readonly metricsFactory: "0x650663aD898A018cca44Ac224Be2286D14B7421d";
            readonly policyFactory: "0x485085f157dD7Ba451f0AB6Fa2ca42421CBA1d3c";
            readonly propertyFactory: "0x66446E01c5a2fdA8FC5Af640a12E66c078903487";
            readonly registry: "0x519d5e729fbE6B3e4607260413Fb684759612465";
            readonly sTokens: "0xe45d65c6d6aA3e2a4c8aAcc0C8153778663fe794";
            readonly withdraw: "0xFBfB9aD095f906d7E354F7ee31d88F0ca517A9C0";
        };
    };
    readonly polygon: {
        readonly mainnet: {
            readonly token: "0xA5577D1cec2583058A6Bd6d5DEAC44797c205701";
            readonly lockup: "0x42767B12d3f07bE0D951a64eE6573B40Ff165C4e";
            readonly marketFactory: "0xEA518Ab9551d3cD9Ec4C74df1fa6946B18212178";
            readonly metricsFactory: "0xD18f2eB75cE3a6A35586115b2f2c63d907536CDE";
            readonly policyFactory: "0xD42c04179410a38BE95737e663480a7CC42B9C05";
            readonly propertyFactory: "0x8bB6a34afBD34663cEeEFA697918c647Da22a352";
            readonly registry: "0xbeF4DeEA3AE863739Bd402E025c749536f491ffa";
            readonly sTokens: "0x89904De861CDEd2567695271A511B3556659FfA2";
            readonly withdraw: "0x60d1743fc6791aEDB833E4aED604eccb9EC838DE";
        };
        readonly mumbai: {
            readonly token: "0xcbc698ed514dF6e54932a22515d6D0C27E4DA091";
            readonly lockup: "0xfDC5FF1F07871A247eafE14eEB134eeFcbCf1ceA";
            readonly marketFactory: "0x953992D325d8A9Bab35406C2E34c0d5535fa5206";
            readonly metricsFactory: "0x02d107567020bCE1Eb524D80C44f899Fa9993E5f";
            readonly policyFactory: "0x0f85eC41980E86847Ba57eA763E9c5f88f829554";
            readonly propertyFactory: "0xcCB7e1454d66fc3c2053694D323c127D2a4b39BA";
            readonly registry: "0xe2C16936413D74c667aeF0D040c920BF639067d4";
            readonly sTokens: "0xe0af15141ABd0B31Fb15e250971936Fe8837230a";
            readonly withdraw: "0x5f9d9f40f4d7d8A350745D69e94E20339Df17b83";
        };
    };
};

type Positions = {
    readonly property: string;
    readonly amount: string;
    readonly price: string;
    readonly cumulativeReward: string;
    readonly pendingReward: string;
};

type Rewards = {
    readonly entireReward: string;
    readonly cumulativeReward: string;
    readonly withdrawableReward: string;
};

type TokenURI = {
    readonly name: string;
    readonly description: string;
    readonly image: string;
    readonly attributes: readonly [
        {
            readonly trait_type: 'Destination';
            readonly value: string;
        },
        {
            readonly trait_type: 'Locked Amount';
            readonly display_type: 'number';
            readonly value: number;
        },
        {
            readonly trait_type: 'Payload';
            readonly value: string;
        }
    ];
};

type TokenURISimProps = {
    readonly tokenId?: number;
    readonly owner?: string;
    readonly positions?: {
        readonly property?: string;
        readonly amount?: string;
        readonly price?: string;
        readonly cumulativeReward?: string;
        readonly pendingReward?: string;
    };
    readonly rewards?: {
        readonly entireReward?: string;
        readonly cumulativeReward?: string;
        readonly withdrawableReward?: string;
    };
    readonly payload?: string | Uint8Array;
};

type STokensContract = {
    readonly positions: (tokenId: number) => Promise<Positions>;
    readonly isFreezed: (tokenId: number) => Promise<boolean>;
    readonly freezeTokenURI: (tokenId: number, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly setTokenURIImage: (tokenId: number, data: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly setSTokenRoyaltyForProperty: (propertyAddress: string, royalty: number, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly royaltyOf: (propertyAddress: string) => Promise<string>;
    readonly setTokenURIDescriptor: (propertyAddress: string, descriptorAddress: string, payloads?: ReadonlyArray<string | Uint8Array>, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly ownerOf: (tokenId: number) => Promise<string>;
    readonly rewards: (tokenId: number) => Promise<Rewards>;
    readonly tokenURI: (tokenId: number) => Promise<TokenURI>;
    readonly tokenURISim: (props?: TokenURISimProps) => Promise<TokenURI>;
    readonly positionsOfProperty: (propertyAddress: string) => Promise<readonly number[]>;
    readonly positionsOfOwner: (accountAddress: string) => Promise<readonly number[]>;
    readonly contract: () => ethers.Contract;
    readonly payloadOf: (tokenId: number) => Promise<string>;
    readonly descriptorOf: (propertyAddress: string) => Promise<string>;
    readonly descriptorOfPropertyByPayload: (propertyAddress: string, payload: string | Uint8Array) => Promise<string>;
};
declare const createSTokensContract: (provider: ContractRunner) => (address: string) => STokensContract;

type Image = {
    readonly src?: string;
    readonly name?: string;
    readonly description?: string;
    readonly requiredETHAmount?: number | string;
    readonly requiredETHFee?: number | string;
    readonly gateway?: string;
};

type Args = ReadonlyArray<string | boolean | readonly string[] | Uint8Array | readonly Image[] | Positions | Rewards>;
type Overrides = {
    readonly gasLimit?: number;
    readonly from?: string;
    readonly value?: string;
};
type FallbackableOverrides = {
    readonly overrides?: Overrides;
    readonly fallback?: Overrides;
};
type Option = {
    readonly contract: ethers.Contract;
    readonly method: string;
    readonly args?: Args;
    readonly mutation?: boolean;
    readonly padEnd?: number;
    readonly static?: boolean;
    readonly interface?: string;
};
type QueryOption = Option & {
    readonly mutation: false;
};
type MutationOption = Option & {
    readonly mutation: true;
    readonly overrides?: FallbackableOverrides;
};
type ExecuteOption = QueryOption | MutationOption;
type ExecuteFunction = <O extends ExecuteOption = QueryOption, R = string>(opts: O) => Promise<O extends QueryOption ? R : O extends MutationOption ? TransactionResponse : never>;
declare const execute: ExecuteFunction;

type Erc20Contract = {
    readonly totalSupply: () => Promise<string>;
    readonly balanceOf: (address: string) => Promise<string>;
    readonly transfer: (to: string, value: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly allowance: (from: string, to: string) => Promise<string>;
    readonly approve: (to: string, value: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly transferFrom: (from: string, to: string, value: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly name: () => Promise<string>;
    readonly symbol: () => Promise<string>;
    readonly decimals: () => Promise<string>;
};
declare const createErc20Contract: (provider: ContractRunner) => (address: string) => Erc20Contract;

declare const arrayify: <T>(obj: Record<string, T>) => ReadonlyArray<T>;

type DevkitUtils = {
    readonly execute: typeof execute;
    readonly arrayify: typeof arrayify;
};
declare const utils: DevkitUtils;

type CustomOptions = {
    readonly from?: string;
    readonly gasPrice?: string;
    readonly gas: number;
    readonly data: string;
};
type ValidProvider = ContractRunner;

declare const marketAddresses: {
    readonly eth: {
        readonly main: {
            readonly github: "0x34A7AdC94C4D41C3e3469F98033B372cB2fAf318";
            readonly youtube: "0x2AD380927F509A1d6338b89A7286cFAc52a896Dd";
        };
        readonly ropsten: {
            readonly github: "0x1A45BA7BB4a5A4a01Eb5330C9F2fd8af47C16eBe";
        };
    };
    readonly arbitrum: {
        readonly one: {
            readonly github: "0x84b9e407e2Ee76A641b45d007bBFd9e60a13FF7d";
            readonly youtube: "0x61999A2F3f403957315255D08A969602f19F2Dcf";
            readonly discord: "0x0f02e7c1bc8769B56B20E03d2Fe277b42194C260";
        };
        readonly rinkeby: {
            readonly github: "0xeb85170bce4ea8a9ca0fb5b6620ab74ef111a50c";
            readonly youtube: "0x53f8A1DEe0aF272d995aF1e206116172c00f2eb4";
            readonly discord: "0xC3af4341f71EfD7F74523D4cD9eD87F36Ed75A99";
        };
    };
    readonly polygon: {
        readonly mainnet: {
            readonly github: "0xa7d0A25Cb2378c935FF94863C8614367b9e85Ed8";
            readonly youtube: "0xfe607787e14A90A320cdfc05710b382380B4fd12";
            readonly discord: "0x75b2C22E5f1EF64814D574caa9c4506Eba268502";
        };
        readonly mumbai: {
            readonly github: "0x9edc758B0477559AB6556BCA9971B4DD892d8E28";
            readonly youtube: "0x7C7CDc82b195d4dcf9a789BD14CD1C73232025a8";
            readonly discord: "0xb5A7CFb9F495De44e58177990dac004b84e7C501";
        };
    };
};

type CreateMarketContract = {
    readonly schema: () => Promise<readonly string[]>;
    readonly vote: (propertyAddress: string, agree: boolean, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly authenticate: (address: string, args: readonly string[], options: {
        readonly metricsFactoryAddress: string;
    }, overrides?: FallbackableOverrides) => Promise<string>;
    readonly behavior: () => Promise<string>;
    readonly contract: () => ethers.Contract;
};
declare const createMarketContract: (provider: ContractRunner) => (address: string) => CreateMarketContract;

type CreateMarketBehaviorContract = {
    readonly getId: (metricsAddress: string) => Promise<string>;
    readonly getMetrics: (id: string) => Promise<string>;
    readonly contract: () => ethers.Contract;
};
declare const createMarketBehaviorContract: (provider: ContractRunner) => (address: string) => CreateMarketBehaviorContract;

type PropertyContract$1 = {
    readonly totalSupply: () => Promise<string>;
    readonly balanceOf: (address: string) => Promise<string>;
    readonly transfer: (to: string, value: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly allowance: (from: string, to: string) => Promise<string>;
    readonly approve: (to: string, value: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly transferFrom: (from: string, to: string, value: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly name: () => Promise<string>;
    readonly symbol: () => Promise<string>;
    readonly decimals: () => Promise<string>;
    readonly author: () => Promise<string>;
    readonly changeAuthor: (nextAuthor: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly changeName: (nextName: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly changeSymbol: (nextSymbol: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly contract: () => ethers.Contract;
};
type CreatePropertyContract = (provider: ContractRunner) => (address: string) => PropertyContract$1;
declare const createPropertyContract: CreatePropertyContract;

type WaitForEventOptions = {
    readonly metricsFactoryAddress: string;
};

type PropertyFactoryContract$1 = {
    readonly create: (name: string, symbol: string, author: string, overrides?: FallbackableOverrides) => Promise<string>;
    readonly createAndAuthenticate: (name: string, symbol: string, marketAddress: string, args: readonly string[], options: WaitForEventOptions, overrides?: FallbackableOverrides) => Promise<{
        readonly property: string;
        readonly transaction: TransactionResponse;
        readonly waitForAuthentication: () => Promise<string>;
    }>;
    readonly contract: () => ethers.Contract;
};
declare const createPropertyFactoryContract: (provider: ContractRunner) => (address: string) => PropertyFactoryContract$1;

type CreateAllocatorContract = {
    readonly calculateMaxRewardsPerBlock: () => Promise<string>;
    readonly contract: () => ethers.Contract;
};
declare const createAllocatorContract: (provider: ContractRunner) => (address: string) => CreateAllocatorContract;

type LockupContract$1 = {
    readonly getValue: (propertyAddress: string, accountAddress: string) => Promise<string>;
    readonly getAllValue: () => Promise<string>;
    readonly getPropertyValue: (address: string) => Promise<string>;
    readonly withdrawByPosition: (positionTokenId: string, amount: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly withdraw: (propertyAddress: string, amount: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly calculateWithdrawableInterestAmountByPosition: (positionTokenId: string) => Promise<string>;
    readonly calculateWithdrawableInterestAmount: (propertyAddress: string, accountAddress: string) => Promise<string>;
    readonly calculateCumulativeHoldersRewardAmount: (propertyAddress: string) => Promise<string>;
    readonly getStorageWithdrawalStatus: (propertyAddress: string, accountAddress: string) => Promise<string>;
    readonly calculateCumulativeRewardPrices: () => Promise<readonly [string, string, string, string]>;
    readonly calculateRewardAmount: (propertyAddress: string) => Promise<readonly [string, string]>;
    readonly cap: () => Promise<string>;
    readonly depositToProperty: (propertyAddress: string, amount: string, payload?: string | Uint8Array, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly depositToPosition: (positionTokenId: string, amount: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly migrateToSTokens: (positionTokenId: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly contract: () => ethers.Contract;
};
declare const createLockupContract: (provider: ContractRunner) => (address: string) => LockupContract$1;

type DevContract$1 = {
    readonly totalSupply: () => Promise<string>;
    readonly balanceOf: (address: string) => Promise<string>;
    readonly transfer: (to: string, value: string) => Promise<TransactionResponse>;
    readonly allowance: (from: string, to: string) => Promise<string>;
    readonly approve: (to: string, value: string) => Promise<TransactionResponse>;
    readonly transferFrom: (from: string, to: string, value: string) => Promise<TransactionResponse>;
    readonly name: () => Promise<string>;
    readonly symbol: () => Promise<string>;
    readonly decimals: () => Promise<string>;
    readonly deposit: (to: string, value: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly contract: () => ethers.Contract;
};
declare const createDevContract: (provider: ContractRunner) => (address: string) => DevContract$1;

type WithdrawContract = {
    readonly withdraw: (propertyAddress: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly bulkWithdraw: (propertyAddresses: readonly string[]) => Promise<TransactionResponse>;
    readonly getRewardsAmount: (propertyAddress: string) => Promise<string>;
    readonly calculateWithdrawableAmount: (propertyAddress: string, accountAddress: string) => Promise<string>;
    readonly calculateRewardAmount: (propertyAddress: string, accountAddress: string) => Promise<string>;
    readonly contract: () => ethers.Contract;
};
declare const createWithdrawContract: (provider: ContractRunner) => (address: string) => WithdrawContract;

type RegistryContract$1 = {
    readonly allocator: () => Promise<string>;
    readonly allocatorStorage: () => Promise<string>;
    readonly lockup: () => Promise<string>;
    readonly lockupStorage: () => Promise<string>;
    readonly marketFactory: () => Promise<string>;
    readonly marketGroup: () => Promise<string>;
    readonly metricsFactory: () => Promise<string>;
    readonly metricsGroup: () => Promise<string>;
    readonly policy: () => Promise<string>;
    readonly policyFactory: () => Promise<string>;
    readonly policySet: () => Promise<string>;
    readonly policyGroup: () => Promise<string>;
    readonly propertyFactory: () => Promise<string>;
    readonly propertyGroup: () => Promise<string>;
    readonly token: () => Promise<string>;
    readonly withdraw: () => Promise<string>;
    readonly withdrawStorage: () => Promise<string>;
    readonly contract: () => ethers.Contract;
};
type CreateRegistryContract = (provider: ContractRunner) => (address: string) => RegistryContract$1;
declare const createRegistryContract: CreateRegistryContract;

type PolicyContract$1 = {
    readonly holdersShare: (amount: string, lockups: string) => Promise<string>;
    readonly rewards: (lockups: string, assets: string) => Promise<string>;
    readonly authenticationFee: (assets: string, propertyAssets: string) => Promise<string>;
    readonly marketVotingBlocks: () => Promise<string>;
    readonly policyVotingBlocks: () => Promise<string>;
    readonly shareOfTreasury: (supply: string) => Promise<string>;
    readonly treasury: () => Promise<string>;
    readonly capSetter: () => Promise<string>;
    readonly contract: () => ethers.Contract;
};
declare const createPolicyContract: (provider: ContractRunner) => (address: string) => PolicyContract$1;

type PolicyGroupContract = {
    readonly isGroup: (policyAddress: string) => Promise<boolean>;
    readonly isDuringVotingPeriod: (policyAddress: string) => Promise<boolean>;
    readonly contract: () => ethers.Contract;
};
type CreatePolicyGroupContract = (provider: ContractRunner) => (address: string) => PolicyGroupContract;
declare const createPolicyGroupContract: CreatePolicyGroupContract;

type CreateMetricsContract = {
    readonly property: () => Promise<string>;
    readonly market: () => Promise<string>;
    readonly contract: () => ethers.Contract;
};
declare const createMetricsContract: (provider: ContractRunner) => (address: string) => CreateMetricsContract;

type PolicyFactoryContract = {
    readonly create: (newPolicyAddress: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly forceAttach: (policy: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly contract: () => ethers.Contract;
};
type CreatePolicyFactoryContract = (provider: ContractRunner) => (address: string) => PolicyFactoryContract;
declare const createPolicyFactoryContract: CreatePolicyFactoryContract;

type CreateMetricsGroupContract = {
    readonly totalAuthenticatedProperties: () => Promise<string>;
    readonly totalIssuedMetrics: () => Promise<string>;
    readonly contract: () => ethers.Contract;
};
declare const createMetricsGroupContract: (provider: ContractRunner) => (address: string) => CreateMetricsGroupContract;

declare const createSimpleCollectionsContract: (provider: ContractRunner) => (address: string) => {
    image: (id: number, address: string, stakingPositions: Positions, rewards: Rewards, keys: readonly string[]) => Promise<string>;
    name: (id: number, address: string, stakingPositions: Positions, rewards: Rewards, keys: readonly string[]) => Promise<string>;
    description: (id: number, address: string, stakingPositions: Positions, rewards: Rewards, keys: readonly string[]) => Promise<string>;
    setImages: (propertyAddress: string, images: readonly Image[], keys: readonly string[], overrides?: FallbackableOverrides) => Promise<ethers.TransactionResponse>;
    removeImage: (propertyAddress: string, keys: readonly string[], overrides?: FallbackableOverrides) => Promise<ethers.TransactionResponse>;
};

type DevkitContract = {
    readonly allocator: ReturnType<typeof createAllocatorContract>;
    readonly market: ReturnType<typeof createMarketContract>;
    readonly marketBehavior: ReturnType<typeof createMarketBehaviorContract>;
    readonly property: ReturnType<typeof createPropertyContract>;
    readonly propertyFactory: ReturnType<typeof createPropertyFactoryContract>;
    readonly lockup: ReturnType<typeof createLockupContract>;
    readonly withdraw: ReturnType<typeof createWithdrawContract>;
    readonly dev: ReturnType<typeof createDevContract>;
    readonly registry: ReturnType<typeof createRegistryContract>;
    readonly policy: ReturnType<typeof createPolicyContract>;
    readonly policyGroup: ReturnType<typeof createPolicyGroupContract>;
    readonly metrics: ReturnType<typeof createMetricsContract>;
    readonly metricsGroup: ReturnType<typeof createMetricsGroupContract>;
    readonly policyFactory: ReturnType<typeof createPolicyFactoryContract>;
    readonly sTokens: ReturnType<typeof createSTokensContract>;
    readonly simpleCollections: ReturnType<typeof createSimpleCollectionsContract>;
};
type ContractFactory = (ethersProvider: ContractRunner) => DevkitContract;
type CreateDevkitContract = (provider: ContractRunner) => DevkitContract;
declare const createDevkitContract: CreateDevkitContract;
declare const contractFactory: ContractFactory;

type CreateDetectSTokens = (sTokens: STokensContract) => (propertyAddress: string, accountAddress: string) => Promise<readonly number[]>;
declare const createDetectSTokens: CreateDetectSTokens;

type DevkitClient = {
    readonly createDetectSTokens: typeof createDetectSTokens;
};
declare const client: DevkitClient;

type MarketFactoryContract$1 = {
    readonly create: (marketBehaviorAddress: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly contract: () => ethers.Contract;
};
declare const createMarketFactoryContract: (provider: ContractRunner) => (address: string) => MarketFactoryContract$1;

declare const erc20Abi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    stateMutability: string;
    type: string;
    anonymous?: undefined;
    name?: undefined;
    outputs?: undefined;
} | {
    anonymous: boolean;
    inputs: {
        indexed: boolean;
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
    stateMutability?: undefined;
    outputs?: undefined;
} | {
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const allocatorAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    constant?: undefined;
    name?: undefined;
    outputs?: undefined;
} | {
    constant: boolean;
    inputs: never[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
} | {
    constant: boolean;
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: never[];
    payable: boolean;
    stateMutability: string;
    type: string;
})[];

declare const devAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
    name?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    anonymous: boolean;
    inputs: {
        indexed: boolean;
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
    payable?: undefined;
    stateMutability?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    constant: boolean;
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const lockupAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
    name?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    anonymous: boolean;
    inputs: {
        indexed: boolean;
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
    payable?: undefined;
    stateMutability?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    constant: boolean;
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const marketAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    constant?: undefined;
    name?: undefined;
    outputs?: undefined;
} | {
    constant: boolean;
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
})[];

declare const marketBehaviorAbi: {
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    stateMutability: string;
    type: string;
}[];

declare const marketFactoryAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
    name?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    anonymous: boolean;
    inputs: {
        indexed: boolean;
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
    payable?: undefined;
    stateMutability?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    constant: boolean;
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const metricsAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    constant?: undefined;
    name?: undefined;
    outputs?: undefined;
} | {
    constant: boolean;
    inputs: never[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
})[];

declare const metricsFactoryAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
    name?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    anonymous: boolean;
    inputs: {
        indexed: boolean;
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
    payable?: undefined;
    stateMutability?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    constant: boolean;
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const metricsGroupAbi: {
    constant: boolean;
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
}[];

declare const policyAbi: {
    constant: boolean;
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
}[];

declare const policyFactoryAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
    name?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    anonymous: boolean;
    inputs: {
        indexed: boolean;
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
    payable?: undefined;
    stateMutability?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    constant: boolean;
    inputs: never[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
} | {
    constant: boolean;
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: never[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const policyGroupAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
    name?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    anonymous: boolean;
    inputs: {
        indexed: boolean;
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
    payable?: undefined;
    stateMutability?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    constant: boolean;
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const propertyAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    stateMutability: string;
    type: string;
    anonymous?: undefined;
    name?: undefined;
    outputs?: undefined;
} | {
    anonymous: boolean;
    inputs: {
        indexed: boolean;
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
    stateMutability?: undefined;
    outputs?: undefined;
} | {
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const propertyFactoryAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
    name?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    anonymous: boolean;
    inputs: {
        indexed: boolean;
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
    payable?: undefined;
    stateMutability?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    constant: boolean;
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const addressConfigAbi: ({
    anonymous: boolean;
    inputs: {
        indexed: boolean;
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
    constant?: undefined;
    outputs?: undefined;
    payable?: undefined;
    stateMutability?: undefined;
} | {
    constant: boolean;
    inputs: never[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
} | {
    constant: boolean;
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: never[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const sTokensAbi: ({
    anonymous: boolean;
    inputs: {
        indexed: boolean;
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
    outputs?: undefined;
    stateMutability?: undefined;
    constant?: undefined;
} | {
    inputs: ({
        internalType: string;
        name: string;
        type: string;
        components?: undefined;
    } | {
        components: {
            internalType: string;
            name: string;
            type: string;
        }[];
        internalType: string;
        name: string;
        type: string;
    })[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    stateMutability: string;
    type: string;
    constant: boolean;
    anonymous?: undefined;
} | {
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    stateMutability: string;
    type: string;
    anonymous?: undefined;
    constant?: undefined;
} | {
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        components: {
            internalType: string;
            name: string;
            type: string;
        }[];
        internalType: string;
        name: string;
        type: string;
    }[];
    stateMutability: string;
    type: string;
    constant: boolean;
    anonymous?: undefined;
})[];

declare const simpleCollectionsAbi: ({
    anonymous: boolean;
    inputs: {
        indexed: boolean;
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
    outputs?: undefined;
    stateMutability?: undefined;
} | {
    inputs: ({
        internalType: string;
        name: string;
        type: string;
        components?: undefined;
    } | {
        components: {
            internalType: string;
            name: string;
            type: string;
        }[];
        internalType: string;
        name: string;
        type: string;
    })[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const withdrawAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
    name?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    anonymous: boolean;
    inputs: {
        indexed: boolean;
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
    payable?: undefined;
    stateMutability?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    constant: boolean;
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

type ApproveIfNeededResultForApproveIsNeeded = {
    readonly approvalNeeded: true;
    readonly approveIfNeeded: (options?: {
        readonly amount?: string;
        readonly overrides?: FallbackableOverrides;
    }) => Promise<TransactionResponse & {
        readonly waitNeeded: true;
        readonly waitOrSkipApproval: () => Promise<(TransactionReceipt | null) & {
            readonly run: () => Promise<TransactionResponse>;
        }>;
    }>;
};
type ApproveIfNeededResultForApproveIsNotNeeded = {
    readonly approvalNeeded: false;
    readonly approveIfNeeded: (options?: {
        readonly amount?: string;
        readonly overrides?: FallbackableOverrides;
    }) => Promise<{
        readonly waitNeeded: false;
        readonly waitOrSkipApproval: () => Promise<{
            readonly run: () => Promise<TransactionResponse>;
        }>;
    }>;
};
type ApproveIfNeededResult = ApproveIfNeededResultForApproveIsNeeded | ApproveIfNeededResultForApproveIsNotNeeded;
type ApproveIfNeeded = (factoryOptions: {
    readonly provider: ContractRunner;
    readonly requiredAmount: string;
    readonly from: string;
    readonly to?: string;
    readonly token?: string;
    readonly callback: (receipt?: TransactionReceipt | null) => Promise<TransactionResponse>;
}) => Promise<UndefinedOr<ApproveIfNeededResult>>;
declare const approveIfNeeded: ApproveIfNeeded;

type PositionsCreate = (options: {
    readonly provider: ContractRunner;
    readonly from: string;
    readonly destination: string;
    readonly amount: string;
    readonly payload?: string | Uint8Array;
    readonly overrides?: FallbackableOverrides;
}) => Promise<UndefinedOr<ApproveIfNeededResult>>;
declare const positionsCreate: PositionsCreate;

type PositionsCreateWithEth = (options: {
    readonly provider: ContractRunner;
    readonly ethAmount?: string;
    readonly devAmount?: string;
    readonly destination: string;
    readonly deadline?: number;
    readonly gatewayAddress?: string;
    readonly gatewayBasisPoints?: number;
    readonly payload?: string | Uint8Array;
    readonly overrides?: FallbackableOverrides;
}) => Promise<{
    readonly estimatedDev: string;
    readonly estimatedEth: string;
    readonly create: () => Promise<TransactionResponse>;
}>;
declare const positionsCreateWithEth: PositionsCreateWithEth;

type PositionsCreateWithEthForPolygon = (options: {
    readonly provider: ContractRunner;
    readonly ethAmount?: string;
    readonly devAmount?: string;
    readonly destination: string;
    readonly from?: string;
    readonly overrides?: FallbackableOverrides;
    readonly payload?: string | Uint8Array;
    readonly deadline?: number;
    readonly gatewayAddress?: string;
    readonly gatewayBasisPoints?: number;
}) => Promise<{
    readonly estimatedDev: string;
    readonly estimatedEth: string;
    readonly create: () => Promise<UndefinedOr<ApproveIfNeededResult>>;
}>;
declare const positionsCreateWithEthForPolygon: PositionsCreateWithEthForPolygon;

type Params = {
    readonly provider: ContractRunner;
    readonly mintTo: string;
    readonly destination: string;
    readonly path: readonly (string | bigint)[];
    readonly token?: string;
    readonly tokenAmount?: string;
    readonly devAmount?: string;
    readonly devAmountOut?: string;
    readonly from?: string;
    readonly overrides?: FallbackableOverrides;
    readonly payload?: string | Uint8Array;
    readonly deadline?: number;
    readonly gatewayAddress?: string;
    readonly gatewayBasisPoints?: number;
};
type ParamsWithToken = Omit<Params, 'token'> & {
    readonly token: string;
};
type ReturnOfPositionsCreateWithAnyTokensERC20 = Promise<UndefinedOr<{
    readonly estimatedDev: string;
    readonly estimatedTokens: string;
    readonly create: () => Promise<ApproveIfNeededResult>;
}>>;
type ReturnOfPositionsCreateWithAnyTokensNative = Promise<UndefinedOr<{
    readonly estimatedDev: string;
    readonly estimatedTokens: string;
    readonly create: () => Promise<ApproveIfNeededResultForApproveIsNotNeeded>;
}>>;
declare function positionsCreateWithAnyTokens(opts: ParamsWithToken): ReturnOfPositionsCreateWithAnyTokensERC20;
declare function positionsCreateWithAnyTokens(opts: Params): ReturnOfPositionsCreateWithAnyTokensNative;

type EstimationsAPY = (options: {
    readonly provider: ContractRunner;
}) => Promise<readonly [UndefinedOr<number>, UndefinedOr<number>]>;
declare const estimationsAPY: EstimationsAPY;

type Asset = {
    readonly market: string;
    readonly marketSlug?: string;
    readonly id: string;
};
type PropertiesAssets = (options: {
    readonly provider: ContractRunner;
    readonly destination: string;
}) => Promise<UndefinedOr<readonly Asset[]>>;
declare const propertiesAssets: PropertiesAssets;

type DevContract = Erc20Contract;

type Results$a = readonly [UndefinedOr<DevContract$1>, UndefinedOr<DevContract>];
declare const clientsDev: (provider: ContractRunner) => Promise<Results$a>;

type LockedupProperty = Readonly<{
    readonly property: string;
    readonly value: string;
}>;

type LockupContract = {
    readonly withdrawByPosition: (positionTokenId: string, amount: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly calculateWithdrawableInterestAmountByPosition: (positionTokenId: string) => Promise<string>;
    readonly calculateCumulativeHoldersRewardAmount: (propertyAddress: string) => Promise<string>;
    readonly calculateCumulativeRewardPrices: () => Promise<readonly [string, string, string, string]>;
    readonly calculateRewardAmount: (propertyAddress: string) => Promise<readonly [string, string]>;
    readonly cap: () => Promise<string>;
    readonly depositToProperty: (propertyAddress: string, amount: string, payload?: string | Uint8Array, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly depositToPosition: (positionTokenId: string, amount: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly totalLocked: () => Promise<string>;
    readonly totalLockedForProperty: (address: string) => Promise<string>;
    readonly getLockedupProperties: () => Promise<readonly LockedupProperty[]>;
    readonly contract: () => ethers.Contract;
};

type Results$9 = readonly [
    UndefinedOr<LockupContract$1>,
    UndefinedOr<LockupContract>
];
declare const clientsLockup: (provider: ContractRunner) => Promise<Results$9>;

type MarketFactoryContract = {
    readonly create: (marketBehaviorAddress: string) => Promise<TransactionResponse>;
    readonly getEnabledMarkets: () => Promise<readonly string[]>;
    readonly contract: () => ethers.Contract;
};

type Results$8 = readonly [
    UndefinedOr<MarketFactoryContract$1>,
    UndefinedOr<MarketFactoryContract>
];
declare const clientsMarketFactory: (provider: ContractRunner) => Promise<Results$8>;

type MetricsFactoryContract = {
    readonly authenticatedPropertiesCount: () => Promise<string>;
    readonly metricsCount: () => Promise<number>;
    readonly metricsOfProperty: (propertyAddress: string) => Promise<readonly string[]>;
    readonly contract: () => ethers.Contract;
};

type Results$7 = readonly [undefined, UndefinedOr<MetricsFactoryContract>];
declare const clientsMetricsFactory: (provider: ContractRunner) => Promise<Results$7>;

type PropertyBalance = Readonly<{
    readonly account: string;
    readonly balance: string;
}>;

type PropertyContract = {
    readonly totalSupply: () => Promise<string>;
    readonly balanceOf: (address: string) => Promise<string>;
    readonly transfer: (to: string, value: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly allowance: (from: string, to: string) => Promise<string>;
    readonly approve: (to: string, value: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly transferFrom: (from: string, to: string, value: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly name: () => Promise<string>;
    readonly symbol: () => Promise<string>;
    readonly decimals: () => Promise<string>;
    readonly author: () => Promise<string>;
    readonly changeName: (nextName: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly changeSymbol: (nextSymbol: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly getBalances: () => Promise<readonly PropertyBalance[]>;
    readonly contract: () => ethers.Contract;
};

type Results$6 = readonly [
    UndefinedOr<PropertyContract$1>,
    UndefinedOr<PropertyContract>
];
declare const clientsProperty: (provider: ContractRunner, tokenAddress: string) => Promise<Results$6>;

type PropertyFactoryContract = {
    readonly create: (name: string, symbol: string, author: string, overrides?: FallbackableOverrides) => Promise<string>;
    readonly createAndAuthenticate: (name: string, symbol: string, marketAddress: string, args: readonly string[], options: WaitForEventOptions, overrides?: FallbackableOverrides) => Promise<{
        readonly property: string;
        readonly transaction: TransactionResponse;
        readonly waitForAuthentication: () => Promise<string>;
    }>;
    readonly getPropertiesOfAuthor: (author: string) => Promise<readonly string[]>;
    readonly contract: () => ethers.Contract;
};

type Results$5 = readonly [
    UndefinedOr<PropertyFactoryContract$1>,
    UndefinedOr<PropertyFactoryContract>
];
declare const clientsPropertyFactory: (provider: ContractRunner) => Promise<Results$5>;

type RegistryContract = {
    readonly registries: (key: string) => Promise<string>;
    readonly contract: () => ethers.Contract;
};

type Results$4 = readonly [
    UndefinedOr<RegistryContract$1>,
    UndefinedOr<RegistryContract>
];
declare const clientsRegistry: (provider: ContractRunner) => Promise<Results$4>;

type PolicyContract = {
    readonly holdersShare: (amount: string, lockups: string) => Promise<string>;
    readonly rewards: (lockups: string, assets: string) => Promise<string>;
    readonly authenticationFee: (assets: string, propertyAssets: string) => Promise<string>;
    readonly marketVotingSeconds: () => Promise<string>;
    readonly policyVotingSeconds: () => Promise<string>;
    readonly shareOfTreasury: (supply: string) => Promise<string>;
    readonly contract: () => ethers.Contract;
};

type Results$3 = readonly [
    UndefinedOr<PolicyContract$1>,
    UndefinedOr<PolicyContract>
];
declare const clientsPolicy: (provider: ContractRunner) => Promise<Results$3>;

type Results$2 = readonly [
    UndefinedOr<STokensContract>,
    UndefinedOr<STokensContract>
];
declare const clientsSTokens: (provider: ContractRunner) => Promise<Results$2>;

type SwapContract = {
    readonly getEstimatedDevForEth: (ethAmount: string) => Promise<string>;
    readonly getEstimatedEthForDev: (devAmount: string) => Promise<string>;
    readonly swapEthAndStakeDevCaller: (propertyAddress: string, deadline: number, payload: string | Uint8Array, overrides: FallbackableOverrides, gatewayAddress?: string, gatewayBasisPoints?: string) => Promise<TransactionResponse>;
    readonly swapEthAndStakeDevPolygonCaller: (propertyAddress: string, amount: string, deadline: number, payload: string | Uint8Array, overrides: FallbackableOverrides, gatewayAddress?: string, gatewayBasisPoints?: string) => Promise<TransactionResponse>;
    readonly contract: () => ethers.Contract;
};

type Results$1 = readonly [
    undefined,
    UndefinedOr<SwapContract>,
    UndefinedOr<string>
];
declare const clientsUtilsSwapForStake: (provider: ContractRunner) => Promise<Results$1>;

type SwapArbitraryTokensContract = {
    readonly getEstimatedDevForTokens: (path: readonly (string | bigint)[], tokenAmount: string) => Promise<string>;
    readonly getEstimatedTokensForDev: (path: readonly (string | bigint)[], devAmount: string) => Promise<string>;
    readonly swapTokensAndStakeDev: (to: string, path: readonly (string | bigint)[], propertyAddress: string, amountOut: string, deadline: number, amount: string, payload?: string | Uint8Array, token?: string, gatewayAddress?: string, gatewayBasisPoints?: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly contract: () => ethers.Contract;
};

type Results = readonly [undefined, UndefinedOr<SwapArbitraryTokensContract>];
declare const clientsUtilsSwapTokensForStake: (provider: ContractRunner) => Promise<Results>;

declare const agentAddresses: {
    readonly eth: {
        readonly main: {
            readonly swap: {
                readonly v2: "0x6400264F991de614048838a7d4B536733BCE3069";
                readonly v3: undefined;
            };
        };
    };
    readonly arbitrum: {
        readonly one: {
            readonly swap: {
                readonly v2: undefined;
                readonly v3: "0x60Ca7E3960e5F143DdB42B19B64F65c27cAD561d";
            };
        };
        readonly rinkeby: {
            readonly swap: {
                readonly v2: undefined;
                readonly v3: "0x4cd6B431B7A242D51B4D96aE5839a8b8f060F7A9";
            };
        };
    };
    readonly polygon: {
        readonly mainnet: {
            readonly swap: {
                readonly v2: undefined;
                readonly v3: "0x9265Cf9e6Dc5B163bDB75d51661Ca8EA3b6150c4";
            };
            readonly swapArbitraryTokens: {
                readonly swap: "0xad7CaC908DfF8Dcd1D0d8d0FE3edD25bf339EB57";
            };
            readonly usdc: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
            readonly weth: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
        };
        readonly mumbai: {
            readonly swap: {
                readonly v2: undefined;
                readonly v3: "0x60650E5a95864b989C8b7B0357a2d4979a34c6AF";
            };
            readonly swapArbitraryTokens: {
                readonly swap: "0x927B51D9Edd43BFDE3586E99BfaCBE08135374AA";
            };
            readonly usdc: "0xFEca406dA9727A25E71e732F9961F680059eF1F9";
            readonly weth: "0x3c8d6A6420C922c88577352983aFFdf7b0F977cA";
        };
    };
};

export { type ApproveIfNeeded, type ApproveIfNeededResult, type ApproveIfNeededResultForApproveIsNeeded, type ApproveIfNeededResultForApproveIsNotNeeded, type ContractFactory, type CreateAllocatorContract, type CreateDevkitContract, type CreateMarketBehaviorContract, type CreateMarketContract, type CreateMetricsContract, type CreateMetricsGroupContract, type CreatePolicyFactoryContract, type CreatePolicyGroupContract, type CreatePropertyContract, type CreateRegistryContract, type CustomOptions, type DevContract$1 as DevContract, type DevkitClient, type DevkitContract, type DevkitUtils, type Erc20Contract, type Image, type LockupContract$1 as LockupContract, type MarketFactoryContract$1 as MarketFactoryContract, type PolicyContract$1 as PolicyContract, type PolicyFactoryContract, type PolicyGroupContract, type Positions, type PropertyContract$1 as PropertyContract, type PropertyFactoryContract$1 as PropertyFactoryContract, type RegistryContract$1 as RegistryContract, type ReturnOfPositionsCreateWithAnyTokensERC20, type ReturnOfPositionsCreateWithAnyTokensNative, type STokensContract, type ValidProvider, type WithdrawContract, addressConfigAbi, addresses, agentAddresses, allocatorAbi, approveIfNeeded, arrayify, client, clientsDev, clientsLockup, clientsMarketFactory, clientsMetricsFactory, clientsPolicy, clientsProperty, clientsPropertyFactory, clientsRegistry, clientsSTokens, clientsUtilsSwapForStake, clientsUtilsSwapTokensForStake as clientsUtilsSwapUsdcForStake, contractFactory, createAllocatorContract, createDetectSTokens, createDevContract, createDevkitContract, createErc20Contract, createLockupContract, createMarketBehaviorContract, createMarketContract, createMarketFactoryContract, createMetricsContract, createMetricsGroupContract, createPolicyContract, createPolicyFactoryContract, createPolicyGroupContract, createPropertyContract, createPropertyFactoryContract, createRegistryContract, createSTokensContract, createSimpleCollectionsContract, createWithdrawContract, devAbi, erc20Abi, estimationsAPY, execute, lockupAbi, marketAbi, marketAddresses, marketBehaviorAbi, marketFactoryAbi, metricsAbi, metricsFactoryAbi, metricsGroupAbi, policyAbi, policyFactoryAbi, policyGroupAbi, positionsCreate, positionsCreateWithAnyTokens, positionsCreateWithEth, positionsCreateWithEthForPolygon, propertiesAssets, propertyAbi, propertyFactoryAbi, sTokensAbi, simpleCollectionsAbi, utils, withdrawAbi };