@skip-go/client 1.1.8 → 1.2.0

package/dist/{chunk-GH36M7RI.js → chunk-DF3WCTFB.js}

@@ -1,4 +1,4 @@
-import { api } from './chunk-H54ORPCL.js';
+import { api } from './chunk-YABXOO3H.js';
 
 // src/api/postSubmitTransaction.ts
 var submitTransaction = api({

package/dist/{chunk-FVI3HTIO.js → chunk-GOPRDIYL.js}

@@ -1,16 +1,18 @@
-import { transactionStatus } from './chunk-M7EBNJWK.js';
-import { trackTransaction } from './chunk-Z7GQR23T.js';
-import { wait } from './chunk-H54ORPCL.js';
+import { transactionStatus } from './chunk-XZV42PVV.js';
+import { trackTransaction } from './chunk-IWMMZY56.js';
+import { wait } from './chunk-YABXOO3H.js';
 
 // src/public-functions/waitForTransaction.ts
 var waitForTransaction = async ({
   chainId,
   txHash,
-  onTransactionTracked
+  onTransactionTracked,
+  ...trackTxPollingOptions
 }) => {
   const { explorerLink } = await trackTransaction({
     chainId,
-    txHash
+    txHash,
+    ...trackTxPollingOptions
   });
   await onTransactionTracked?.({ txHash, chainId, explorerLink });
   while (true) {

package/dist/chunk-IWMMZY56.js

@@ -0,0 +1,20 @@
+import { pollingApi } from './chunk-YABXOO3H.js';
+
+// src/api/postTrackTransaction.ts
+var trackTransaction = ({
+  maxRetries,
+  retryInterval,
+  backoffMultiplier = 2.5,
+  ...trackTxRequest
+}) => {
+  return pollingApi({
+    methodName: "track",
+    path: "/v2/tx/track",
+    method: "post",
+    maxRetries,
+    retryInterval,
+    backoffMultiplier
+  })(trackTxRequest);
+};
+
+export { trackTransaction };

package/dist/{chunk-QYJTS5PW.js → chunk-NQZYCFAA.js}

@@ -1,4 +1,4 @@
-import { api } from './chunk-H54ORPCL.js';
+import { api } from './chunk-YABXOO3H.js';
 
 // src/api/postIbcOriginAssets.ts
 var ibcOriginAssets = api({

package/dist/{chunk-PXL7VX4V.js → chunk-O4IHON37.js}

@@ -1,5 +1,5 @@
 import { BigNumber } from './chunk-VQ5SIQWU.js';
-import { getFeeInfoForChain } from './chunk-H42CXF2U.js';
+import { getFeeInfoForChain } from './chunk-6SQTOOYP.js';
 import { Decimal } from '@cosmjs/math';
 import { GasPrice } from '@cosmjs/stargate';
 

package/dist/{chunk-I5GT57P3.js → chunk-OFBEDG4X.js}

@@ -1,4 +1,4 @@
-import { api } from './chunk-H54ORPCL.js';
+import { api } from './chunk-YABXOO3H.js';
 
 // src/api/postSubmit.ts
 var submit = api({

package/dist/{chunk-WN4AUWSP.js → chunk-RE4YYQCE.js}

@@ -1,4 +1,4 @@
-import { api } from './chunk-H54ORPCL.js';
+import { api } from './chunk-YABXOO3H.js';
 
 // src/api/getVenues.ts
 var venues = api({

package/dist/{chunk-FRP5Y35B.js → chunk-THUBVEVZ.js}

@@ -1,4 +1,4 @@
-import { api } from './chunk-H54ORPCL.js';
+import { api } from './chunk-YABXOO3H.js';
 
 // src/api/postRecommendAssets.ts
 var recommendAssets = api({

package/dist/{chunk-IHHYXB3K.js → chunk-U6NXCWXE.js}

@@ -1,4 +1,4 @@
-import { ApiState, api } from './chunk-H54ORPCL.js';
+import { ApiState, api } from './chunk-YABXOO3H.js';
 
 // src/api/postRoute.ts
 var route = async (request) => {

package/dist/{chunk-YSXM6ATC.js → chunk-UCUUIQHV.js}

@@ -1,4 +1,4 @@
-import { api } from './chunk-H54ORPCL.js';
+import { api } from './chunk-YABXOO3H.js';
 
 // src/api/getBridges.ts
 var bridges = api({

package/dist/{chunk-6NMCE4AL.js → chunk-UNMBRIHZ.js}

@@ -1,16 +1,16 @@
-import { waitForTransaction } from './chunk-FVI3HTIO.js';
+import { waitForTransaction } from './chunk-GOPRDIYL.js';
 import { getEncodeObjectFromCosmosMessage, getCosmosGasAmountForMessage, getEncodeObjectFromCosmosMessageInjective } from './chunk-TV2XPAIF.js';
 import { getEVMGasAmountForMessage } from './chunk-GV2QOWB4.js';
 import { BigNumber } from './chunk-VQ5SIQWU.js';
 import { GAS_STATION_CHAIN_IDS } from './chunk-SWYON2RG.js';
-import { getSigningStargateClient, getRpcEndpointForChain, accountParser } from './chunk-MSWIIMAD.js';
+import { getSigningStargateClient, getRpcEndpointForChain, accountParser } from './chunk-72PK3PKI.js';
 import { chains, findFirstWorkingEndpoint, getIsEthermint, getIsInitia } from './chunk-36MCR5DZ.js';
-import { messages } from './chunk-5UHQEC5K.js';
-import { submit } from './chunk-I5GT57P3.js';
-import { submitTransaction } from './chunk-GH36M7RI.js';
-import { venues } from './chunk-WN4AUWSP.js';
-import { ClientState, balances } from './chunk-I7WONP6Y.js';
-import { ApiState, wait, createRequestClient, toCamel } from './chunk-H54ORPCL.js';
+import { messages } from './chunk-A7FWC5OX.js';
+import { submit } from './chunk-OFBEDG4X.js';
+import { submitTransaction } from './chunk-DF3WCTFB.js';
+import { venues } from './chunk-RE4YYQCE.js';
+import { ClientState, balances } from './chunk-4XUWIG3Z.js';
+import { ApiState, wait, createRequestClient, toCamel } from './chunk-YABXOO3H.js';
 import { PublicKey, Transaction, Connection, LAMPORTS_PER_SOL } from '@solana/web3.js';
 import { bech32m, bech32 } from 'bech32';
 import { StargateClient, GasPrice, calculateFee } from '@cosmjs/stargate';
@@ -45,14 +45,14 @@ var getRestEndpointForChain = async (chainId) => {
   }
   if (chain.apis?.rest?.length === 0 || !chain.apis?.rest) {
     throw new Error(
-      `getRestEndpointForChain error: failed to find REST endpoint for chain '${chainId}'`
+      `getRestEndpointForChain error: failed to find REST endpoint for chain id '${chainId}'`
     );
   }
   const endpoints = chain.apis?.rest?.map((api) => api.address);
   const endpoint = await findFirstWorkingEndpoint(endpoints, "rest");
   if (!endpoint) {
     throw new Error(
-      `getRestEndpointForChain error: failed to find REST endpoint for chain '${chainId}'`
+      `getRestEndpointForChain error: failed to find REST endpoint for chain id '${chainId}'`
     );
   }
   return endpoint;
@@ -340,9 +340,7 @@ var signCosmosMessageAmino = async (options) => {
     signatures: [fromBase64(signature.signature)]
   });
 };
-
-// src/private-functions/cosmos/executeCosmosTransaction.ts
-var executeCosmosTransaction = async ({
+var signCosmosTransaction = async ({
   tx,
   options,
   index
@@ -369,7 +367,7 @@ var executeCosmosTransaction = async ({
   if (messages2 === void 0) {
     throw new Error("no messages found for tx");
   }
-  const { stargateClient, signer } = await getSigningStargateClient({
+  const { signer } = await getSigningStargateClient({
     chainId,
     getOfflineSigner: options?.getCosmosSigner
   });
@@ -416,6 +414,24 @@ var executeCosmosTransaction = async ({
   });
   const txBytes = TxRaw.encode(rawTx).finish();
   const rawTxBase64 = Buffer.from(txBytes).toString("base64");
+  return rawTxBase64;
+};
+
+// src/private-functions/cosmos/executeCosmosTransaction.ts
+var executeCosmosTransaction = async ({
+  tx,
+  options,
+  index
+}) => {
+  if (tx === void 0) {
+    throw new Error("executeCosmosTransaction error: tx is undefined");
+  }
+  const rawTxBase64 = await signCosmosTransaction({
+    tx,
+    options,
+    index
+  });
+  const chainId = tx.cosmosTx?.chainId;
   const txResponse = await submit({
     chainId,
     tx: rawTxBase64
@@ -713,12 +729,17 @@ var executeEvmTransaction = async (message, options) => {
   });
   return receipt;
 };
-var executeSvmTransaction = async (tx, options) => {
+var signSvmTransaction = async ({
+  tx,
+  options
+}) => {
   const gasArray = ClientState.validateGasResults;
   if (tx === void 0) {
     throw new Error("executeSvmTransaction error: tx is undefined");
   }
-  const gas = gasArray?.find((gas2) => gas2?.error !== null && gas2?.error !== void 0);
+  const gas = gasArray?.find(
+    (gas2) => gas2?.error !== null && gas2?.error !== void 0
+  );
   if (typeof gas?.error === "string") {
     throw new Error(gas?.error);
   }
@@ -735,25 +756,37 @@ var executeSvmTransaction = async (tx, options) => {
   }
   const txBuffer = Buffer.from(svmTx.tx ?? "", "base64");
   const transaction = Transaction.from(txBuffer);
+  if (!("signTransaction" in signer)) return;
+  const signedTx = await signer.signTransaction(transaction);
+  options?.onTransactionSigned?.({ chainId: svmTx.chainId });
+  const serializedTx = signedTx.serialize();
+  return serializedTx;
+};
+
+// src/private-functions/svm/executeSvmTransaction.ts
+var executeSvmTransaction = async (tx, options) => {
+  const svmTx = tx?.svmTx;
+  if (!svmTx?.chainId) {
+    throw new Error("executeSvmTransaction error: chainId not found in svmTx");
+  }
+  const signedTx = await signSvmTransaction({ tx, options });
+  if (!signedTx) {
+    throw new Error("executeSvmTransaction error: signedTx is undefined");
+  }
   const endpoint = await getRpcEndpointForChain(svmTx.chainId);
   const connection = new Connection(endpoint);
   let signature;
-  if ("signTransaction" in signer) {
-    const signedTx = await signer.signTransaction(transaction);
-    options?.onTransactionSigned?.({ chainId: svmTx.chainId });
-    const serializedTx = signedTx.serialize();
-    await submitTransaction({
-      chainId: svmTx.chainId,
-      tx: serializedTx.toString("base64")
-    }).then((res) => {
-      signature = res?.txHash;
-    });
-    const rpcSig = await connection.sendRawTransaction(serializedTx, {
-      preflightCommitment: "confirmed",
-      maxRetries: 5
-    });
-    signature = rpcSig;
-  }
+  await submitTransaction({
+    chainId: svmTx.chainId,
+    tx: signedTx.toString("base64")
+  }).then((res) => {
+    signature = res?.txHash;
+  });
+  const rpcSig = await connection.sendRawTransaction(signedTx, {
+    preflightCommitment: "confirmed",
+    maxRetries: 5
+  });
+  signature = rpcSig;
   if (!signature) {
     throw new Error("executeSvmTransaction error: signature not found");
   }
@@ -799,11 +832,11 @@ var validateCosmosGasBalance = async ({
   const skipChains = await ClientState.getSkipChains();
   const chain = skipChains?.find((c) => c.chainId === chainId);
   if (!chain) {
-    throw new Error(`failed to find chain id for '${chainId}'`);
+    throw new Error(`failed to find chain id '${chainId}'`);
   }
   const { feeAssets } = chain;
   if (!feeAssets) {
-    throw new Error(`failed to find fee assets for chain '${chainId}'`);
+    throw new Error(`failed to find fee assets for chain id '${chainId}'`);
   }
   const estimatedGasAmount = await (async () => {
     try {
@@ -928,11 +961,11 @@ var validateCosmosGasBalance = async ({
   if (!feeUsed) {
     if (validatedAssets.length > 1) {
       throw new Error(
-        validatedAssets[0]?.error || `Insufficient fee token to initiate transfer on ${chainId}.`
+        validatedAssets[0]?.error || `Insufficient fee token to initiate transfer on ${chain.prettyName}.`
       );
     }
     throw new Error(
-      validatedAssets[0]?.error || `Insufficient fee token to initiate transfer on ${chainId}.`
+      validatedAssets[0]?.error || `Insufficient fee token to initiate transfer on ${chain.prettyName}.`
     );
   }
   return feeUsed;
@@ -1178,15 +1211,15 @@ var validateGasBalances = async ({
   enabledChainIds,
   useUnlimitedApproval
 }) => {
-  onValidateGasBalance?.({
-    status: "pending"
-  });
   const validateResult = await Promise.all(
     txs.map(async (tx, i) => {
       if (!tx) {
         throw new Error(`invalid tx at index ${i}`);
       }
       if ("cosmosTx" in tx && !disabledChainIds?.includes(tx?.cosmosTx?.chainId ?? "") && (enabledChainIds === void 0 || enabledChainIds.includes(tx?.cosmosTx?.chainId ?? ""))) {
+        onValidateGasBalance?.({
+          status: "pending"
+        });
         if (!tx?.cosmosTx?.msgs) {
           throw new Error(`invalid msgs ${tx?.cosmosTx?.msgs}`);
         }
@@ -1211,9 +1244,14 @@ var validateGasBalances = async ({
         }
       }
       if ("evmTx" in tx && !disabledChainIds?.includes(tx?.evmTx?.chainId ?? "") && (enabledChainIds === void 0 || enabledChainIds.includes(tx?.evmTx?.chainId ?? ""))) {
+        onValidateGasBalance?.({
+          status: "pending"
+        });
         const signer = await getEvmSigner?.(tx?.evmTx?.chainId ?? "");
         if (!signer) {
-          throw new Error(`failed to get signer for chain ${tx?.evmTx?.chainId}`);
+          throw new Error(
+            `failed to get signer for chain ${tx?.evmTx?.chainId}`
+          );
         }
         try {
           const res = await validateEvmGasBalance({
@@ -1233,6 +1271,9 @@ var validateGasBalances = async ({
         }
       }
       if ("svmTx" in tx && !disabledChainIds?.includes(tx?.svmTx?.chainId ?? "") && (enabledChainIds === void 0 || enabledChainIds.includes(tx?.svmTx?.chainId ?? ""))) {
+        onValidateGasBalance?.({
+          status: "pending"
+        });
         try {
           const res = await validateSvmGasBalance({
             tx: tx.svmTx
@@ -1277,10 +1318,14 @@ var executeTransactions = async (options) => {
     getFallbackGasAmount = getDefaultFallbackGasAmount,
     getCosmosSigner,
     getEvmSigner,
-    onValidateGasBalance
+    onValidateGasBalance,
+    trackTxPollingOptions,
+    batchSignTxs = true
   } = options;
   if (txs === void 0) {
-    throw new Error("executeTransactions error: txs is undefined in executeTransactions");
+    throw new Error(
+      "executeTransactions error: txs is undefined in executeTransactions"
+    );
   }
   const chainIds = txs.map((tx) => {
     if ("cosmosTx" in tx) {
@@ -1327,35 +1372,84 @@ var executeTransactions = async (options) => {
       enabledChainIds: !batchSimulate ? [chainId] : validateChainIds
     });
   };
+  let signedTxs = [];
+  if (batchSignTxs) {
+    for (let i = 0; i < txs.length; i++) {
+      const tx = txs[i];
+      if (!tx) {
+        throw new Error(`executeRoute error: invalid message at index ${i}`);
+      }
+      if ("cosmosTx" in tx) {
+        await validateEnabledChainIds(tx.cosmosTx?.chainId ?? "");
+        const signedTx = await signCosmosTransaction({
+          tx,
+          options,
+          index: i
+        });
+        signedTxs.push({
+          index: i,
+          chainId: tx.cosmosTx?.chainId ?? "",
+          tx: signedTx,
+          chainType: "cosmos" /* Cosmos */
+        });
+      }
+      if ("svmTx" in tx) {
+        await validateEnabledChainIds(tx.svmTx?.chainId ?? "");
+        const signedTx = await signSvmTransaction({ tx, options });
+        if (!signedTx) {
+          throw new Error(`executeRoute error: signedTx is undefined`);
+        }
+        signedTxs.push({
+          index: i,
+          chainId: tx.svmTx?.chainId ?? "",
+          tx: signedTx.toString("base64"),
+          chainType: "svm" /* Svm */
+        });
+      }
+    }
+  }
   for (let i = 0; i < txs.length; i++) {
     const tx = txs[i];
     if (!tx) {
       throw new Error(`executeRoute error: invalid message at index ${i}`);
     }
     let txResult;
-    if ("cosmosTx" in tx) {
-      await validateEnabledChainIds(tx.cosmosTx?.chainId ?? "");
-      txResult = await executeCosmosTransaction({
-        tx,
-        options,
-        index: i
+    const txSigned = signedTxs.find((item) => item.index === i);
+    if (txSigned) {
+      const txResponse = await submit({
+        chainId: txSigned.chainId,
+        tx: txSigned.tx
       });
-    } else if ("evmTx" in tx) {
-      await validateEnabledChainIds(tx.evmTx?.chainId ?? "");
-      const txResponse = await executeEvmTransaction(tx, options);
       txResult = {
-        chainId: tx?.evmTx?.chainId ?? "",
-        txHash: txResponse.transactionHash
+        chainId: txSigned.chainId,
+        txHash: txResponse?.txHash ?? ""
       };
-    } else if ("svmTx" in tx) {
-      await validateEnabledChainIds(tx.svmTx?.chainId ?? "");
-      txResult = await executeSvmTransaction(tx, options);
     } else {
-      throw new Error("executeRoute error: invalid message type");
+      if ("cosmosTx" in tx) {
+        await validateEnabledChainIds(tx.cosmosTx?.chainId ?? "");
+        txResult = await executeCosmosTransaction({
+          tx,
+          options,
+          index: i
+        });
+      } else if ("evmTx" in tx) {
+        await validateEnabledChainIds(tx.evmTx?.chainId ?? "");
+        const txResponse = await executeEvmTransaction(tx, options);
+        txResult = {
+          chainId: tx?.evmTx?.chainId ?? "",
+          txHash: txResponse.transactionHash
+        };
+      } else if ("svmTx" in tx) {
+        await validateEnabledChainIds(tx.svmTx?.chainId ?? "");
+        txResult = await executeSvmTransaction(tx, options);
+      } else {
+        throw new Error("executeRoute error: invalid message type");
+      }
     }
     await onTransactionBroadcast?.({ ...txResult });
     const txStatusResponse = await waitForTransaction({
       ...txResult,
+      ...trackTxPollingOptions,
       onTransactionTracked: options.onTransactionTracked
     });
     await onTransactionCompleted?.({
@@ -1377,7 +1471,9 @@ var getDefaultFallbackGasAmount = async (chainId, chainType) => {
   }
   if (chainType !== "cosmos" /* Cosmos */) return void 0;
   const venuesResult = await venues();
-  const isSwapChain = venuesResult?.some((venue) => venue.chainId === chainId) ?? false;
+  const isSwapChain = venuesResult?.some(
+    (venue) => venue.chainId === chainId
+  ) ?? false;
   const defaultGasAmount = Math.ceil(
     isSwapChain ? COSMOS_GAS_AMOUNT.SWAP : COSMOS_GAS_AMOUNT.DEFAULT
   );
@@ -1417,7 +1513,8 @@ var executeRoute = async (options) => {
     operations: route?.operations,
     addressList,
     slippageTolerancePercent: options.slippageTolerancePercent || "1",
-    chainIdsToAffiliates: ApiState.chainIdsToAffiliates
+    chainIdsToAffiliates: ApiState.chainIdsToAffiliates,
+    postRouteHandler: options.postRouteHandler
   });
   if (beforeMsg && (response?.txs?.length ?? 0) > 0) {
     const firstTx = response?.txs?.[0];

package/dist/{chunk-M7EBNJWK.js → chunk-XZV42PVV.js}

@@ -1,4 +1,4 @@
-import { pollingApi } from './chunk-H54ORPCL.js';
+import { pollingApi } from './chunk-YABXOO3H.js';
 
 // src/api/postTransactionStatus.ts
 var transactionStatus = pollingApi({

package/dist/{chunk-H54ORPCL.js → chunk-YABXOO3H.js}

@@ -24,14 +24,21 @@ function convertKeys(obj, convertKey) {
 }
 
 // src/utils/generateApi.ts
-var createRequestClient = ({ baseUrl, apiKey }) => {
-  if (!baseUrl?.endsWith("/")) {
-    baseUrl += "/";
+var createRequestClient = ({ apiUrl, apiKey, apiHeaders }) => {
+  if (!apiUrl?.endsWith("/")) {
+    apiUrl += "/";
+  }
+  const headers = new Headers({
+    "content-type": "application/json"
+  });
+  if (apiKey) {
+    headers.set("authorization", apiKey);
+  }
+  if (apiHeaders) {
+    new Headers(apiHeaders).forEach((value, key) => {
+      headers.set(key, value);
+    });
   }
-  const defaultHeaders = {
-    "content-type": "application/json",
-    ...apiKey ? { authorization: apiKey } : {}
-  };
   const handleResponse = async (response) => {
     const contentType = response.headers.get("content-type");
     const isJson = contentType?.includes("application/json");
@@ -46,7 +53,7 @@ var createRequestClient = ({ baseUrl, apiKey }) => {
     if (path?.startsWith("/")) {
       console.warn("paths that start with / are treated as absolute paths, please remove the leading / if this path is intended to be a relative path");
     }
-    const url = new URL(path ?? "", baseUrl);
+    const url = new URL(path ?? "", apiUrl);
     if (params && typeof params === "object") {
       Object.entries(params).forEach(([key, value]) => {
         if (value !== void 0 && value !== null) {
@@ -56,7 +63,7 @@ var createRequestClient = ({ baseUrl, apiKey }) => {
     }
     const response = await fetch(url.toString(), {
       method: "GET",
-      headers: defaultHeaders,
+      headers,
       signal
     });
     return handleResponse(response);
@@ -65,9 +72,9 @@ var createRequestClient = ({ baseUrl, apiKey }) => {
     if (path?.startsWith("/")) {
       console.warn("paths that start with / are treated as absolute paths, please remove the leading / if this path is intended to be a relative path");
     }
-    const response = await fetch(new URL(path, baseUrl).toString(), {
+    const response = await fetch(new URL(path, apiUrl).toString(), {
       method: "POST",
-      headers: defaultHeaders,
+      headers,
       body: JSON.stringify(data),
       signal
     });
@@ -83,12 +90,13 @@ function createRequest({
 }) {
   let controller = null;
   const request = async (options) => {
-    const { apiKey, apiUrl, abortDuplicateRequests, ...requestParams } = options ?? {};
+    const { apiKey, apiUrl, apiHeaders, abortDuplicateRequests, ...requestParams } = options ?? {};
     let fetchClient = ApiState.client;
     if (apiUrl || apiKey) {
       fetchClient = createRequestClient({
-        baseUrl: apiUrl || "https://api.skip.build",
-        apiKey
+        apiUrl: apiUrl || "https://api.skip.build",
+        apiKey,
+        apiHeaders
       });
     } else {
       await ApiState.clientInitialized;

package/dist/{chunk-NQNYCD4R.js → chunk-Z3Z7A3YS.js}

@@ -1,4 +1,4 @@
-import { api } from './chunk-H54ORPCL.js';
+import { api } from './chunk-YABXOO3H.js';
 
 // src/api/getAssetsBetweenChains.ts
 var assetsBetweenChains = api({

package/dist/{client-types-BkeR6R_z.d.ts → client-types-DRmsTfeT.d.ts}

@@ -3,7 +3,7 @@ import { OfflineDirectSigner } from '@cosmjs/proto-signing';
 import { StdFee, GasPrice, SignerData } from '@cosmjs/stargate';
 import { WalletClient } from 'viem';
 import { Adapter } from '@solana/wallet-adapter-base';
-import { a3 as FeeAsset, L as ChainType, W as CosmosMsg } from './swaggerTypes-CAERZYPb.js';
+import { a3 as FeeAsset, L as ChainType, W as CosmosMsg } from './swaggerTypes-BpJPRbC3.js';
 
 /** Common Types */
 type UserAddress = {

package/dist/generateApi-D7KXciAd.d.ts

@@ -0,0 +1,55 @@
+import { bv as Api } from './swaggerTypes-BpJPRbC3.js';
+
+type CamelKey<S extends string> = S extends `${infer T}_${infer U}` ? `${T}${Capitalize<CamelKey<U>>}` : S;
+type Camel<T> = T extends (infer U)[] ? Camel<U>[] : T extends object ? {
+    [K in keyof T as K extends string ? CamelKey<K> : never]: Camel<T[K]>;
+} : T;
+
+type ApiInstance = InstanceType<typeof Api>;
+type FunctionKeys<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+type ValidApiMethodKeys = {
+    [K in FunctionKeys<ApiInstance>]: Awaited<ReturnType<ApiInstance[K]>> extends {
+        data: unknown;
+    } ? K : never;
+}[FunctionKeys<ApiInstance>];
+type ApiRequest<K extends ValidApiMethodKeys> = NonNullable<Camel<Parameters<ApiInstance[K]>[0]>>;
+type ApiResponse<K extends ValidApiMethodKeys> = Camel<Awaited<ReturnType<ApiInstance[K]>> extends {
+    data: infer D;
+} ? D extends object ? D : never : never>;
+type PollingProps<K extends ValidApiMethodKeys> = {
+    isSuccess?: (result: ApiResponse<K>) => boolean;
+    /**
+     * Maximum number of retries
+     * @default 5
+     */
+    maxRetries?: number;
+    /**
+     * Retry interval in milliseconds
+     * @default 1000
+     */
+    retryInterval?: number;
+    /**
+     * Backoff multiplier for retries
+     *
+     * example: `retryInterval` is set to 1000, backoffMultiplier is set to 2
+     *
+     * 1st retry: 1000ms
+     *
+     * 2nd retry: 2000ms
+     *
+     * 3rd retry: 4000ms
+     *
+     * 4th retry: 8000ms
+     *
+     * 5th retry: 16000ms
+     *
+     * @default 2
+     */
+    backoffMultiplier?: number;
+    onError?: (error: unknown, attempt: number) => void;
+    onSuccess?: (result: ApiResponse<K>, attempt: number) => void;
+};
+
+export type { ApiRequest as A, PollingProps as P, ApiResponse as a };