cloreai 0.1.12 → 0.1.14

package/build/cloreai/CloreAI.d.ts

@@ -1,30 +1,30 @@
 import { type AxiosInstance, type AxiosRequestConfig } from 'axios';
-import PQueue, { type QueueAddOptions } from 'p-queue';
-import type { CancelOrderBody, CancelOrderOutput } from './endpoints/cancelOrder.js';
-import type { CreateOrderBody, CreateOrderOutput } from './endpoints/createOrder.js';
-import type { MarketplaceOutput } from './endpoints/marketplace.js';
-import type { MyOrdersOutput, MyOrdersParams } from './endpoints/myOrders.js';
-import type { MyServersOutput } from './endpoints/myServers.js';
-import type { ServerConfigBody, ServerConfigOutput } from './endpoints/serverConfig.js';
-import type { SetServerSettingsBody, SetServerSettingsOutput } from './endpoints/setServerSettings.js';
-import type { SetSpotPriceBody, SetSpotPriceOutput } from './endpoints/setSpotPrice.js';
-import type { SpotMarketplaceOutput, SpotMarketplaceParams } from './endpoints/spotMarketplace.js';
-import type { WalletsOutput } from './endpoints/wallets.js';
+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 { 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';
 declare class CloreAI {
-    readonly axios: AxiosInstance;
-    readonly rateLimitQueue: PQueue;
-    readonly rateLimitCreateOrderQueue: PQueue;
+    axios: AxiosInstance;
+    rateLimitQueue: PQueue;
+    rateLimitQueueCreateOrder: PQueue;
     constructor(config: Config);
-    wallets(axiosConfig?: AxiosRequestConfig, queueOptions?: QueueAddOptions): Promise<WalletsOutput>;
-    myServers(axiosConfig?: AxiosRequestConfig, queueOptions?: QueueAddOptions): Promise<MyServersOutput>;
-    serverConfig(body: ServerConfigBody, axiosConfig?: AxiosRequestConfig<ServerConfigBody>, queueOptions?: QueueAddOptions): Promise<ServerConfigOutput>;
-    marketplace(axiosConfig?: AxiosRequestConfig, queueOptions?: QueueAddOptions): Promise<MarketplaceOutput>;
-    myOrders(params?: MyOrdersParams, axiosConfig?: AxiosRequestConfig, queueOptions?: QueueAddOptions): Promise<MyOrdersOutput>;
-    spotMarketplace(params: SpotMarketplaceParams, axiosConfig?: AxiosRequestConfig, queueOptions?: QueueAddOptions): Promise<SpotMarketplaceOutput>;
-    setServerSettings(body: SetServerSettingsBody, axiosConfig?: AxiosRequestConfig<SetServerSettingsBody>, queueOptions?: QueueAddOptions): Promise<SetServerSettingsOutput>;
-    setSpotPrice(body: SetSpotPriceBody, axiosConfig?: AxiosRequestConfig<SetSpotPriceBody>, queueOptions?: QueueAddOptions): Promise<SetSpotPriceOutput>;
-    cancelOrder(body: CancelOrderBody, axiosConfig?: AxiosRequestConfig<CancelOrderBody>, queueOptions?: QueueAddOptions): Promise<CancelOrderOutput>;
-    createOrder(body: CreateOrderBody, axiosConfig?: AxiosRequestConfig<CreateOrderBody>, queueOptions?: QueueAddOptions): Promise<CreateOrderOutput>;
+    wallets(config?: AxiosRequestConfig): Promise<WalletsResponseData>;
+    myServers(config?: AxiosRequestConfig): Promise<MyServersResponseData>;
+    serverConfig(data: ServerConfigRequestData, config?: AxiosRequestConfig): Promise<ServerConfigResponseData>;
+    marketplace(config?: AxiosRequestConfig): Promise<MarketplaceResponseData>;
+    myOrders(params: MyOrdersRequestParams, config?: AxiosRequestConfig): Promise<MyOrdersResponseData>;
+    spotMarketplace(params: SpotMarketplaceRequestParams, config?: AxiosRequestConfig): Promise<SpotMarketplaceResponseData>;
+    setServerSettings(data: SetServerSettingsRequestData, config?: AxiosRequestConfig): Promise<SetServerSettingsResponseData>;
+    setSpotPrice(data: SetSpotPriceRequestData, config?: AxiosRequestConfig): Promise<SetSpotPriceResponseData>;
+    cancelOrder(data: CancelOrderRequestData, config?: AxiosRequestConfig): Promise<CancelOrderResponseData>;
+    createOrder(data: CreateOrderRequestData, config?: AxiosRequestConfig): Promise<CreateOrderResponseData>;
 }
 export default CloreAI;

package/build/cloreai/CloreAI.js

@@ -1,28 +1,32 @@
 import axios from 'axios';
 import PQueue from 'p-queue';
-import { CustomError, DatabaseError, ExceededError, InvalidApiTokenError, InvalidEndpointError, InvalidInputDataError, UnknownError } from '../common/errors.js';
-import { getErrorMessage, RATE_LIMIT, RATE_LIMIT_CREATE_ORDER, statusCodes } from '../common/index.js';
+import { priorityLevels, RATE_LIMIT, RATE_LIMIT_CREATE_ORDER, statusCodes } from '../common/constants.js';
+import { DatabaseError, ExceededError, InvalidApiTokenError, InvalidEndpointError, InvalidInputDataError, OtherError, UnknownError } from '../common/errors.js';
+import { getErrorMessage, getQueueOptions } from '../common/helpers.js';
 class CloreAI {
     axios;
-    rateLimitQueue = new PQueue({
-        interval: RATE_LIMIT,
-        intervalCap: 1,
-        concurrency: 1,
-    });
-    rateLimitCreateOrderQueue = new PQueue({
-        interval: RATE_LIMIT_CREATE_ORDER,
-        intervalCap: 1,
-        concurrency: 1,
-    });
+    rateLimitQueue;
+    rateLimitQueueCreateOrder;
     constructor(config) {
-        const { apiKey, axiosConfig = {} } = config;
+        this.rateLimitQueue = new PQueue({
+            interval: RATE_LIMIT,
+            intervalCap: 1,
+            concurrency: 1,
+            ...config.rateLimitQueueOptions,
+        });
+        this.rateLimitQueueCreateOrder = new PQueue({
+            interval: RATE_LIMIT_CREATE_ORDER,
+            intervalCap: 1,
+            concurrency: 1,
+            ...config.rateLimitQueueOptionsCreateOrder,
+        });
         this.axios = axios.create({
-            ...axiosConfig,
+            ...config.axiosConfig,
             baseURL: 'https://api.clore.ai/v1',
-            headers: {
-                ...axiosConfig.headers,
-                auth: apiKey,
-            },
+        });
+        this.axios.interceptors.request.use((request) => {
+            request.headers.set('auth', config.apiKey);
+            return request;
         });
         this.axios.interceptors.response.use((response) => {
             if (response.data.code === statusCodes.NORMAL) {
@@ -47,81 +51,71 @@ class CloreAI {
                     throw new InvalidEndpointError(...axiosErrorParameters);
                 case statusCodes.EXCEEDED:
                     throw new ExceededError(...axiosErrorParameters);
-                case statusCodes.ERROR:
-                    throw new CustomError(...axiosErrorParameters);
+                case statusCodes.OTHER:
+                    throw new OtherError(...axiosErrorParameters);
                 default:
                     throw new UnknownError(...axiosErrorParameters);
             }
         });
     }
-    async wallets(axiosConfig, queueOptions) {
+    async wallets(config) {
         const response = await this.rateLimitQueue.add(async () => {
-            return await this.axios.get('/wallets', axiosConfig);
-        }, { ...queueOptions, throwOnTimeout: true });
+            return await this.axios.get('/wallets', config);
+        }, getQueueOptions(priorityLevels.NORMAL, config));
         return response.data;
     }
-    async myServers(axiosConfig, queueOptions) {
+    async myServers(config) {
         const response = await this.rateLimitQueue.add(async () => {
-            return await this.axios.get('/my_servers', axiosConfig);
-        }, { ...queueOptions, throwOnTimeout: true });
+            return await this.axios.get('/my_servers', config);
+        }, getQueueOptions(priorityLevels.NORMAL, config));
         return response.data;
     }
-    async serverConfig(body, axiosConfig, queueOptions) {
+    async serverConfig(data, config) {
         const response = await this.rateLimitQueue.add(async () => {
-            return await this.axios.get('/server_config', { ...axiosConfig, data: body });
-        }, { ...queueOptions, throwOnTimeout: true });
+            return await this.axios.get('/server_config', { ...config, data });
+        }, getQueueOptions(priorityLevels.NORMAL, config));
         return response.data;
     }
