@imtbl/sdk 0.0.1-alpha.3 → 0.1.0-alpha

package/dist/{starkex.d.ts → immutablex_client.d.ts}

@@ -1,3 +1,244 @@
+declare type Bytes = ArrayLike<number>;
+declare type BytesLike = Bytes | string;
+interface Hexable {
+    toHexString(): string;
+}
+
+declare type BigNumberish = BigNumber | Bytes | bigint | string | number;
+declare class BigNumber implements Hexable {
+    readonly _hex: string;
+    readonly _isBigNumber: boolean;
+    constructor(constructorGuard: any, hex: string);
+    fromTwos(value: number): BigNumber;
+    toTwos(value: number): BigNumber;
+    abs(): BigNumber;
+    add(other: BigNumberish): BigNumber;
+    sub(other: BigNumberish): BigNumber;
+    div(other: BigNumberish): BigNumber;
+    mul(other: BigNumberish): BigNumber;
+    mod(other: BigNumberish): BigNumber;
+    pow(other: BigNumberish): BigNumber;
+    and(other: BigNumberish): BigNumber;
+    or(other: BigNumberish): BigNumber;
+    xor(other: BigNumberish): BigNumber;
+    mask(value: number): BigNumber;
+    shl(value: number): BigNumber;
+    shr(value: number): BigNumber;
+    eq(other: BigNumberish): boolean;
+    lt(other: BigNumberish): boolean;
+    lte(other: BigNumberish): boolean;
+    gt(other: BigNumberish): boolean;
+    gte(other: BigNumberish): boolean;
+    isNegative(): boolean;
+    isZero(): boolean;
+    toNumber(): number;
+    toBigInt(): bigint;
+    toString(): string;
+    toHexString(): string;
+    toJSON(key?: string): any;
+    static from(value: any): BigNumber;
+    static isBigNumber(value: any): value is BigNumber;
+}
+
+declare type Deferrable<T> = {
+    [K in keyof T]: T[K] | Promise<T[K]>;
+};
+declare class Description<T = any> {
+    constructor(info: {
+        [K in keyof T]: T[K];
+    });
+}
+
+declare type Network = {
+    name: string;
+    chainId: number;
+    ensAddress?: string;
+    _defaultProvider?: (providers: any, options?: any) => any;
+};
+
+declare type AccessList = Array<{
+    address: string;
+    storageKeys: Array<string>;
+}>;
+declare type AccessListish = AccessList | Array<[string, Array<string>]> | Record<string, Array<string>>;
+interface Transaction {
+    hash?: string;
+    to?: string;
+    from?: string;
+    nonce: number;
+    gasLimit: BigNumber;
+    gasPrice?: BigNumber;
+    data: string;
+    value: BigNumber;
+    chainId: number;
+    r?: string;
+    s?: string;
+    v?: number;
+    type?: number | null;
+    accessList?: AccessList;
+    maxPriorityFeePerGas?: BigNumber;
+    maxFeePerGas?: BigNumber;
+}
+
+interface OnceBlockable {
+    once(eventName: "block", handler: () => void): void;
+}
+
+declare type TransactionRequest = {
+    to?: string;
+    from?: string;
+    nonce?: BigNumberish;
+    gasLimit?: BigNumberish;
+    gasPrice?: BigNumberish;
+    data?: BytesLike;
+    value?: BigNumberish;
+    chainId?: number;
+    type?: number;
+    accessList?: AccessListish;
+    maxPriorityFeePerGas?: BigNumberish;
+    maxFeePerGas?: BigNumberish;
+    customData?: Record<string, any>;
+    ccipReadEnabled?: boolean;
+};
+interface TransactionResponse extends Transaction {
+    hash: string;
+    blockNumber?: number;
+    blockHash?: string;
+    timestamp?: number;
+    confirmations: number;
+    from: string;
+    raw?: string;
+    wait: (confirmations?: number) => Promise<TransactionReceipt>;
+}
+declare type BlockTag = string | number;
+interface _Block {
+    hash: string;
+    parentHash: string;
+    number: number;
+    timestamp: number;
+    nonce: string;
+    difficulty: number;
+    _difficulty: BigNumber;
+    gasLimit: BigNumber;
+    gasUsed: BigNumber;
+    miner: string;
+    extraData: string;
+    baseFeePerGas?: null | BigNumber;
+}
+interface Block extends _Block {
+    transactions: Array<string>;
+}
+interface BlockWithTransactions extends _Block {
+    transactions: Array<TransactionResponse>;
+}
+interface Log {
+    blockNumber: number;
+    blockHash: string;
+    transactionIndex: number;
+    removed: boolean;
+    address: string;
+    data: string;
+    topics: Array<string>;
+    transactionHash: string;
+    logIndex: number;
+}
+interface TransactionReceipt {
+    to: string;
+    from: string;
+    contractAddress: string;
+    transactionIndex: number;
+    root?: string;
+    gasUsed: BigNumber;
+    logsBloom: string;
+    blockHash: string;
+    transactionHash: string;
+    logs: Array<Log>;
+    blockNumber: number;
+    confirmations: number;
+    cumulativeGasUsed: BigNumber;
+    effectiveGasPrice: BigNumber;
+    byzantium: boolean;
+    type: number;
+    status?: number;
+}
+interface FeeData$1 {
+    lastBaseFeePerGas: null | BigNumber;
+    maxFeePerGas: null | BigNumber;
+    maxPriorityFeePerGas: null | BigNumber;
+    gasPrice: null | BigNumber;
+}
+interface EventFilter {
+    address?: string;
+    topics?: Array<string | Array<string> | null>;
+}
+interface Filter extends EventFilter {
+    fromBlock?: BlockTag;
+    toBlock?: BlockTag;
+}
+declare abstract class ForkEvent extends Description {
+    readonly expiry: number;
+    readonly _isForkEvent?: boolean;
+    static isForkEvent(value: any): value is ForkEvent;
+}
+declare type EventType = string | Array<string | Array<string>> | EventFilter | ForkEvent;
+declare type Listener = (...args: Array<any>) => void;
+declare abstract class Provider implements OnceBlockable {
+    abstract getNetwork(): Promise<Network>;
+    abstract getBlockNumber(): Promise<number>;
+    abstract getGasPrice(): Promise<BigNumber>;
+    getFeeData(): Promise<FeeData$1>;
+    abstract getBalance(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<BigNumber>;
+    abstract getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
+    abstract getCode(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    abstract getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    abstract sendTransaction(signedTransaction: string | Promise<string>): Promise<TransactionResponse>;
+    abstract call(transaction: Deferrable<TransactionRequest>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    abstract estimateGas(transaction: Deferrable<TransactionRequest>): Promise<BigNumber>;
+    abstract getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<Block>;
+    abstract getBlockWithTransactions(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<BlockWithTransactions>;
+    abstract getTransaction(transactionHash: string): Promise<TransactionResponse>;
+    abstract getTransactionReceipt(transactionHash: string): Promise<TransactionReceipt>;
+    abstract getLogs(filter: Filter): Promise<Array<Log>>;
+    abstract resolveName(name: string | Promise<string>): Promise<null | string>;
+    abstract lookupAddress(address: string | Promise<string>): Promise<null | string>;
+    abstract on(eventName: EventType, listener: Listener): Provider;
+    abstract once(eventName: EventType, listener: Listener): Provider;
+    abstract emit(eventName: EventType, ...args: Array<any>): boolean;
+    abstract listenerCount(eventName?: EventType): number;
+    abstract listeners(eventName?: EventType): Array<Listener>;
+    abstract off(eventName: EventType, listener?: Listener): Provider;
+    abstract removeAllListeners(eventName?: EventType): Provider;
+    addListener(eventName: EventType, listener: Listener): Provider;
+    removeListener(eventName: EventType, listener: Listener): Provider;
+    abstract waitForTransaction(transactionHash: string, confirmations?: number, timeout?: number): Promise<TransactionReceipt>;
+    readonly _isProvider: boolean;
+    constructor();
+    static isProvider(value: any): value is Provider;
+}
+
+declare abstract class Signer {
+    readonly provider?: Provider;
+    abstract getAddress(): Promise<string>;
+    abstract signMessage(message: Bytes | string): Promise<string>;
+    abstract signTransaction(transaction: Deferrable<TransactionRequest>): Promise<string>;
+    abstract connect(provider: Provider): Signer;
+    readonly _isSigner: boolean;
+    constructor();
+    getBalance(blockTag?: BlockTag): Promise<BigNumber>;
+    getTransactionCount(blockTag?: BlockTag): Promise<number>;
+    estimateGas(transaction: Deferrable<TransactionRequest>): Promise<BigNumber>;
+    call(transaction: Deferrable<TransactionRequest>, blockTag?: BlockTag): Promise<string>;
+    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse>;
+    getChainId(): Promise<number>;
+    getGasPrice(): Promise<BigNumber>;
+    getFeeData(): Promise<FeeData$1>;
+    resolveName(name: string): Promise<string>;
+    checkTransaction(transaction: Deferrable<TransactionRequest>): Deferrable<TransactionRequest>;
+    populateTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionRequest>;
+    _checkProvider(operation?: string): void;
+    static isSigner(value: any): value is Signer;
+}
+
 // TypeScript Version: 3.0
 
 type AxiosRequestHeaders = Record<string, string | number | boolean>;
@@ -177,6 +418,79 @@ interface AxiosInstance extends Axios {
   (url: string, config?: AxiosRequestConfig): AxiosPromise;
 }
 
+/**
+ * Generates a deterministic Stark private key from the provided signer.
+ * @returns the private key as a hex string
+ */
+declare function generateLegacyStarkPrivateKey(signer: Signer): Promise<string>;
+
+/**
+ * An abstraction of a Stark account, which can be used to sign messages and transactions on StarkEx to execute state changing operations
+ */
+interface StarkSigner {
+    /**
+     * Signs the prefixed-message
+     * @params message - this must be a UTF8-message
+     * @example "0x1234"
+     * @returns the signed prefixed-message
+     */
+    signMessage(message: string): Promise<string>;
+    /**
+     * Get the Signer address
+     * @returns the Signer's checksum address
+     */
+    getAddress(): string | Promise<string>;
+}
+/**
+ * A pair of Signers
+ */
+interface WalletConnection {
+    /**
+     * The L1 signer
+     */
+    ethSigner: Signer;
+    /**
+     * The L2 signer
+     */
+    starkSigner: StarkSigner;
+}
+
+/**
+ * An ERC20 token
+ */
+interface ERC20Token {
+    type: 'ERC20';
+    tokenAddress: string;
+}
+/**
+ * An ETH token
+ */
+interface ETHToken {
+    type: 'ETH';
+}
+/**
+ * An amount of ETH token of unit Wei
+ */
+interface ETHAmount extends ETHToken {
+    /**
+     * An amount in unit Wei
+     */
+    amount: string;
+}
+/**
+ * The token details and amount of ERC20 token units
+ */
+interface ERC20Amount extends ERC20Token {
+    /**
+     * An amount in units for the given ERC20 token
+     */
+    amount: string;
+}
+/**
+ * Union type that represents exchange token type amounts
+ */
+declare type ExchangeTokenAmount = ETHAmount | ERC20Amount;
+
 /**
  * Immutable X API
  * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
@@ -9573,6 +9887,30 @@ declare class WithdrawalsApi extends BaseAPI {
      */
     listWithdrawals(requestParameters?: WithdrawalsApiListWithdrawalsRequest, options?: AxiosRequestConfig): Promise<AxiosResponse<ListWithdrawalsResponse, any>>;
 }
+/**
+ * Parameter required to Mint tokens
+ */
+declare type UnsignedMintRequest = Omit<MintRequest, 'auth_signature'>;
+/**
+ * Parameter required to create a Transfer
+ */
+declare type UnsignedExchangeTransferRequest = ExchangeTokenAmount & {
+    /**
+     * Ethereum address of the receiving user
+     */
+    receiver: string;
+    /**
+     * Exchange transaction ID
+     */
+    transactionID: string;
+};
+
+/**
+ * Creates a new Stark Signer
+ * @params starkPrivateKey - the private key as a hex string
+ * @returns a StarkSigner
+ */
+declare function createStarkSigner(starkPrivateKey: string): StarkSigner;
 
 /**
  * The configuration for the Ethereum network
@@ -9613,18 +9951,14 @@ interface ModuleConfiguration<T> {
     overrides?: T;
 }
 
-interface StarkExOverrides {
+interface ImxOverrides {
     immutableXConfig: ImmutableXConfiguration;
 }
-interface StarkExModuleConfiguration extends ModuleConfiguration<StarkExOverrides> {
-}
-declare class StarkExConfiguration {
-    readonly immutableXConfig: ImmutableXConfiguration;
-    readonly baseConfig: ImmutableConfiguration;
-    constructor({ baseConfig, overrides }: StarkExModuleConfiguration);
+interface ImxModuleConfiguration extends ModuleConfiguration<ImxOverrides> {
 }
 
-declare const StarkExAPIFactory: (config: StarkExConfiguration) => {
+declare class ImmutableXClient {
+    private immutableX;
     depositsApi: DepositsApi;
     mintsApi: MintsApi;
     ordersApi: OrdersApi;
@@ -9641,6 +9975,332 @@ declare const StarkExAPIFactory: (config: StarkExConfiguration) => {
     metadataApi: MetadataApi;
     metadataRefreshesApi: MetadataRefreshesApi;
     projectsApi: ProjectsApi;
-};
+    constructor(config: ImxModuleConfiguration);
+    /**
+     * Get details of a Deposit with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Deposit
+     * @throws {@link index.IMXError}
+     */
+    getDeposit(request: DepositsApiGetDepositRequest): Promise<Deposit>;
+    /**
+     * Get a list of Deposits
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Deposits
+     * @throws {@link index.IMXError}
+     */
+    listDeposits(request?: DepositsApiListDepositsRequest): Promise<ListDepositsResponse>;
+    /**
+     * Get Stark keys for a registered User
+     * @param ethAddress - the eth address of the User
+     * @returns a promise that resolves with the requested User
+     * @throws {@link index.IMXError}
+     */
+    getUser(ethAddress: string): Promise<GetUsersApiResponse>;
+    /**
+     * Get details of an Asset
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Asset
+     * @throws {@link index.IMXError}
+     */
+    getAsset(request: AssetsApiGetAssetRequest): Promise<Asset>;
+    /**
+     * Get a list of Assets
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Assets
+     * @throws {@link index.IMXError}
+     */
+    listAssets(request?: AssetsApiListAssetsRequest): Promise<ListAssetsResponse>;
+    /**
+     * Create a Collection
+     * @param ethSigner - the L1 signer
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created Collection
+     * @throws {@link index.IMXError}
+     */
+    createCollection(ethSigner: Signer, request: CreateCollectionRequest): Promise<Collection>;
+    /**
+     * Get details of a Collection at the given address
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Collection
+     * @throws {@link index.IMXError}
+     */
+    getCollection(request: CollectionsApiGetCollectionRequest): Promise<Collection>;
+    /**
+     * Get a list of Collection filters
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Collection Filters
+     * @throws {@link index.IMXError}
+     */
+    listCollectionFilters(request: CollectionsApiListCollectionFiltersRequest): Promise<CollectionFilter>;
+    /**
+     * Get a list of Collections
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Collections
+     * @throws {@link index.IMXError}
+     */
+    listCollections(request?: CollectionsApiListCollectionsRequest): Promise<ListCollectionsResponse>;
+    /**
+     * Update a Collection
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the updated Collection
+     * @throws {@link index.IMXError}
+     */
+    updateCollection(ethSigner: Signer, collectionAddress: string, request: UpdateCollectionRequest): Promise<Collection>;
+    /**
+     * Add metadata schema to Collection
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the SuccessResponse if successful
+     * @throws {@link index.IMXError}
+     */
+    addMetadataSchemaToCollection(ethSigner: Signer, collectionAddress: string, request: AddMetadataSchemaToCollectionRequest): Promise<SuccessResponse>;
+    /**
+     * Get Metadata schema
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Metadata schema
+     * @throws {@link index.IMXError}
+     */
+    getMetadataSchema(request: MetadataApiGetMetadataSchemaRequest): Promise<MetadataSchemaProperty[]>;
+    /**
+     * Update metadata schema by name
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param name - the Metadata schema name
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the SuccessResponse if successful
+     * @throws {@link index.IMXError}
+     */
+    updateMetadataSchemaByName(ethSigner: Signer, collectionAddress: string, name: string, request: MetadataSchemaRequest): Promise<SuccessResponse>;
+    /**
+     * Get a list of metadata refreshes
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param pageSize - the page size of the result
+     * @param cursor - the cursor
+     * @returns a promise that resolves with the requested metadata refreshes
+     * @throws {@link index.IMXError}
+     */
+    listMetadataRefreshes(ethSigner: Signer, collectionAddress?: string, pageSize?: number, cursor?: string): Promise<GetMetadataRefreshes>;
+    /**
+     * Get a list of metadata refresh errors
+     * @param ethSigner - the L1 signer
+     * @param refreshId - the metadata refresh ID
+     * @param pageSize - the page size of the result
+     * @param cursor - the cursor
+     * @returns a promise that resolves with the requested metadata refresh errors
+     * @throws {@link index.IMXError}
+     */
+    getMetadataRefreshErrors(ethSigner: Signer, refreshId: string, pageSize?: number, cursor?: string): Promise<GetMetadataRefreshErrorsResponse>;
+    /**
+     * Get a list of metadata refresh results
+     * @param ethSigner - the L1 signer
+     * @param refreshId - the metadata refresh ID
+     * @returns a promise that resolves with the requested metadata refresh results
+     * @throws {@link index.IMXError}
+     */
+    getMetadataRefreshResults(ethSigner: Signer, refreshId: string): Promise<GetMetadataRefreshResponse>;
+    /**
+     * Request a metadata refresh
+     * @param ethSigner - the L1 signer
+     * @param request the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested metadata refresh
+     * @throws {@link index.IMXError}
+     */
+    createMetadataRefresh(ethSigner: Signer, request: CreateMetadataRefreshRequest): Promise<CreateMetadataRefreshResponse>;
+    /**
+     * Create a Project
+     * @param ethSigner - the L1 signer
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the created Project
+     * @throws {@link index.IMXError}
+     */
+    createProject(ethSigner: Signer, request: CreateProjectRequest): Promise<CreateProjectResponse>;
+    /**
+     * Get a Project
+     * @param ethSigner - the L1 signer
+     * @param id - the Project ID
+     * @returns a promise that resolves with the requested Project
+     * @throws {@link index.IMXError}
+     */
+    getProject(ethSigner: Signer, id: string): Promise<Project>;
+    /**
+     * Get Projects owned by the given User
+     * @param ethSigner - the L1 signer
+     * @param pageSize - the page size of the result
+     * @param cursor - the cursor
+     * @param orderBy - the property to sort by
+     * @param direction - direction to sort (asc/desc)
+     * @returns a promise that resolves with the requested Projects
+     * @throws {@link index.IMXError}
+     */
+    getProjects(ethSigner: Signer, pageSize?: number, cursor?: string, orderBy?: string, direction?: string): Promise<GetProjectsResponse>;
+    /**
+     * Get the token Balances of the User
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Balance
+     * @throws {@link index.IMXError}
+     */
+    getBalance(request: BalancesApiGetBalanceRequest): Promise<Balance>;
+    /**
+     * Get a list of Balances for given User
+     * @param request the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Balances
+     * @throws {@link index.IMXError}
+     */
+    listBalances(request: BalancesApiListBalancesRequest): Promise<ListBalancesResponse>;
+    /**
+     * Get details of a Mint with the given ID
+     * @param request the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Mint
+     * @throws {@link index.IMXError}
+     */
+    getMint(request: MintsApiGetMintRequest): Promise<Mint[]>;
+    /**
+     * Get a list of Mints
+     * @param request optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Mints
+     * @throws {@link index.IMXError}
+     */
+    listMints(request?: MintsApiListMintsRequest): Promise<ListMintsResponse>;
+    /**
+     * Mint tokens in a batch with fees
+     * @param ethSigner - the L1 signer
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the minted tokens
+     * @throws {@link index.IMXError}
+     */
+    mint(ethSigner: Signer, request: UnsignedMintRequest): Promise<MintTokensResponse>;
+    /**
+     * Get a list of Withdrawals
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Withdrawals
+     * @throws {@link index.IMXError}
+     */
+    listWithdrawals(request?: WithdrawalsApiListWithdrawalsRequest): Promise<ListWithdrawalsResponse>;
+    /**
+     * Get details of Withdrawal with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Withdrawal
+     * @throws {@link index.IMXError}
+     */
+    getWithdrawal(request: WithdrawalsApiGetWithdrawalRequest): Promise<Withdrawal>;
+    /**
+     * Get details of an Order with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Order
+     * @throws {@link index.IMXError}
+     */
+    getOrder(request: OrdersApiGetOrderRequest): Promise<Order>;
+    /**
+     * Get a list of Orders
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Orders
+     * @throws {@link index.IMXError}
+     */
+    listOrders(request?: OrdersApiListOrdersRequest): Promise<ListOrdersResponse>;
+    /**
+     * Get details of a Trade with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Trade
+     * @throws {@link index.IMXError}
+     */
+    getTrade(request: TradesApiGetTradeRequest): Promise<Trade>;
+    /**
+     * Get a list of Trades
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Trades
+     * @throws {@link index.IMXError}
+     */
+    listTrades(request?: TradesApiListTradesRequest): Promise<ListTradesResponse>;
+    /**
+     * Get details of a Token
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Token
+     * @throws {@link index.IMXError}
+     */
+    getToken(request: TokensApiGetTokenRequest): Promise<TokenDetails>;
+    /**
+     * Get a list of Tokens
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Tokens
+     * @throws {@link index.IMXError}
+     */
+    listTokens(request?: TokensApiListTokensRequest): Promise<ListTokensResponse>;
+    /**
+     * Get details of a Transfer with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Transfer
+     * @throws {@link index.IMXError}
+     */
+    getTransfer(request: TransfersApiGetTransferRequest): Promise<Transfer>;
+    /**
+     * Get a list of Transfers
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Transfers
+     * @throws {@link index.IMXError}
+     */
+    listTransfers(request?: TransfersApiListTransfersRequest): Promise<ListTransfersResponse>;
+    /**
+     * Create a new Exchange transaction
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created Exchange Transaction
+     * @throws {@link index.IMXError}
+     */
+    createExchange(request: ExchangesApiCreateExchangeRequest): Promise<ExchangeCreateExchangeAndURLResponse>;
+    /**
+     * Get an Exchange transaction
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the Exchange Transaction
+     * @throws {@link index.IMXError}
+     */
+    getExchange(request: ExchangesApiGetExchangeRequest): Promise<Exchange>;
+    /**
+     * Get Exchange transactions
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with Exchange Transactions
+     * @throws {@link index.IMXError}
+     */
+    getExchanges(request: ExchangesApiGetExchangesRequest): Promise<GetTransactionsResponse>;
+    /**
+     * Create a new Transfer request
+     * @param walletConnection - the pair of Eth/Stark signers
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created Exchange Transfer
+     * @throws {@link index.IMXError}
+     */
+    exchangeTransfer(walletConnection: WalletConnection, request: UnsignedExchangeTransferRequest): Promise<CreateTransferResponseV1>;
+    /**
+     * Create a new nft primary transaction
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created nft primary Transaction
+     * @throws {@link index.IMXError}
+     */
+    createNftPrimary(request: NftCheckoutPrimaryApiCreateNftPrimaryRequest): Promise<NftprimarytransactionCreateResponse>;
+    /**
+     * Get nft primary supported currencies and their limits
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with nft primary Currencies
+     * @throws {@link index.IMXError}
+     */
+    getCurrenciesNFTCheckoutPrimary(request: NftCheckoutPrimaryApiGetCurrenciesNFTCheckoutPrimaryRequest): Promise<CurrencyWithLimits>;
+    /**
+     * Get nft primary transaction by transaction id
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with nft primary transaction
+     * @throws {@link index.IMXError}
+     */
+    getNftPrimaryTransaction(request: NftCheckoutPrimaryApiGetNftPrimaryTransactionRequest): Promise<NftprimarytransactionGetResponse>;
+    /**
+     * Get list of nft primary transactions
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with nft primary transaction
+     * @throws {@link index.IMXError}
+     */
+    getNftPrimaryTransactions(request: NftCheckoutPrimaryApiGetNftPrimaryTransactionsRequest): Promise<NftprimarytransactionListTransactionsResponse>;
+}
 
-export { StarkExAPIFactory, StarkExConfiguration, StarkExOverrides };
+export { ImmutableXClient, ImxModuleConfiguration as ImxClientModuleConfiguration, WalletConnection as ImxClientWalletConnection, createStarkSigner as imxClientCreateStarkSigner, generateLegacyStarkPrivateKey as imxClientGenerateLegacyStarkPrivateKey };