import * as ethers from 'ethers';
import { TransactionResponse, ethers as ethers$1, ContractRunner } from 'ethers';

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$1.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 Overrides = {
    readonly gasLimit?: number;
    readonly from?: string;
    readonly value?: string;
};
type FallbackableOverrides = {
    readonly overrides?: Overrides;
    readonly fallback?: Overrides;
};

type MarketContract = {
    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 name: () => Promise<string>;
    readonly getAuthenticatedProperties: () => Promise<readonly string[]>;
    readonly contract: () => ethers$1.Contract;
};
declare const createMarketContract: (provider: ContractRunner) => (address: string) => MarketContract;

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

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$1.Contract;
};
type CreatePropertyContract = (provider: ContractRunner) => (address: string) => PropertyContract;
declare const createPropertyContract: CreatePropertyContract;

type WaitForEventOptions = {
    readonly metricsFactoryAddress: string;
};

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$1.Contract;
};
declare const createPropertyFactoryContract: (provider: ContractRunner) => (address: string) => PropertyFactoryContract;

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$1.Contract;
};
declare const createLockupContract: (provider: ContractRunner) => (address: string) => LockupContract;

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 createDevContract: (provider: ethers.ContractRunner) => (address: string) => Erc20Contract;
type DevContract = Erc20Contract;

type HolderRewards = {
    readonly amount: string;
    readonly price: string;
    readonly cap: string;
    readonly allReward: string;
};

type TransferHistory = {
    readonly to: string;
    readonly from: string;
    readonly amount: string;
    readonly preBalanceOfRecipient: string;
    readonly preBalanceOfSender: string;
    readonly filled: boolean;
    readonly blockNumber: string;
};

type WithdrawContract = {
    readonly withdraw: (propertyAddress: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly calculateRewardAmount: (propertyAddress: string, accountAddress: string) => Promise<HolderRewards>;
    readonly transferHistory: (propertyAddress: string, index: number | string) => Promise<TransferHistory>;
    readonly transferHistoryLength: (propertyAddress: string) => Promise<string>;
    readonly transferHistoryLengthOfRecipient: (propertyAddress: string, recipient: string) => Promise<string>;
    readonly transferHistoryLengthOfSender: (propertyAddress: string, sender: string) => Promise<string>;
    readonly transferHistoryOfRecipientByIndex: (propertyAddress: string, recipient: string, index: number | string) => Promise<string>;
    readonly transferHistoryOfSenderByIndex: (propertyAddress: string, sender: string, index: number | string) => Promise<string>;
    readonly contract: () => ethers$1.Contract;
};
declare const createWithdrawContract: (provider: ContractRunner) => (address: string) => WithdrawContract;

type RegistryContract = {
    readonly registries: (key: string) => Promise<string>;
    readonly contract: () => ethers$1.Contract;
};
type CreateRegistryContract = (provider: ContractRunner) => (address: string) => RegistryContract;
declare const createRegistryContract: CreateRegistryContract;

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$1.Contract;
};
declare const createPolicyContract: (provider: ContractRunner) => (address: string) => PolicyContract;

type CreateMetricsContract = {
    readonly property: () => Promise<string>;
    readonly market: () => Promise<string>;
    readonly contract: () => ethers$1.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$1.Contract;
};
type CreatePolicyFactoryContract = (provider: ContractRunner) => (address: string) => PolicyFactoryContract;
declare const createPolicyFactoryContract: CreatePolicyFactoryContract;

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

type MetricsFactoryContract = {
    readonly authenticatedPropertiesCount: () => Promise<string>;
    readonly metricsCount: () => Promise<number>;
    readonly metricsOfProperty: (propertyAddress: string) => Promise<readonly string[]>;
    readonly contract: () => ethers$1.Contract;
};
declare const createMetricsFactoryContract: (provider: ContractRunner) => (address: string) => MetricsFactoryContract;

type DevkitContract = {
    readonly market: ReturnType<typeof createMarketContract>;
    readonly marketBehavior: ReturnType<typeof createMarketBehaviorContract>;
    readonly marketFactory: ReturnType<typeof createMarketFactoryContract>;
    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 metrics: ReturnType<typeof createMetricsContract>;
    readonly metricsFactory: ReturnType<typeof createMetricsFactoryContract>;
    readonly policyFactory: ReturnType<typeof createPolicyFactoryContract>;
    readonly sTokens: ReturnType<typeof createSTokensContract>;
};
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;

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 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 lockupAbi: ({
    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;
    }[];
    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: never[];
    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 marketAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    stateMutability: string;
    type: string;
    name?: undefined;
    outputs?: undefined;
} | {
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    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: ({
    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;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    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: ({
    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;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const policyAbi: ({
    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 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 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;
} | {
    inputs: never[];
    name: string;
    outputs: {
        components: {
            internalType: string;
            name: string;
            type: string;
        }[];
        internalType: string;
        name: string;
        type: string;
    }[];
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const propertyFactoryAbi: ({
    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;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const addressRegistryAbi: ({
    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;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    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 withdrawAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    stateMutability: string;
    type: string;
    constant: boolean;
} | {
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: never[];
    stateMutability: string;
    type: string;
    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;
})[];

export { type ContractFactory, type CreateDevkitContract, type CreatePropertyContract, type CreateRegistryContract, type DevContract, type DevkitClient, type DevkitContract, type Erc20Contract, type HolderRewards, type LockupContract, type MarketContract, type MarketFactoryContract, type MetricsFactoryContract, type PolicyContract, type PolicyFactoryContract, type Positions, type PropertyContract, type PropertyFactoryContract, type RegistryContract, type STokensContract, type TransferHistory, type WithdrawContract, addressRegistryAbi, client, contractFactory, createDetectSTokens, createDevContract, createDevkitContract, createErc20Contract, createLockupContract, createMarketBehaviorContract, createMarketContract, createMarketFactoryContract, createMetricsContract, createMetricsFactoryContract, createPolicyContract, createPolicyFactoryContract, createPropertyContract, createPropertyFactoryContract, createRegistryContract, createSTokensContract, createWithdrawContract, devAbi, erc20Abi, lockupAbi, marketAbi, marketBehaviorAbi, marketFactoryAbi, metricsAbi, metricsFactoryAbi, policyAbi, policyFactoryAbi, propertyAbi, propertyFactoryAbi, sTokensAbi, withdrawAbi };