-    async marketplace(axiosConfig, queueOptions) {
+    async marketplace(config) {
         const response = await this.rateLimitQueue.add(async () => {
-            return await this.axios.get('/marketplace', axiosConfig);
-        }, { ...queueOptions, throwOnTimeout: true });
+            return await this.axios.get('/marketplace', config);
+        }, getQueueOptions(priorityLevels.NORMAL, config));
         return response.data;
     }
-    async myOrders(params, axiosConfig, queueOptions) {
+    async myOrders(params, config) {
         const response = await this.rateLimitQueue.add(async () => {
-            return await this.axios.get('/my_orders', { ...axiosConfig, params });
-        }, { ...queueOptions, throwOnTimeout: true });
+            return await this.axios.get('/my_orders', { ...config, params });
+        }, getQueueOptions(priorityLevels.NORMAL, config));
         return response.data;
     }
-    async spotMarketplace(params, axiosConfig, queueOptions) {
+    async spotMarketplace(params, config) {
         const response = await this.rateLimitQueue.add(async () => {
-            return await this.axios.get('/spot_marketplace', { ...axiosConfig, params });
-        }, { ...queueOptions, throwOnTimeout: true });
+            return await this.axios.get('/spot_marketplace', { ...config, params });
+        }, getQueueOptions(priorityLevels.NORMAL, config));
         return response.data;
     }
