import { UndefinedOr } from '@devprotocol/util-ts';
import { TransactionResponse, ethers, TransactionReceipt, 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.Contract;
    readonly payloadOf: (tokenId: number) => Promise<string>;
    readonly descriptorOf: (propertyAddress: string) => Promise<string>;
    readonly descriptorOfPropertyByPayload: (propertyAddress: string, payload: string | Uint8Array) => Promise<string>;
};

type Overrides = {
    readonly gasLimit?: number;
    readonly from?: string;
    readonly value?: string;
};
type FallbackableOverrides = {
    readonly overrides?: Overrides;
    readonly fallback?: Overrides;
};

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$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;
};

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>;
};

type DevContract = Erc20Contract;

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

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;
};

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$1 = {
    readonly create: (marketBehaviorAddress: string, overrides?: FallbackableOverrides) => Promise<TransactionResponse>;
    readonly contract: () => ethers.Contract;
};

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 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 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 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;
};

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$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 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$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;
};

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 ReturnOfPositionsCreateWithAnyTokensERC20, type ReturnOfPositionsCreateWithAnyTokensNative, agentAddresses, approveIfNeeded, clientsDev, clientsLockup, clientsMarketFactory, clientsMetricsFactory, clientsPolicy, clientsProperty, clientsPropertyFactory, clientsRegistry, clientsSTokens, clientsUtilsSwapForStake, clientsUtilsSwapTokensForStake as clientsUtilsSwapUsdcForStake, estimationsAPY, positionsCreate, positionsCreateWithAnyTokens, positionsCreateWithEth, positionsCreateWithEthForPolygon, propertiesAssets };