cloreai 2.0.0 → 3.0.0

package/README.md

@@ -7,7 +7,8 @@ Features:
 - Based on [axios](https://github.com/axios/axios)
 - Protects from rate limit exceeded (429 errors) via
   [p-queue](https://github.com/sindresorhus/p-queue)
-- Error handling via try...catch and instanceof
+- User-friendly error handling
+- Full typing
 - Supports GigaSPOT
 
 Official documentation: [clore.ai/api-docs](https://clore.ai/api-docs)
@@ -26,13 +27,13 @@ npm install cloreai
 ### Creating an instance
 
 ```typescript
-import CloreAI from 'cloreai'
+import Cloreai from 'cloreai'
 
-const cloreai = new CloreAI('<API_KEY>', {
+const cloreai = new Cloreai('API_KEY', {
   axiosOptions: {}, // (optional) Axios instance options https://github.com/axios/axios
   queueOptions: {}, // (optional) Queue instance options https://github.com/sindresorhus/p-queue
-  queueOptionsCreateOrder: {}, // (optional) Create order queue instance options https://github.com/sindresorhus/p-queue
-  queueOptionsGigaspot: {}, // (optional) Gigaspot queue instance options https://github.com/sindresorhus/p-queue
+  queueCreateOrderOptions: {}, // (optional) Create order queue instance options https://github.com/sindresorhus/p-queue
+  queueGigaspotOptions: {}, //  (optional) Gigaspot queue instance options https://github.com/sindresorhus/p-queue
 })
 ```
 
@@ -52,7 +53,7 @@ const myServers = await cloreai.myServers()
 
 ```typescript
 const serverConfig = await cloreai.serverConfig({
-  server_name: 'server_name',
+  server_name: 'SERVER_NAME',
 })
 ```
 
@@ -81,13 +82,28 @@ const spotMarketplace = await cloreai.spotMarketplace({
 
 ```typescript
 await cloreai.setServerSettings({
-  'name': 'name', // Server name
+  'name': 'NAME', // Server name
   'availability': true,
   'mrl': 24,
-  'on_demand': 50,
-  'spot': 50,
-  'CLORE-Blockchain_on_demand': 50,
-  'CLORE-Blockchain_spot': 50,
+  'bitcoin_on_demand': 1,
+  'bitcoin_spot': 1,
+  'CLORE-Blockchain_on_demand': 1,
+  'CLORE-Blockchain_spot': 1,
+  'USD-Blockchain_on_demand': 1,
+  'USD-Blockchain_spot': 1,
+  'enabled-USD-Blockchain': true,
+  'enabled-CLORE-Blockchain': true,
+  'enabled-bitcoin': true,
+  'autoprice': {
+    'CLORE-Blockchain': 'usd',
+    'USD-Blockchain': 'usd',
+    'bitcoin': 'usd',
+  },
+  'usd_pricing': {
+    'CLORE-Blockchain': { on_demand: 1, spot: 1 },
+    'USD-Blockchain': { on_demand: 1, spot: 1 },
+    'bitcoin': { on_demand: 1, spot: 1 },
+  },
 })
 ```
 
@@ -119,8 +135,8 @@ await cloreai.createOrder({
   renting_server: 5738,
   ports: { 22: 'tcp', 8888: 'http' },
   env: { SSH_PASSWORD: 'SSH_PASSWORD', JUPYTER_TOKEN: 'JUPYTER_TOKEN' },
-  jupyter_token: 'jupyter_token',
-  ssh_password: 'ssh_password',
+  jupyter_token: 'JUPYTER_TOKEN',
+  ssh_password: 'SSH_PASSWORD',
   required_price: 50,
   remember_password: true,
 })
@@ -132,6 +148,12 @@ await cloreai.createOrder({
 const pohBalance = await cloreai.pohBalance()
 ```
 
+### 12. renter_fees
+
+```typescript
+const renterFees = await cloreai.renterFees()
+```
+
 ### GigaSPOT
 
 #### getGigaspot
@@ -205,51 +227,43 @@ Refer to the documentation [axios](https://github.com/axios/axios).
 
 Use the fields:
 
-- `cloreai.queue` - for main request queue
-- `cloreai.queueCreateOrder` - for createOrder request queue
-- `cloreai.gigaspot.queue` - for gigaspot request queue
+- `cloreai.queue` - for the main request queue
+- `cloreai.queueCreateOrder` - for the createOrder request queue
+- `cloreai.gigaspot.queue` - for the gigaspot request queue
 
 Refer to the documentation [p-queue](https://github.com/sindresorhus/p-queue).
 
 ### Error Handling
 
-The library exports the following error types:
-
-- `DatabaseError`
-- `InvalidInputDataError`
-- `InvalidApiTokenError`
-- `InvalidEndpointError`
-- `ExceededError`
-- `OtherError`
-- `UnknownError`
+Use the `CloreaiError` class for error handling.
 
-All these errors inherit from `AxiosError`.
+This class inherits from `AxiosError` and has additional fields with error
+information `error.code` and `error.error`.
 
-Check the error type via the `instanceof` operator:
+To check the error type use the constant `statusCodes`.
 
 ```typescript
-import { AxiosError } from 'axios'
-import { ExceededError } from 'cloreai'
+import { CloreaiError, statusCodes } from 'cloreai'
 
 try {
   const marketplace = await cloreai.marketplace()
 } catch (error) {
-  if (error instanceof AxiosError) {
-    console.log('AxiosError')
+  if (error instanceof CloreaiError) {
+    console.log(error.code, error.error)
+
+    if (error.code === statusCodes.EXCEEDED) {
+      console.log('Rate limit exceeded error')
+    }
+  } else {
+    throw error
   }
-
-  if (error instanceof ExceededError) {
-    console.log('ExceededError')
-  }
-
-  throw error
 }
 ```
 
 ### Rate limit
 
 All methods are protected from rate limit exceeded via
-[p-queue](https://github.com/sindresorhus/p-queue), they automatically pause for
+[p-queue](https://github.com/sindresorhus/p-queue), they automatically delay for
 the required time to avoid exceeding the limit.
 
 Default rate limit values are available as constants:
@@ -266,19 +280,19 @@ console.log(RATE_LIMIT_CREATE_ORDER)
 console.log(RATE_LIMIT_GIGASPOT)
 ```
 
-You can set your own rate limit values for each request queue:
+You can set custom rate limit values for each request queue:
 
 ```typescript
-import CloreAI from 'cloreai'
+import Cloreai from 'cloreai'
 
-const cloreai = new CloreAI('<API_KEY>', {
+const cloreai = new Cloreai('API_KEY', {
   queueOptions: {
     interval: 2000, // For example 2 seconds
   },
-  queueOptionsCreateOrder: {
+  queueCreateOrderOptions: {
     interval: 6000, // For example 6 seconds
   },
-  queueOptionsGigaspot: {
+  queueGigaspotOptions: {
     interval: 2000, // For example 2 seconds
   },
 })

package/build/{CloreAI.d.ts → Cloreai.d.ts}

@@ -1,19 +1,26 @@
-import { type AxiosInstance, type AxiosRequestConfig } from 'axios';
-import PQueue from 'p-queue';
-import type { CancelOrderRequestData, CancelOrderResponseData } from './resources/cancelOrder.js';
-import type { CreateOrderRequestData, CreateOrderResponseData } from './resources/createOrder.js';
-import type { MarketplaceResponseData } from './resources/marketplace.js';
-import type { MyOrdersRequestParams, MyOrdersResponseData } from './resources/myOrders.js';
-import type { MyServersResponseData } from './resources/myServers.js';
-import type { PohBalanceResponseData } from './resources/pohBalance.js';
-import type { ServerConfigRequestData, ServerConfigResponseData } from './resources/serverConfig.js';
-import type { SetServerSettingsRequestData, SetServerSettingsResponseData } from './resources/setServerSettings.js';
-import type { SetSpotPriceRequestData, SetSpotPriceResponseData } from './resources/setSpotPrice.js';
-import type { SpotMarketplaceRequestParams, SpotMarketplaceResponseData } from './resources/spotMarketplace.js';
-import type { WalletsResponseData } from './resources/wallets.js';
-import type { Options } from './types.js';
-import Gigaspot from './Gigaspot.js';
-declare class CloreAI {
+import { type AxiosInstance, type AxiosRequestConfig, type CreateAxiosDefaults } from 'axios';
+import PQueue, { type Options as PQueueOptions, type Queue, type QueueAddOptions } from 'p-queue';
+import type { CancelOrderRequestData, CancelOrderResponseData } from './resources/cancelOrder.ts';
+import type { CreateOrderRequestData, CreateOrderResponseData } from './resources/createOrder.ts';
+import type { MarketplaceResponseData } from './resources/marketplace.ts';
+import type { MyOrdersRequestParams, MyOrdersResponseData } from './resources/myOrders.ts';
+import type { MyServersResponseData } from './resources/myServers.ts';
+import type { PohBalanceResponseData } from './resources/pohBalance.ts';
+import type { RenterFeesResponseData } from './resources/renterFees.ts';
+import type { ServerConfigRequestData, ServerConfigResponseData } from './resources/serverConfig.ts';
+import type { SetServerSettingsRequestData, SetServerSettingsResponseData } from './resources/setServerSettings.ts';
+import type { SetSpotPriceRequestData, SetSpotPriceResponseData } from './resources/setSpotPrice.ts';
+import type { SpotMarketplaceRequestParams, SpotMarketplaceResponseData } from './resources/spotMarketplace.ts';
+import type { WalletsResponseData } from './resources/wallets.ts';
+import Gigaspot from './Gigaspot.ts';
+export type QueueOptions = PQueueOptions<Queue<() => Promise<unknown>, QueueAddOptions>, QueueAddOptions>;
+export interface Options {
+    axiosOptions?: CreateAxiosDefaults;
+    queueOptions?: QueueOptions;
+    queueCreateOrderOptions?: QueueOptions;
+    queueGigaspotOptions?: QueueOptions;
+}
+declare class Cloreai {
     axios: AxiosInstance;
     queue: PQueue;
     queueCreateOrder: PQueue;
@@ -30,5 +37,6 @@ declare class CloreAI {
     cancelOrder(data: CancelOrderRequestData, config?: AxiosRequestConfig): Promise<CancelOrderResponseData>;
     createOrder(data: CreateOrderRequestData, config?: AxiosRequestConfig): Promise<CreateOrderResponseData>;
     pohBalance(config?: AxiosRequestConfig): Promise<PohBalanceResponseData>;
+    renterFees(config?: AxiosRequestConfig): Promise<RenterFeesResponseData>;
 }
-export default CloreAI;
+export default Cloreai;

package/build/{CloreAI.js → Cloreai.js}

@@ -1,10 +1,10 @@
-import axios from 'axios';
-import PQueue from 'p-queue';
-import { priorityLevels, RATE_LIMIT, RATE_LIMIT_CREATE_ORDER, statusCodes } from './constants.js';
-import { DatabaseError, ExceededError, InvalidApiTokenError, InvalidEndpointError, InvalidInputDataError, OtherError, UnknownError } from './errors.js';
-import { getQueueOptions } from './getQueueOptions.js';
-import Gigaspot from './Gigaspot.js';
-class CloreAI {
+import axios, {} from 'axios';
+import PQueue, {} from 'p-queue';
+import { CloreaiError } from "./CloreaiError.js";
+import { priorityLevels, RATE_LIMIT, RATE_LIMIT_CREATE_ORDER, statusCodes } from "./constants.js";
+import { getQueueOptions } from "./getQueueOptions.js";
+import Gigaspot from "./Gigaspot.js";
+class Cloreai {
     axios;
     queue;
     queueCreateOrder;
@@ -20,11 +20,11 @@ class CloreAI {
             interval: RATE_LIMIT_CREATE_ORDER,
             intervalCap: 1,
             concurrency: 1,
-            ...options.queueOptionsCreateOrder,
+            ...options.queueCreateOrderOptions,
         });
         this.axios = axios.create({
-            ...options.axiosOptions,
             baseURL: 'https://api.clore.ai/v1',
+            ...options.axiosOptions,
         });
         this.axios.interceptors.request.use((request) => {
             request.headers.set('auth', apiKey);
@@ -34,100 +34,92 @@ class CloreAI {
             if (response.data.code === statusCodes.NORMAL) {
                 return response;
             }
-            const errorMessage = response.data.error != null
-                ? `Code "${response.data.code}", error "${response.data.error}"`
-                : `Code "${response.data.code}"`;
-            const axiosErrorParameters = [
-                errorMessage,
-                undefined,
-                response.config,
-                response.request,
+            const errorMessage = `Code "${response.data.code}"`;
+            const error = new CloreaiError(errorMessage, {
+                code: String(response.data.code),
+                config: response.config,
+                request: response.request,
                 response,
-            ];
-            switch (response.data.code) {
-                case statusCodes.DATABASE_ERROR:
-                    throw new DatabaseError(...axiosErrorParameters);
-                case statusCodes.INVALID_INPUT_DATA:
-                    throw new InvalidInputDataError(...axiosErrorParameters);
-                case statusCodes.INVALID_API_TOKEN:
-                    throw new InvalidApiTokenError(...axiosErrorParameters);
-                case statusCodes.INVALID_ENDPOINT:
-                    throw new InvalidEndpointError(...axiosErrorParameters);
-                case statusCodes.EXCEEDED:
-                    throw new ExceededError(...axiosErrorParameters);
-                case statusCodes.OTHER:
-                    throw new OtherError(...axiosErrorParameters);
-                default:
-                    throw new UnknownError(...axiosErrorParameters);
+            });
+            if (response.data.error != null) {
+                error.message += `, error "${response.data.error}"`;
+                error.error = response.data.error;
             }
+            throw error;
         });
         this.gigaspot = new Gigaspot(options, this.axios);
     }
     async wallets(config) {
         const response = await this.queue.add(async () => {
             return await this.axios.get('/wallets', config);
-        }, getQueueOptions(priorityLevels.NORMAL, config));
+        }, getQueueOptions(priorityLevels.NORMAL, this.axios, config));
         return response.data;
     }
     async myServers(config) {
         const response = await this.queue.add(async () => {
             return await this.axios.get('/my_servers', config);
-        }, getQueueOptions(priorityLevels.NORMAL, config));
+        }, getQueueOptions(priorityLevels.NORMAL, this.axios, config));
         return response.data;
     }
     async serverConfig(data, config) {
         const response = await this.queue.add(async () => {
             return await this.axios.get('/server_config', { ...config, data });
-        }, getQueueOptions(priorityLevels.NORMAL, config));
+        }, getQueueOptions(priorityLevels.NORMAL, this.axios, config));
         return response.data;
     }
     async marketplace(config) {
         const response = await this.queue.add(async () => {
             return await this.axios.get('/marketplace', config);
-        }, getQueueOptions(priorityLevels.NORMAL, config));
+        }, getQueueOptions(priorityLevels.NORMAL, this.axios, config));
         return response.data;
     }
     async myOrders(params, config) {
         const response = await this.queue.add(async () => {
             return await this.axios.get('/my_orders', { ...config, params });
-        }, getQueueOptions(priorityLevels.NORMAL, config));
+        }, getQueueOptions(priorityLevels.NORMAL, this.axios, config));
         return response.data;
     }
     async spotMarketplace(params, config) {
         const response = await this.queue.add(async () => {
             return await this.axios.get('/spot_marketplace', { ...config, params });
-        }, getQueueOptions(priorityLevels.NORMAL, config));
+        }, getQueueOptions(priorityLevels.NORMAL, this.axios, config));
         return response.data;
     }
     async setServerSettings(data, config) {
         const response = await this.queue.add(async () => {
             return await this.axios.post('/set_server_settings', data, config);
-        }, getQueueOptions(priorityLevels.HIGH, config));
+        }, getQueueOptions(priorityLevels.HIGH, this.axios, config));
         return response.data;
     }
     async setSpotPrice(data, config) {
         const response = await this.queue.add(async () => {
             return await this.axios.post('/set_spot_price', data, config);
-        }, getQueueOptions(priorityLevels.HIGH, config));
+        }, getQueueOptions(priorityLevels.HIGH, this.axios, config));
         return response.data;
     }
     async cancelOrder(data, config) {
         const response = await this.queue.add(async () => {
             return await this.axios.post('/cancel_order', data, config);
-        }, getQueueOptions(priorityLevels.HIGH, config));
+        }, getQueueOptions(priorityLevels.HIGH, this.axios, config));
         return response.data;
     }
     async createOrder(data, config) {
         const response = await this.queueCreateOrder.add(async () => {
             return await this.axios.post('/create_order', data, config);
-        }, getQueueOptions(priorityLevels.HIGHEST, config));
+        }, getQueueOptions(priorityLevels.HIGHEST, this.axios, config));
         return response.data;
     }
     async pohBalance(config) {
         const response = await this.queue.add(async () => {
             return await this.axios.get('/poh_balance', config);
-        }, getQueueOptions(priorityLevels.NORMAL, config));
+        }, getQueueOptions(priorityLevels.NORMAL, this.axios, config));
+        return response.data;
+    }
+    async renterFees(config) {
+        const response = await this.queue.add(async () => {
+            return await this.axios.get('/renter_fees', config);
+        }, getQueueOptions(priorityLevels.NORMAL, this.axios, config));
         return response.data;
     }
 }
-export default CloreAI;
+export default Cloreai;

package/build/CloreaiError.d.ts

@@ -0,0 +1,12 @@
+import { AxiosError, type AxiosResponse, type InternalAxiosRequestConfig } from 'axios';
+export interface CloreaiErrorOptions<T = unknown, D = unknown> extends ErrorOptions {
+    code?: string;
+    config?: InternalAxiosRequestConfig<D>;
+    request?: unknown;
+    response?: AxiosResponse<T, D>;
+    error?: string;
+}
+export declare class CloreaiError<T = unknown, D = unknown> extends AxiosError<T, D> {
+    error?: string;
+    constructor(message?: string, options?: CloreaiErrorOptions<T, D>);
+}

package/build/CloreaiError.js

@@ -0,0 +1,16 @@
+import { AxiosError } from 'axios';
+export class CloreaiError extends AxiosError {
+    error;
+    constructor(message, options = {}) {
+        super(message, options.code, options.config, options.request, options.response);
+        this.name = 'CloreaiError';
+        if (options.cause != null) {
+            this.cause = (options.cause instanceof Error)
+                ? options.cause
+                : new Error(String(options.cause));
+        }
+        if (options.error != null) {
+            this.error = options.error;
+        }
+    }
+}

package/build/Gigaspot.d.ts

@@ -1,13 +1,13 @@
 import { type AxiosInstance, type AxiosRequestConfig } from 'axios';
 import PQueue from 'p-queue';
-import type { CancelOrdersRequestData, CancelOrdersResponseData } from './resources/cancelOrders.js';
-import type { CreateGigaspotOrdersRequestData, CreateGigaspotOrdersResponseData } from './resources/createGigaspotOrders.js';
-import type { EditGigaspotOrdersRequestData, EditGigaspotOrdersResponseData } from './resources/editGigaspotOrders.js';
-import type { GetGigaspotResponseData } from './resources/getGigaspot.js';
-import type { Options } from './types.js';
+import type { Options } from './Cloreai.ts';
+import type { CancelOrdersRequestData, CancelOrdersResponseData } from './resources/cancelOrders.ts';
+import type { CreateGigaspotOrdersRequestData, CreateGigaspotOrdersResponseData } from './resources/createGigaspotOrders.ts';
+import type { EditGigaspotOrdersRequestData, EditGigaspotOrdersResponseData } from './resources/editGigaspotOrders.ts';
+import type { GetGigaspotResponseData } from './resources/getGigaspot.ts';
 declare class Gigaspot {
+    axios: AxiosInstance;
     queue: PQueue;
-    private axios;
     constructor(options: Options, axios: AxiosInstance);
     getGigaspot(config?: AxiosRequestConfig): Promise<GetGigaspotResponseData>;
     createGigaspotOrders(data: CreateGigaspotOrdersRequestData, config?: AxiosRequestConfig): Promise<CreateGigaspotOrdersResponseData>;

package/build/Gigaspot.js

@@ -1,16 +1,16 @@
-import axios from 'axios';
+import axios, {} from 'axios';
 import PQueue from 'p-queue';
-import { priorityLevels, RATE_LIMIT_GIGASPOT } from './constants.js';
-import { getQueueOptions } from './getQueueOptions.js';
+import { priorityLevels, RATE_LIMIT_GIGASPOT } from "./constants.js";
+import { getQueueOptions } from "./getQueueOptions.js";
 class Gigaspot {
-    queue;
     axios;
+    queue;
     constructor(options, axios) {
         this.queue = new PQueue({
             interval: RATE_LIMIT_GIGASPOT,
             intervalCap: 1,
             concurrency: 1,
-            ...options.queueOptionsGigaspot,
+            ...options.queueGigaspotOptions,
         });
         this.axios = axios;
     }
@@ -22,24 +22,24 @@ class Gigaspot {
                 ...response.data,
                 snapshot: snapshot.data,
             };
-        }, getQueueOptions(priorityLevels.NORMAL, config));
+        }, getQueueOptions(priorityLevels.NORMAL, this.axios, config));
     }
     async createGigaspotOrders(data, config) {
         const response = await this.queue.add(async () => {
             return await this.axios.post('/create_gigaspot_orders', data, config);
-        }, getQueueOptions(priorityLevels.HIGH, config));
+        }, getQueueOptions(priorityLevels.HIGH, this.axios, config));
         return response.data;
     }
     async editGigaspotOrders(data, config) {
         const response = await this.queue.add(async () => {
             return await this.axios.post('/edit_gigaspot_orders', data, config);
-        }, getQueueOptions(priorityLevels.HIGH, config));
+        }, getQueueOptions(priorityLevels.HIGH, this.axios, config));
         return response.data;
     }
     async cancelOrders(data, config) {
         const response = await this.queue.add(async () => {
             return await this.axios.post('/cancel_orders', data, config);
-        }, getQueueOptions(priorityLevels.HIGH, config));
+        }, getQueueOptions(priorityLevels.HIGH, this.axios, config));
         return response.data;
     }
 }

package/build/constants.d.ts

@@ -1,21 +1,21 @@
-export declare const RATE_LIMIT = 1800;
+export declare const RATE_LIMIT = 1000;
 export declare const RATE_LIMIT_CREATE_ORDER = 5000;
-export declare const RATE_LIMIT_GIGASPOT = 1800;
-export declare const gigaspotBaseImages: {
-    UBUNTU: string;
-    HIVEOS: string;
-};
-export declare const statusCodes: {
-    NORMAL: number;
-    DATABASE_ERROR: number;
-    INVALID_INPUT_DATA: number;
-    INVALID_API_TOKEN: number;
-    INVALID_ENDPOINT: number;
-    EXCEEDED: number;
-    OTHER: number;
-};
-export declare const priorityLevels: {
-    NORMAL: number;
-    HIGH: number;
-    HIGHEST: number;
-};
+export declare const RATE_LIMIT_GIGASPOT = 1000;
+export declare const gigaspotBaseImages: Readonly<{
+    UBUNTU: "a3f9c4d7e5b088d8a0bff880";
+    HIVEOS: "c9a4e2f6b7d488d8f0bab0ff";
+}>;
+export declare const statusCodes: Readonly<{
+    NORMAL: 0;
+    DATABASE_ERROR: 1;
+    INVALID_INPUT_DATA: 2;
+    INVALID_API_TOKEN: 3;
+    INVALID_ENDPOINT: 4;
+    EXCEEDED: 5;
+    CUSTOM: 6;
+}>;
+export declare const priorityLevels: Readonly<{
+    NORMAL: 0;
+    HIGH: 1;
+    HIGHEST: 2;
+}>;

package/build/constants.js

@@ -1,21 +1,21 @@
-export const RATE_LIMIT = 1800;
+export const RATE_LIMIT = 1000;
 export const RATE_LIMIT_CREATE_ORDER = 5000;
-export const RATE_LIMIT_GIGASPOT = 1800;
-export const gigaspotBaseImages = {
+export const RATE_LIMIT_GIGASPOT = 1000;
+export const gigaspotBaseImages = Object.freeze({
     UBUNTU: 'a3f9c4d7e5b088d8a0bff880',
     HIVEOS: 'c9a4e2f6b7d488d8f0bab0ff',
-};
-export const statusCodes = {
+});
+export const statusCodes = Object.freeze({
     NORMAL: 0,
     DATABASE_ERROR: 1,
     INVALID_INPUT_DATA: 2,
     INVALID_API_TOKEN: 3,
     INVALID_ENDPOINT: 4,
     EXCEEDED: 5,
-    OTHER: 6,
-};
-export const priorityLevels = {
+    CUSTOM: 6,
+});
+export const priorityLevels = Object.freeze({
     NORMAL: 0,
     HIGH: 1,
     HIGHEST: 2,
-};
+});

package/build/getQueueOptions.d.ts

@@ -1,5 +1,3 @@
-import type { AxiosRequestConfig } from 'axios';
+import type { AxiosInstance, AxiosRequestConfig } from 'axios';
 import type { QueueAddOptions } from 'p-queue';
-export declare function getQueueOptions(priority: number, config?: AxiosRequestConfig): QueueAddOptions & {
-    throwOnTimeout: true;
-};
+export declare function getQueueOptions(priority: number, axios: AxiosInstance, config?: AxiosRequestConfig): QueueAddOptions;

package/build/getQueueOptions.js

@@ -1,15 +1,8 @@
-export function getQueueOptions(priority, config) {
-    const defaultQueueOptions = {
-        throwOnTimeout: true,
-        priority,
-    };
+export function getQueueOptions(priority, axios, config = {}) {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    const signal = config?.signal;
-    if (signal == null) {
-        return defaultQueueOptions;
-    }
+    const signal = (config.signal ?? axios.defaults.signal);
     return {
-        ...defaultQueueOptions,
+        priority,
         signal,
     };
 }

package/build/index.d.ts

@@ -1,20 +1,22 @@
-import CloreAI from './CloreAI.js';
-export * from './constants.js';
-export * from './errors.js';
-export type * from './resources/cancelOrder.js';
-export type * from './resources/cancelOrders.js';
-export type * from './resources/createGigaspotOrders.js';
-export type * from './resources/createOrder.js';
-export type * from './resources/editGigaspotOrders.js';
-export type * from './resources/getGigaspot.js';
-export type * from './resources/marketplace.js';
-export type * from './resources/myOrders.js';
-export type * from './resources/myServers.js';
-export type * from './resources/pohBalance.js';
-export type * from './resources/serverConfig.js';
-export type * from './resources/setServerSettings.js';
-export type * from './resources/setSpotPrice.js';
-export type * from './resources/spotMarketplace.js';
-export type * from './resources/wallets.js';
-export type * from './types.js';
-export default CloreAI;
+import Cloreai from './Cloreai.ts';
+export * from './Cloreai.ts';
+export * from './CloreaiError.ts';
+export * from './constants.ts';
+export type * from './resources/cancelOrder.ts';
+export type * from './resources/cancelOrders.ts';
+export type * from './resources/createGigaspotOrders.ts';
+export type * from './resources/createOrder.ts';
+export type * from './resources/editGigaspotOrders.ts';
+export type * from './resources/getGigaspot.ts';
+export type * from './resources/marketplace.ts';
+export type * from './resources/myOrders.ts';
+export type * from './resources/myServers.ts';
+export type * from './resources/pohBalance.ts';
+export type * from './resources/renterFees.ts';
+export type * from './resources/serverConfig.ts';
+export type * from './resources/setServerSettings.ts';
+export type * from './resources/setSpotPrice.ts';
+export type * from './resources/spotMarketplace.ts';
+export type * from './resources/wallets.ts';
+export type * from './types.ts';
+export default Cloreai;

package/build/index.js

@@ -1,4 +1,5 @@
-import CloreAI from './CloreAI.js';
-export * from './constants.js';
-export * from './errors.js';
-export default CloreAI;
+import Cloreai from "./Cloreai.js";
+export * from "./Cloreai.js";
+export * from "./CloreaiError.js";
+export * from "./constants.js";
+export default Cloreai;

package/build/resources/cancelOrder.d.ts

@@ -1,4 +1,4 @@
-import type { ResponseData } from '../types.js';
+import type { ResponseData } from '../types.ts';
 export interface CancelOrderRequestData {
     id: number;
     issue?: string;

package/build/resources/cancelOrders.d.ts

@@ -1,4 +1,4 @@
-import type { ResponseData } from '../types.js';
+import type { ResponseData } from '../types.ts';
 export interface CancelOrdersRequestData {
     order_ids: number[];
 }

package/build/resources/createGigaspotOrders.d.ts

@@ -1,20 +1,13 @@
-import type { Currency, ResponseData } from '../types.js';
-export interface CreateGigaspotOrdersRequestDataOrderOverclock {
-    pl: number;
-    core_offset?: number;
-    mem_offset?: number;
-    core_lock?: number;
-    mem_lock?: number;
-}
-export interface CreateGigaspotOrdersRequestDataOrder {
+import type { Currency, GigaspotOverclock, ResponseData } from '../types.ts';
+export interface CreateGigaspotOrdersOrder {
     currency: Currency;
     image: string;
     renting_server: number;
     price: number;
-    oc: CreateGigaspotOrdersRequestDataOrderOverclock[];
+    oc: GigaspotOverclock[];
     env?: Record<string, string>;
 }
-export type CreateGigaspotOrdersRequestData = CreateGigaspotOrdersRequestDataOrder[];
+export type CreateGigaspotOrdersRequestData = CreateGigaspotOrdersOrder[];
 export interface CreateGigaspotOrdersResponseData extends ResponseData {
     failed_to_oc_servers: number[];
     failed_to_rent_servers: number[];

package/build/resources/createOrder.d.ts

@@ -1,5 +1,5 @@
-import type { Currency, OrderType, ResponseData } from '../types.js';
-export interface CreateOrderRequestDataBase {
+import type { Currency, OrderType, ResponseData } from '../types.ts';
+export interface CreateOrderBase {
     type: OrderType;
     currency: Currency;
     image: string;
@@ -15,12 +15,12 @@ export interface CreateOrderRequestDataBase {
     remember_password?: boolean;
     dockerhub_auth?: string;
 }
-export interface CreateOrderRequestDataOnDemand extends CreateOrderRequestDataBase {
+export interface CreateOrderOnDemand extends CreateOrderBase {
     type: 'on-demand';
 }
-export interface CreateOrderRequestDataSpot extends CreateOrderRequestDataBase {
+export interface CreateOrderSpot extends CreateOrderBase {
     type: 'spot';
     spotprice: number;
 }
-export type CreateOrderRequestData = CreateOrderRequestDataOnDemand | CreateOrderRequestDataSpot;
+export type CreateOrderRequestData = CreateOrderOnDemand | CreateOrderSpot;
 export type CreateOrderResponseData = ResponseData;

package/build/resources/editGigaspotOrders.d.ts

@@ -1,17 +1,10 @@
-import type { ResponseData } from '../types.js';
-export interface EditGigaspotOrdersRequestDataOrderOverclock {
-    pl: number;
-    core_offset?: number;
-    mem_offset?: number;
-    core_lock?: number;
-    mem_lock?: number;
-}
-export interface EditGigaspotOrdersRequestDataOrder {
+import type { GigaspotOverclock, ResponseData } from '../types.ts';
+export interface EditGigaspotOrdersOrder {
     order_id: number;
     price: number;
-    oc: EditGigaspotOrdersRequestDataOrderOverclock[];
+    oc: GigaspotOverclock[];
 }
-export type EditGigaspotOrdersRequestData = EditGigaspotOrdersRequestDataOrder[];
+export type EditGigaspotOrdersRequestData = EditGigaspotOrdersOrder[];
 export interface EditGigaspotOrdersResponseData extends ResponseData {
     success_to_update_ids: number[];
     failed_to_update_ids: number[];

package/build/resources/getGigaspot.d.ts

@@ -1,5 +1,5 @@
-import type { Currency, Pricing, ResponseData } from '../types.js';
-export interface GetGigaspotResponseDataSnapshotServerBid {
+import type { Currency, Pricing, ResponseData } from '../types.ts';
+export interface GetGigaspotSnapshotServerBid {
     owner: number;
     id: number;
     active: boolean;
@@ -9,7 +9,7 @@ export interface GetGigaspotResponseDataSnapshotServerBid {
     currency: Currency;
     pl: number;
 }
-export interface GetGigaspotResponseDataSnapshotServerGpu {
+export interface GetGigaspotSnapshotServerGpu {
     pl: [number, number];
     mem_lock: [number, number];
     core_lock: [number, number];
@@ -17,15 +17,15 @@ export interface GetGigaspotResponseDataSnapshotServerGpu {
     core_offset: [number, number];
     model: string;
 }
-export interface GetGigaspotResponseDataSnapshotServer {
-    bids: GetGigaspotResponseDataSnapshotServerBid[];
+export interface GetGigaspotSnapshotServer {
+    bids: GetGigaspotSnapshotServerBid[];
     on_demand_rented: boolean;
     online: boolean;
     cpu: string;
     cores: number;
     threads: number;
     ram: number;
-    gpus: GetGigaspotResponseDataSnapshotServerGpu[];
+    gpus: GetGigaspotSnapshotServerGpu[];
     working_properly: boolean;
     cuda: string;
     max_rental_length: number;
@@ -35,12 +35,12 @@ export interface GetGigaspotResponseDataSnapshotServer {
     min_bid: number;
     energy_price: number;
 }
-export type GetGigaspotResponseDataSnapshot = Record<string, GetGigaspotResponseDataSnapshotServer>;
+export type GetGigaspotSnapshot = Record<string, GetGigaspotSnapshotServer>;
 export interface GetGigaspotResponseDataBase extends ResponseData {
     my_user_id: number;
     v1_snapshot_url: string;
     creation_fees: Pricing;
 }
 export interface GetGigaspotResponseData extends GetGigaspotResponseDataBase {
-    snapshot: GetGigaspotResponseDataSnapshot;
+    snapshot: GetGigaspotSnapshot;
 }

package/build/resources/marketplace.d.ts

@@ -1,5 +1,5 @@
-import type { Currency, Price, Rating, ResponseData, Specs } from '../types.js';
-export interface MarketplaceResponseDataServer {
+import type { Currency, Price, Rating, ResponseData, Specs } from '../types.ts';
+export interface MarketplaceServer {
     id: number;
     owner: number;
     autoprice?: string;
@@ -16,6 +16,5 @@ export interface MarketplaceResponseDataServer {
     cuda_version: string;
 }
 export interface MarketplaceResponseData extends ResponseData {
-    servers: MarketplaceResponseDataServer[];
-    my_servers: number[];
+    servers: MarketplaceServer[];
 }

package/build/resources/myOrders.d.ts

@@ -1,10 +1,9 @@
-import type { Currency, Rating, ResponseData, Specs } from '../types.js';
+import type { Currency, Rating, ResponseData, Specs } from '../types.ts';
 export interface MyOrdersRequestParams {
     return_completed?: boolean;
 }
-export interface MyOrdersResponseDataOrder {
+export interface MyOrdersOrder {
     id: number;
-    fee: number;
     creation_fee: number;
     price: number;
     mrl: number;
@@ -32,6 +31,6 @@ export interface MyOrdersResponseDataOrder {
     expired?: boolean;
 }
 export interface MyOrdersResponseData extends ResponseData {
-    orders: MyOrdersResponseDataOrder[];
+    orders: MyOrdersOrder[];
     limit: number;
 }

package/build/resources/myServers.d.ts

@@ -1,15 +1,16 @@
-import type { Pricing, ResponseData, Specs, Visibility } from '../types.js';
-export interface MyServersResponseDataServer {
+import type { Currency, Pricing, ResponseData, Specs, Visibility } from '../types.ts';
+export interface MyServersServer {
     name: string;
     connected: boolean;
     visibility: Visibility;
     pricing: Pricing;
     online: boolean;
     min_spot_pricing: Pricing;
-    init_token: string;
-    specs: Specs;
+    allowed_currencies: Currency[];
+    init_token?: string;
+    specs?: Specs;
 }
 export interface MyServersResponseData extends ResponseData {
-    servers: MyServersResponseDataServer[];
+    servers: MyServersServer[];
     limit: number;
 }

package/build/resources/pohBalance.d.ts

@@ -1,18 +1,18 @@
-import type { ResponseData } from '../types.js';
-export interface PohBalanceResponseDataBalanceOffers {
+import type { ResponseData } from '../types.ts';
+export interface PohBalanceOffers {
     rented_amount: number;
     rented_on_marketplace_amount: number;
     rented_finished_amount: number;
     leased_amount: number;
     leased_finished_amount: number;
 }
-export interface PohBalanceResponseDataBalance {
+export interface PohBalance {
     total: number;
     free_amount: number;
     reward_amount: number;
-    offers: PohBalanceResponseDataBalanceOffers;
+    offers: PohBalanceOffers;
 }
-export interface PohBalanceResponseDataItem {
+export interface PohBalanceItem {
     user: number;
     address: string;
     signature: string;
@@ -25,7 +25,7 @@ export interface PohBalanceResponseDataItem {
     last_check: number;
 }
 export interface PohBalanceResponseData extends ResponseData {
-    items: PohBalanceResponseDataItem[];
-    balance: PohBalanceResponseDataBalance;
+    items: PohBalanceItem[];
+    balance: PohBalance;
     count: number;
 }

package/build/resources/renterFees.d.ts

@@ -0,0 +1,22 @@
+import type { Pricing, ResponseData } from '../types.ts';
+export interface RenterFeesPohConfig {
+    max_reduction_percent: number;
+    max_poh_amount: number;
+}
+export interface RenterFeesCreationFees {
+    on_demand: Pricing;
+    spot: Pricing;
+}
+export interface RenterFees {
+    on_demand: RenterFee;
+    spot: RenterFee;
+}
+export interface RenterFee {
+    base: Pricing;
+}
+export interface RenterFeesResponseData extends ResponseData {
+    renter_fees: RenterFees;
+    poh_config: RenterFeesPohConfig;
+    creation_fees: RenterFeesCreationFees;
+    poh_balance: number;
+}

package/build/resources/renterFees.js

@@ -0,0 +1 @@
+export {};

package/build/resources/serverConfig.d.ts

@@ -1,14 +1,14 @@
-import type { Pricing, ResponseData, Specs, Visibility } from '../types.js';
+import type { AutoPrice, Currency, Pricing, PricingInOriginalUsd, ResponseData, Specs, Visibility } from '../types.ts';
 export interface ServerConfigRequestData {
     server_name: string;
 }
-export interface ServerConfigResponseDataConfigBackgroundJob {
+export interface ServerConfigBackgroundJob {
     times_updated: number;
     image: string;
     command: string;
     env: Record<string, string>;
 }
-export interface ServerConfigResponseDataConfig {
+export interface ServerConfig {
     name: string;
     connected: boolean;
     visibility: Visibility;
@@ -20,9 +20,12 @@ export interface ServerConfigResponseDataConfig {
     id: number;
     rental_status: number;
     specs: Specs;
-    background_job: ServerConfigResponseDataConfigBackgroundJob;
+    background_job: ServerConfigBackgroundJob;
+    allowed_coins: Currency[];
+    autoprice: AutoPrice;
+    usd_pricing: PricingInOriginalUsd;
 }
 export interface ServerConfigResponseData extends ResponseData {
-    config: ServerConfigResponseDataConfig;
+    config: ServerConfig;
     creation_completed: boolean;
 }

package/build/resources/setServerSettings.d.ts

@@ -1,11 +1,18 @@
-import type { ResponseData } from '../types.js';
+import type { AutoPrice, PricingInOriginalUsd, ResponseData } from '../types.ts';
 export interface SetServerSettingsRequestData {
     'name': string;
     'availability': boolean;
     'mrl': number;
-    'on_demand': number;
-    'spot': number;
-    'CLORE-Blockchain_on_demand': number;
-    'CLORE-Blockchain_spot': number;
+    'bitcoin_on_demand': number;
+    'bitcoin_spot': number;
+    'CLORE-Blockchain_on_demand'?: number;
+    'CLORE-Blockchain_spot'?: number;
+    'USD-Blockchain_on_demand'?: number;
+    'USD-Blockchain_spot'?: number;
+    'enabled-USD-Blockchain'?: boolean;
+    'enabled-CLORE-Blockchain'?: boolean;
+    'enabled-bitcoin'?: boolean;
+    'autoprice'?: AutoPrice;
+    'usd_pricing'?: PricingInOriginalUsd;
 }
 export type SetServerSettingsResponseData = ResponseData;

package/build/resources/setSpotPrice.d.ts

@@ -1,17 +1,15 @@
-import type { ResponseData } from '../types.js';
+import type { ResponseData } from '../types.ts';
 export interface SetSpotPriceRequestData {
     order_id: number;
     desired_price: number;
 }
-export interface SetSpotPriceResponseDataMaxStep extends ResponseData {
+export interface SetSpotPriceMaxStep extends ResponseData {
     error: 'exceeded_max_step';
     max_step: number;
 }
-export interface SetSpotPriceResponseDataTimeToLowering extends ResponseData {
+export interface SetSpotPriceTimeToLowering extends ResponseData {
     error: 'can_lower_every_600_seconds';
     time_to_lowering: number;
 }
-export interface SetSpotPriceResponseDataNormal extends ResponseData {
-    error: null;
-}
-export type SetSpotPriceResponseData = SetSpotPriceResponseDataMaxStep | SetSpotPriceResponseDataTimeToLowering | SetSpotPriceResponseDataNormal;
+export type SetSpotPriceNormal = Omit<ResponseData, 'error'>;
+export type SetSpotPriceResponseData = SetSpotPriceMaxStep | SetSpotPriceTimeToLowering | SetSpotPriceNormal;

package/build/resources/setSpotPrice.js

@@ -1,2 +1 @@
-/* RequestData */
 export {};

package/build/resources/spotMarketplace.d.ts

@@ -1,26 +1,26 @@
-import type { Currency, Pricing, ResponseData, Visibility } from '../types.js';
+import type { Currency, Pricing, ResponseData, Visibility } from '../types.ts';
 export interface SpotMarketplaceRequestParams {
     market: number;
 }
-export interface SpotMarketplaceResponseDataOffer {
-    active: boolean;
+export interface SpotMarketplaceMarketOffer {
+    offer_id: number;
     bid: number;
-    currency: Currency;
+    active: boolean;
     my: boolean;
-    offer_id: number;
+    currency: Currency;
 }
-export interface SpotMarketplaceResponseDataServer {
+export interface SpotMarketplaceMarketServer {
     min_pricing: Pricing;
     mrl: number;
     online: boolean;
     visibility: Visibility;
 }
-export interface SpotMarketplaceResponseDataMarket {
+export interface SpotMarketplaceMarket {
     currency_rates_in_usd: Pricing;
-    offers: SpotMarketplaceResponseDataOffer[];
-    server: SpotMarketplaceResponseDataServer;
+    offers: SpotMarketplaceMarketOffer[];
+    server: SpotMarketplaceMarketServer;
 }
 export interface SpotMarketplaceResponseData extends ResponseData {
-    market: SpotMarketplaceResponseDataMarket;
+    market: SpotMarketplaceMarket;
     exists: boolean;
 }

package/build/resources/wallets.d.ts

@@ -1,10 +1,10 @@
-import type { Currency, ResponseData } from '../types.js';
-export interface WalletsResponseDataWallet {
+import type { Currency, ResponseData } from '../types.ts';
+export interface Wallet {
     name: Currency;
     deposit: string;
     balance: number;
     withdrawal_fee: number;
 }
 export interface WalletsResponseData extends ResponseData {
-    wallets: WalletsResponseDataWallet[];
+    wallets: Wallet[];
 }

package/build/types.d.ts

@@ -1,37 +1,26 @@
-import type { CreateAxiosDefaults } from 'axios';
-import type { Options as PQueueOptions, Queue, QueueAddOptions } from 'p-queue';
-export type QueueOptions = PQueueOptions<Queue<() => Promise<unknown>, QueueAddOptions>, QueueAddOptions>;
-export interface Options {
-    axiosOptions?: CreateAxiosDefaults;
-    queueOptions?: QueueOptions;
-    queueOptionsCreateOrder?: QueueOptions;
-    queueOptionsGigaspot?: QueueOptions;
-}
 export interface ResponseData {
     code: number;
-    error?: string | null;
+    error?: string;
 }
 export type OrderType = 'on-demand' | 'spot';
 export type Visibility = 'public' | 'hidden';
-export type Currency = 'CLORE-Blockchain' | 'bitcoin';
-export interface Pricing {
-    'CLORE-Blockchain': number;
-    'bitcoin': number;
-    'usd'?: number;
-}
+export type Currency = 'CLORE-Blockchain' | 'USD-Blockchain' | 'bitcoin';
+export type Pricing = Partial<Record<Currency, number>>;
+export type AutoPrice = Partial<Record<Currency, 'usd' | false>>;
+export type PricingInOriginalUsd = Partial<Record<Currency, {
+    on_demand: number;
+    spot: number;
+}>>;
 export interface PricingInUsd {
-    on_demand_btc: number;
     on_demand_clore: number;
-    spot: number;
-}
-export interface PricingInOriginalUsd {
-    on_demand: number;
+    on_demand_usd: number;
+    on_demand_btc: number;
     spot: number;
 }
 export interface Price {
     on_demand: Pricing;
     spot: Pricing;
-    usd?: PricingInUsd;
+    usd: PricingInUsd;
     original_usd?: PricingInOriginalUsd;
 }
 export interface Net {
@@ -77,3 +66,10 @@ export interface Rating {
     avg: number;
     cnt: number;
 }
+export interface GigaspotOverclock {
+    pl: number;
+    core_offset?: number;
+    mem_offset?: number;
+    core_lock?: number;
+    mem_lock?: number;
+}

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "cloreai",
-  "version": "2.0.0",
-  "type": "module",
+  "version": "3.0.0",
   "description": "CLORE.AI API client",
+  "keywords": [
+    "cloreai",
+    "clore",
+    "api"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vladpuz/cloreai.git"
   },
-  "author": "Vladislav Puzyrev",
   "license": "MIT",
+  "author": "Vladislav Puzyrev",
+  "type": "module",
   "main": "build/index.js",
   "types": "build/index.d.ts",
-  "keywords": [
-    "cloreai",
-    "clore",
-    "api"
-  ],
   "scripts": {
     "build": "tsc --project tsconfig.build.json",
     "check": "npm run typecheck && npm run lint && npm run format",
@@ -27,19 +27,20 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "axios": "^1.10.0",
-    "p-queue": "^8.1.0"
+    "axios": "^1.13.5",
+    "p-queue": "^9.1.0"
   },
   "devDependencies": {
-    "@tsconfig/node-lts": "^22.0.2",
-    "@tsconfig/strictest": "^2.0.5",
-    "@types/node": "^24.0.12",
-    "eslint": "^9.30.1",
-    "eslint-config-vladpuz": "^2.0.2",
+    "@tsconfig/node-lts": "^24.0.0",
+    "@tsconfig/node-ts": "^23.6.4",
+    "@tsconfig/strictest": "^2.0.8",
+    "@types/node": "^25.3.0",
+    "eslint": "^9.39.3",
+    "eslint-config-vladpuz": "^2.5.1",
     "husky": "^9.1.7",
-    "prettier": "^3.6.2",
-    "prettier-config-vladpuz": "^1.0.2",
-    "rimraf": "^6.0.1",
-    "typescript": "^5.8.3"
+    "prettier": "^3.8.1",
+    "prettier-config-vladpuz": "^2.0.0",
+    "rimraf": "^6.1.3",
+    "typescript": "^5.9.3"
   }
 }

package/build/errors.d.ts

@@ -1,22 +0,0 @@
-import { AxiosError } from 'axios';
-export declare class DatabaseError extends AxiosError {
-    constructor(...args: ConstructorParameters<typeof AxiosError>);
-}
-export declare class InvalidInputDataError extends AxiosError {
-    constructor(...args: ConstructorParameters<typeof AxiosError>);
-}
-export declare class InvalidApiTokenError extends AxiosError {
-    constructor(...args: ConstructorParameters<typeof AxiosError>);
-}
-export declare class InvalidEndpointError extends AxiosError {
-    constructor(...args: ConstructorParameters<typeof AxiosError>);
-}
-export declare class ExceededError extends AxiosError {
-    constructor(...args: ConstructorParameters<typeof AxiosError>);
-}
-export declare class OtherError extends AxiosError {
-    constructor(...args: ConstructorParameters<typeof AxiosError>);
-}
-export declare class UnknownError extends AxiosError {
-    constructor(...args: ConstructorParameters<typeof AxiosError>);
-}

package/build/errors.js

@@ -1,43 +0,0 @@
-import { AxiosError } from 'axios';
-export class DatabaseError extends AxiosError {
-    constructor(...args) {
-        super(...args);
-        this.name = 'DatabaseError';
-    }
-}
-export class InvalidInputDataError extends AxiosError {
-    constructor(...args) {
-        super(...args);
-        this.name = 'InvalidInputDataError';
-    }
-}
-export class InvalidApiTokenError extends AxiosError {
-    constructor(...args) {
-        super(...args);
-        this.name = 'InvalidApiTokenError';
-    }
-}
-export class InvalidEndpointError extends AxiosError {
-    constructor(...args) {
-        super(...args);
-        this.name = 'InvalidEndpointError';
-    }
-}
-export class ExceededError extends AxiosError {
-    constructor(...args) {
-        super(...args);
-        this.name = 'ExceededError';
-    }
-}
-export class OtherError extends AxiosError {
-    constructor(...args) {
-        super(...args);
-        this.name = 'OtherError';
-    }
-}
-export class UnknownError extends AxiosError {
-    constructor(...args) {
-        super(...args);
-        this.name = 'UnknownError';
-    }
-}