-    async setServerSettings(body, axiosConfig, queueOptions) {
+    async setServerSettings(data, config) {
         const response = await this.rateLimitQueue.add(async () => {
-            return await this.axios.post('/set_server_settings', body, axiosConfig);
-        }, { ...queueOptions, throwOnTimeout: true });
+            return await this.axios.post('/set_server_settings', data, config);
+        }, getQueueOptions(priorityLevels.HIGH, config));
         return response.data;
     }
-    async setSpotPrice(body, axiosConfig, queueOptions) {
+    async setSpotPrice(data, config) {
         const response = await this.rateLimitQueue.add(async () => {
-            return await this.axios.post('/set_spot_price', body, axiosConfig);
-        }, { ...queueOptions, throwOnTimeout: true });
+            return await this.axios.post('/set_spot_price', data, config);
+        }, getQueueOptions(priorityLevels.HIGH, config));
         return response.data;
     }
-    async cancelOrder(body, axiosConfig, queueOptions) {
+    async cancelOrder(data, config) {
         const response = await this.rateLimitQueue.add(async () => {
-            return await this.axios.post('/cancel_order', body, axiosConfig);
-        }, { ...queueOptions, throwOnTimeout: true });
+            return await this.axios.post('/cancel_order', data, config);
+        }, getQueueOptions(priorityLevels.HIGH, config));
         return response.data;
     }
