cloreai 1.0.1 → 3.0.0

package/README.md

@@ -2,37 +2,38 @@
 
 > CLORE.AI API client
 
-Особенности:
+Features:
 
-- Базируется на [axios](https://github.com/axios/axios)
-- Защищает от превышения rate limit (ошибки 429) через
+- Based on [axios](https://github.com/axios/axios)
+- Protects from rate limit exceeded (429 errors) via
   [p-queue](https://github.com/sindresorhus/p-queue)
-- Поддерживает GigaSPOT
+- User-friendly error handling
+- Full typing
+- Supports GigaSPOT
 
-Официальная документация: [clore.ai/api-docs](https://clore.ai/api-docs)
+Official documentation: [clore.ai/api-docs](https://clore.ai/api-docs)
 
-Официальная документация GigaSPOT:
+Official GigaSPOT documentation:
 [gigaspot-api-docs.clore.ai](https://gigaspot-api-docs.clore.ai)
 
-## Установка
+## Installation
 
 ```shell
 npm install cloreai
 ```
 
-## Использование
+## Usage
 
-### Создание экземпляра
+### Creating an instance
 
 ```typescript
-import CloreAI from 'cloreai'
+import Cloreai from 'cloreai'
 
-const cloreai = new CloreAI({
-  apiKey: '<API_KEY>', // (required)
+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
@@ -184,10 +206,10 @@ await cloreai.gigaspot.cancelOrders({
 })
 ```
 
-### Конфигурация запросов
+### Request Configuration
 
-Каждый метод принимает опциональную конфигурацию запроса для axios последним
-параметром, например:
+All methods accept an optional request configuration for axios as the last
+parameter, for example:
 
 ```typescript
 const marketplace = await cloreai.marketplace({
@@ -195,50 +217,42 @@ const marketplace = await cloreai.marketplace({
 })
 ```
 
-### Доступ к экземпляру axios
-
-Используйте поле `cloreai.axios`.
+### Access to axios instance
 
-Обратитесь к документации [axios](https://github.com/axios/axios).
+Use the field `cloreai.axios`.
 
-### Доступ к экземплярам p-queue
+Refer to the documentation [axios](https://github.com/axios/axios).
 
-Используйте поля:
+### Access to p-queue instances
 
-- `cloreai.queue` - для основной очереди запросов
-- `cloreai.queueCreateOrder` - для очереди запросов createOrder
-- `cloreai.gigaspot.queue` - для очереди запросов gigaspot
+Use the fields:
 
-Обратитесь к документации [p-queue](https://github.com/sindresorhus/p-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
 
-- `DatabaseError`
-- `InvalidInputDataError`
-- `InvalidApiTokenError`
-- `InvalidEndpointError`
-- `ExceededError`
-- `OtherError`
-- `UnknownError`
+Use the `CloreaiError` class for error handling.
 
-Все эти ошибки наследуются от `AxiosError`.
+This class inherits from `AxiosError` and has additional fields with error
+information `error.code` and `error.error`.
 
-Проверяйте тип ошибки через оператор `instanceof`:
+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 instanceof ExceededError) {
-      console.log('ExceededError')
+    if (error.code === statusCodes.EXCEEDED) {
+      console.log('Rate limit exceeded error')
     }
   } else {
     throw error
@@ -248,11 +262,11 @@ try {
 
 ### Rate limit
 
-Все методы защищены от превышения rate limit через
-[p-queue](https://github.com/sindresorhus/p-queue), они автоматически
-задерживаются на нужное время, чтобы избежать превышения лимита.
+All methods are protected from rate limit exceeded via
+[p-queue](https://github.com/sindresorhus/p-queue), they automatically delay for
+the required time to avoid exceeding the limit.
 
-Значения rate limit по умолчанию доступны как константы:
+Default rate limit values are available as constants:
 
 ```typescript
 import {
@@ -266,21 +280,20 @@ console.log(RATE_LIMIT_CREATE_ORDER)
 console.log(RATE_LIMIT_GIGASPOT)
 ```
 
-Можно задать собственные значение rate limit для каждой очереди запросов:
+You can set custom rate limit values for each request queue:
 
 ```typescript
-import CloreAI from 'cloreai'
+import Cloreai from 'cloreai'
 
-const cloreai = new CloreAI({
-  apiKey: '<API_KEY>',
+const cloreai = new Cloreai('API_KEY', {
   queueOptions: {
-    interval: 10000, // 10 seconds
+    interval: 2000, // For example 2 seconds
   },
-  queueOptionsCreateOrder: {
-    interval: 10000, // 10 seconds
+  queueCreateOrderOptions: {
+    interval: 6000, // For example 6 seconds
   },
-  queueOptionsGigaspot: {
-    interval: 10000, // 10 seconds
+  queueGigaspotOptions: {
+    interval: 2000, // For example 2 seconds
   },
 })
 ```

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

@@ -1,24 +1,31 @@
-import { type AxiosInstance, type AxiosRequestConfig } from 'axios';
-import PQueue from 'p-queue';
-import type { CancelOrderRequestData, CancelOrderResponseData } from './endpoints/cancelOrder.js';
-import type { CreateOrderRequestData, CreateOrderResponseData } from './endpoints/createOrder.js';
-import type { MarketplaceResponseData } from './endpoints/marketplace.js';
-import type { MyOrdersRequestParams, MyOrdersResponseData } from './endpoints/myOrders.js';
-import type { MyServersResponseData } from './endpoints/myServers.js';
-import type { PohBalanceResponseData } from './endpoints/pohBalance.js';
-import type { ServerConfigRequestData, ServerConfigResponseData } from './endpoints/serverConfig.js';
-import type { SetServerSettingsRequestData, SetServerSettingsResponseData } from './endpoints/setServerSettings.js';
-import type { SetSpotPriceRequestData, SetSpotPriceResponseData } from './endpoints/setSpotPrice.js';
-import type { SpotMarketplaceRequestParams, SpotMarketplaceResponseData } from './endpoints/spotMarketplace.js';
-import type { WalletsResponseData } from './endpoints/wallets.js';
-import type { Config } 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;
     gigaspot: Gigaspot;
-    constructor(config: Config);
+    constructor(apiKey: string, options?: Options);
     wallets(config?: AxiosRequestConfig): Promise<WalletsResponseData>;
     myServers(config?: AxiosRequestConfig): Promise<MyServersResponseData>;
     serverConfig(data: ServerConfigRequestData, config?: AxiosRequestConfig): Promise<ServerConfigResponseData>;
@@ -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,133 +1,125 @@
-import axios from 'axios';
-import PQueue from 'p-queue';
-import { RATE_LIMIT, RATE_LIMIT_CREATE_ORDER } from './constants.js';
-import { DatabaseError, ExceededError, InvalidApiTokenError, InvalidEndpointError, InvalidInputDataError, OtherError, UnknownError } from './errors.js';
-import Gigaspot from './Gigaspot.js';
-import { getQueueOptions, priorityLevels, statusCodes } from './helpers.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;
     gigaspot;
-    constructor(config) {
+    constructor(apiKey, options = {}) {
         this.queue = new PQueue({
             interval: RATE_LIMIT,
             intervalCap: 1,
             concurrency: 1,
-            ...config.queueOptions,
+            ...options.queueOptions,
         });
         this.queueCreateOrder = new PQueue({
             interval: RATE_LIMIT_CREATE_ORDER,
             intervalCap: 1,
             concurrency: 1,
-            ...config.queueOptionsCreateOrder,
+            ...options.queueCreateOrderOptions,
         });
         this.axios = axios.create({
-            ...config.axiosOptions,
             baseURL: 'https://api.clore.ai/v1',
+            ...options.axiosOptions,
         });
         this.axios.interceptors.request.use((request) => {
-            request.headers.set('auth', config.apiKey);
+            request.headers.set('auth', apiKey);
             return request;
         });
         this.axios.interceptors.response.use((response) => {
             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(config, this.axios);
+        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,14 +1,14 @@
 import { type AxiosInstance, type AxiosRequestConfig } from 'axios';
 import PQueue from 'p-queue';
-import type { CancelOrdersRequestData, CancelOrdersResponseData } from './endpoints/cancelOrders.js';
-import type { CreateGigaspotOrdersRequestData, CreateGigaspotOrdersResponseData } from './endpoints/createGigaspotOrders.js';
-import type { EditGigaspotOrdersRequestData, EditGigaspotOrdersResponseData } from './endpoints/editGigaspotOrders.js';
-import type { GetGigaspotResponseData } from './endpoints/getGigaspot.js';
-import type { Config } 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 readonly axios;
-    constructor(config: Config, axios: AxiosInstance);
+    constructor(options: Options, axios: AxiosInstance);
     getGigaspot(config?: AxiosRequestConfig): Promise<GetGigaspotResponseData>;
     createGigaspotOrders(data: CreateGigaspotOrdersRequestData, config?: AxiosRequestConfig): Promise<CreateGigaspotOrdersResponseData>;
     editGigaspotOrders(data: EditGigaspotOrdersRequestData, config?: AxiosRequestConfig): Promise<EditGigaspotOrdersResponseData>;

package/build/Gigaspot.js

@@ -1,16 +1,16 @@
-import axios from 'axios';
+import axios, {} from 'axios';
 import PQueue from 'p-queue';
-import { RATE_LIMIT_GIGASPOT } from './constants.js';
-import { getQueueOptions, priorityLevels } from './helpers.js';
+import { priorityLevels, RATE_LIMIT_GIGASPOT } from "./constants.js";
+import { getQueueOptions } from "./getQueueOptions.js";
 class Gigaspot {
-    queue;
     axios;
-    constructor(config, axios) {
+    queue;
+    constructor(options, axios) {
         this.queue = new PQueue({
             interval: RATE_LIMIT_GIGASPOT,
             intervalCap: 1,
             concurrency: 1,
-            ...config.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,7 +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 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,7 +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 = Object.freeze({
+    NORMAL: 0,
+    DATABASE_ERROR: 1,
+    INVALID_INPUT_DATA: 2,
+    INVALID_API_TOKEN: 3,
+    INVALID_ENDPOINT: 4,
+    EXCEEDED: 5,
+    CUSTOM: 6,
+});
+export const priorityLevels = Object.freeze({
+    NORMAL: 0,
+    HIGH: 1,
+    HIGHEST: 2,
+});

package/build/getQueueOptions.d.ts

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