-    async createOrder(body, axiosConfig, queueOptions) {
-        const response = await this.rateLimitQueue.add(async () => {
-            this.rateLimitQueue.pause();
-            try {
-                return await this.rateLimitCreateOrderQueue.add(async () => {
-                    return await this.axios.post('/create_order', body, axiosConfig);
-                }, { ...queueOptions, throwOnTimeout: true });
-            }
-            finally {
-                setTimeout(() => {
-                    this.rateLimitQueue.start();
-                }, RATE_LIMIT);
-            }
-        }, { ...queueOptions, throwOnTimeout: true });
+    async createOrder(data, config) {
+        const response = await this.rateLimitQueueCreateOrder.add(async () => {
+            return await this.axios.post('/create_order', data, config);
+        }, getQueueOptions(priorityLevels.HIGHEST, config));
         return response.data;
     }
 }

package/build/cloreai/endpoints/cancelOrder.d.ts

@@ -1,7 +1,6 @@
-import type { Output } from '../types.js';
-export interface CancelOrderBody {
-    id: number;
+import type { CancelOrderRequestDataCommon } from '../../common/endpoints/cancelOrder.js';
+import type { ResponseData } from '../types.js';
+export interface CancelOrderRequestData extends CancelOrderRequestDataCommon {
     issue?: string;
 }
-export interface CancelOrderOutput extends Output {
-}
+export type CancelOrderResponseData = ResponseData;

package/build/cloreai/endpoints/createOrder.d.ts

@@ -1,26 +1,4 @@
-import type { Currency, OrderType } from '../../common/index.js';
-import type { Output } from '../types.js';
-export interface CreateOrderCommon {
-    type: OrderType;
-    currency: Currency;
-    image: string;
-    renting_server: number;
-    ports?: Record<string, string>;
-    env?: Record<string, string>;
-    jupyter_token?: string;
-    ssh_key?: string;
-    ssh_password?: string;
-    command?: string;
-    required_price?: number;
-    autossh_entrypoint?: boolean;
-}
-export interface CreateOrderOnDemand extends CreateOrderCommon {
-    type: 'on-demand';
-}
-export interface CreateOrderSpot extends CreateOrderCommon {
-    type: 'spot';
-    spotprice: number;
-}
-export type CreateOrderBody = CreateOrderOnDemand | CreateOrderSpot;
-export interface CreateOrderOutput extends Output {
-}
+import type { CreateOrderRequestDataCommon } from '../../common/endpoints/createOrder.js';
+import type { ResponseData } from '../types.js';
+export type CreateOrderRequestData = CreateOrderRequestDataCommon;
+export type CreateOrderResponseData = ResponseData;

package/build/cloreai/endpoints/marketplace.d.ts

@@ -1,14 +1,6 @@
-import type { Price, Specs } from '../../common/index.js';
-import type { Output } from '../types.js';
-export interface MarketplaceServer {
-    id: number;
-    owner: number;
-    mrl: number;
-    price: Price;
-    rented: boolean;
-    specs: Specs;
-}
-export interface MarketplaceOutput extends Output {
-    servers: MarketplaceServer[];
+import type { MarketplaceResponseDataServerCommon } from '../../common/endpoints/marketplace.js';
+import type { ResponseData } from '../types.js';
+export interface MarketplaceResponseData extends ResponseData {
+    servers: MarketplaceResponseDataServerCommon[];
     my_servers: number[];
 }

package/build/cloreai/endpoints/myOrders.d.ts

@@ -1,28 +1,9 @@
-import type { Currency, Specs } from '../../common/index.js';
-import type { Output } from '../types.js';
-export interface MyOrdersParams {
+import type { MyOrdersResponseDataOrderCommon } from '../../common/endpoints/myOrders.js';
+import type { ResponseData } from '../types.js';
+export interface MyOrdersRequestParams {
     return_completed?: boolean;
 }
-export interface MyOrdersOrder {
-    id: number;
-    fee: number;
-    creation_fee: number;
-    price: number;
-    mrl: number;
-    image: string;
-    currency: Currency;
-    spend: number;
-    ct: number;
-    p: number;
-    specs: Specs;
-    si: number;
-    pub_cluster: string[];
-    tcp_ports: string[];
-    http_port: string;
-    spot: boolean;
-    expired: boolean;
-}
-export interface MyOrdersOutput extends Output {
-    orders: MyOrdersOrder[];
+export interface MyOrdersResponseData extends ResponseData {
+    orders: MyOrdersResponseDataOrderCommon[];
     limit: number;
 }

package/build/cloreai/endpoints/myServers.d.ts

@@ -1,6 +1,6 @@
-import type { Pricing, Specs, Visibility } from '../../common/index.js';
-import type { Output } from '../types.js';
-export interface MyServersServer {
+import type { Pricing, Specs, Visibility } from '../../common/types.js';
+import type { ResponseData } from '../types.js';
+export interface MyServersResponseDataServer {
     name: string;
     connected: boolean;
     visibility: Visibility;
@@ -10,7 +10,7 @@ export interface MyServersServer {
     init_token: string;
     specs: Specs;
 }
-export interface MyServersOutput extends Output {
-    servers: MyServersServer[];
+export interface MyServersResponseData extends ResponseData {
+    servers: MyServersResponseDataServer[];
     limit: number;
 }

package/build/cloreai/endpoints/serverConfig.d.ts

@@ -1,15 +1,15 @@
-import type { Pricing, Specs, Visibility } from '../../common/index.js';
-import type { Output } from '../types.js';
-export interface ServerConfigBody {
+import type { Pricing, Specs, Visibility } from '../../common/types.js';
+import type { ResponseData } from '../types.js';
+export interface ServerConfigRequestData {
     server_name: string;
 }
-export interface ServerConfigConfigBackgroundJob {
+export interface ServerConfigResponseDataConfigBackgroundJob {
     times_updated: number;
     image: string;
     command: string;
     env: Record<string, string>;
 }
-export interface ServerConfigConfig {
+export interface ServerConfigResponseDataConfig {
     name: string;
     connected: boolean;
     visibility: Visibility;
@@ -21,9 +21,9 @@ export interface ServerConfigConfig {
     id: number;
     rental_status: number;
     specs: Specs;
-    background_job: ServerConfigConfigBackgroundJob;
+    background_job: ServerConfigResponseDataConfigBackgroundJob;
 }
-export interface ServerConfigOutput extends Output {
-    config: ServerConfigConfig;
+export interface ServerConfigResponseData extends ResponseData {
+    config: ServerConfigResponseDataConfig;
     creation_completed: boolean;
 }

package/build/cloreai/endpoints/setServerSettings.d.ts

@@ -1,10 +1,9 @@
-import type { Output } from '../types.js';
-export interface SetServerSettingsBody {
+import type { ResponseData } from '../types.js';
+export interface SetServerSettingsRequestData {
     name: string;
     availability: boolean;
     mrl: number;
     on_demand: number;
     spot: number;
 }
-export interface SetServerSettingsOutput extends Output {
-}
+export type SetServerSettingsResponseData = ResponseData;

package/build/cloreai/endpoints/setSpotPrice.d.ts

@@ -1,17 +1,4 @@
-import type { Output } from '../types.js';
-export interface SetSpotPriceBody {
-    order_id: number;
-    desired_price: number;
-}
-export interface SetSpotPriceMaxStep extends Output {
-    error: 'exceeded_max_step';
-    max_step: number;
-}
-export interface SetSpotPriceTimeToLowering extends Output {
-    error: 'can_lower_every_600_seconds';
-    time_to_lowering: number;
-}
-export interface SetSpotPriceSuccess extends Output {
-    error: undefined;
-}
-export type SetSpotPriceOutput = SetSpotPriceMaxStep | SetSpotPriceTimeToLowering | SetSpotPriceSuccess;
+import type { SetSpotPriceRequestDataCommon, SetSpotPriceResponseDataCommon } from '../../common/endpoints/setSpotPrice.js';
+import type { ResponseData } from '../types.js';
+export type SetSpotPriceRequestData = SetSpotPriceRequestDataCommon;
+export type SetSpotPriceResponseData = SetSpotPriceResponseDataCommon & ResponseData;

package/build/cloreai/endpoints/spotMarketplace.d.ts

@@ -1,25 +1,9 @@
-import type { Pricing, Visibility } from '../../common/index.js';
-import type { Output } from '../types.js';
-export interface SpotMarketplaceParams {
+import type { SpotMarketplaceResponseDataCommon } from '../../common/endpoints/spotMarketplace.js';
+import type { ResponseData } from '../types.js';
+export interface SpotMarketplaceRequestParams {
     market: number;
 }
-export interface SpotMarketplaceMarketOffer {
-    offer_id: number;
-    bid: number;
-    active: boolean;
-    my: boolean;
-}
-export interface SpotMarketplaceMarketServer {
-    min_pricing: Pricing;
-    mrl: number;
-    visibility: Visibility;
-    online: boolean;
-}
-export interface SpotMarketplaceMarket {
-    offers: SpotMarketplaceMarketOffer[];
-    server: SpotMarketplaceMarketServer;
-}
-export interface SpotMarketplaceOutput extends Output {
-    market: SpotMarketplaceMarket;
+export interface SpotMarketplaceResponseData extends ResponseData {
+    market: SpotMarketplaceResponseDataCommon;
     exists: boolean;
 }

package/build/cloreai/endpoints/wallets.d.ts

@@ -1,11 +1,11 @@
-import type { Currency } from '../../common/index.js';
-import type { Output } from '../types.js';
-export interface WalletsWallet {
+import type { Currency } from '../../common/types.js';
+import type { ResponseData } from '../types.js';
+export interface WalletsResponseDataWallet {
     name: Currency;
     deposit: string;
     balance: number;
     withdrawal_fee: number;
 }
-export interface WalletsOutput extends Output {
-    wallets: WalletsWallet[];
+export interface WalletsResponseData extends ResponseData {
+    wallets: WalletsResponseDataWallet[];
 }

package/build/cloreai/index.d.ts

@@ -1,13 +1,13 @@
 import CloreAI from './CloreAI.js';
-export * from './endpoints/cancelOrder.js';
-export * from './endpoints/createOrder.js';
-export * from './endpoints/marketplace.js';
-export * from './endpoints/myOrders.js';
-export * from './endpoints/myServers.js';
-export * from './endpoints/serverConfig.js';
-export * from './endpoints/setServerSettings.js';
-export * from './endpoints/setSpotPrice.js';
-export * from './endpoints/spotMarketplace.js';
-export * from './endpoints/wallets.js';
-export * from './types.js';
+export type * from './endpoints/cancelOrder.js';
+export type * from './endpoints/createOrder.js';
+export type * from './endpoints/marketplace.js';
+export type * from './endpoints/myOrders.js';
+export type * from './endpoints/myServers.js';
+export type * from './endpoints/serverConfig.js';
+export type * from './endpoints/setServerSettings.js';
+export type * from './endpoints/setSpotPrice.js';
+export type * from './endpoints/spotMarketplace.js';
+export type * from './endpoints/wallets.js';
+export type * from './types.js';
 export default CloreAI;

package/build/cloreai/index.js

@@ -1,13 +1,2 @@
 import CloreAI from './CloreAI.js';
-export * from './endpoints/cancelOrder.js';
-export * from './endpoints/createOrder.js';
-export * from './endpoints/marketplace.js';
-export * from './endpoints/myOrders.js';
-export * from './endpoints/myServers.js';
-export * from './endpoints/serverConfig.js';
-export * from './endpoints/setServerSettings.js';
-export * from './endpoints/setSpotPrice.js';
-export * from './endpoints/spotMarketplace.js';
-export * from './endpoints/wallets.js';
-export * from './types.js';
 export default CloreAI;

package/build/cloreai/types.d.ts

@@ -1,7 +1,7 @@
-import type { CommonConfig, CommonOutput } from '../common/types.js';
+import type { CommonConfig, CommonResponseData } from '../common/types.js';
 export interface Config extends CommonConfig {
     apiKey: string;
 }
-export interface Output extends CommonOutput {
+export interface ResponseData extends CommonResponseData {
     code: number;
 }

package/build/common/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const RATE_LIMIT = 3000;
+export declare const RATE_LIMIT = 1800;
 export declare const RATE_LIMIT_CREATE_ORDER = 5000;
 export declare const statusCodes: {
     NORMAL: number;
@@ -7,5 +7,10 @@ export declare const statusCodes: {
     INVALID_API_TOKEN: number;
     INVALID_ENDPOINT: number;
     EXCEEDED: number;
-    ERROR: number;
+    OTHER: number;
+};
+export declare const priorityLevels: {
+    NORMAL: number;
+    HIGH: number;
+    HIGHEST: number;
 };

package/build/common/constants.js

@@ -1,4 +1,4 @@
-export const RATE_LIMIT = 3_000;
+export const RATE_LIMIT = 1_800;
 export const RATE_LIMIT_CREATE_ORDER = 5_000;
 export const statusCodes = {
     NORMAL: 0,
@@ -7,5 +7,10 @@ export const statusCodes = {
     INVALID_API_TOKEN: 3,
     INVALID_ENDPOINT: 4,
     EXCEEDED: 5,
-    ERROR: 6,
+    OTHER: 6,
+};
+export const priorityLevels = {
+    NORMAL: 0,
+    HIGH: 1,
+    HIGHEST: 2,
 };

package/build/common/endpoints/cancelOrder.d.ts

@@ -0,0 +1,3 @@
+export interface CancelOrderRequestDataCommon {
+    id: number;
+}

package/build/common/endpoints/cancelOrder.js

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

package/build/common/endpoints/createOrder.d.ts

@@ -0,0 +1,25 @@
+import type { Currency, OrderType } from '../types.js';
+export interface CreateOrderRequestDataBase {
+    type: OrderType;
+    currency: Currency;
+    image: string;
+    renting_server: number;
+    ports?: Record<string, string>;
+    env?: Record<string, string>;
+    jupyter_token?: string;
+    ssh_key?: string;
+    ssh_password?: string;
+    command?: string;
+    required_price?: number;
+    autossh_entrypoint?: boolean;
+    remember_password?: boolean;
+    dockerhub_auth?: string;
+}
+export interface CreateOrderRequestDataOnDemand extends CreateOrderRequestDataBase {
+    type: 'on-demand';
+}
+export interface CreateOrderRequestDataSpot extends CreateOrderRequestDataBase {
+    type: 'spot';
+    spotprice: number;
+}
+export type CreateOrderRequestDataCommon = CreateOrderRequestDataOnDemand | CreateOrderRequestDataSpot;

package/build/common/endpoints/marketplace.d.ts

@@ -0,0 +1,19 @@
+import type { Currency, Price, Specs } from '../types.js';
+export interface MarketplaceResponseDataServerRatingCommon {
+    avg: number;
+    cnt: number;
+}
+export interface MarketplaceResponseDataServerCommon {
+    allowed_coins: Currency[];
+    cuda_version: string;
+    gpu_array: string[];
+    id: number;
+    mrl: number;
+    oc: boolean;
+    owner: number;
+    price: Price;
+    rating: MarketplaceResponseDataServerRatingCommon;
+    reliability: number;
+    rented: boolean;
+    specs: Specs;
+}

package/build/common/endpoints/myOrders.d.ts

@@ -0,0 +1,23 @@
+import type { Currency, Specs } from '../../common/types.js';
+export interface MyOrdersResponseDataOrderCommon {
+    auto_login: string;
+    id: number;
+    fee: number;
+    creation_fee: number;
+    price: number;
+    mrl: number;
+    online: boolean;
+    image: string;
+    mon_container: number;
+    currency: Currency;
+    spend: number;
+    ct: number;
+    p: number;
+    specs: Specs;
+    si: number;
+    spot: boolean;
+    expired: boolean;
+    pub_cluster: string[];
+    tcp_ports: string[];
+    http_port: string;
+}