cloreai 0.1.11 → 0.1.13

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

@@ -0,0 +1,16 @@
+export interface SetSpotPriceRequestDataCommon {
+    order_id: number;
+    desired_price: number;
+}
+export interface SetSpotPriceResponseDataMaxStep {
+    error: 'exceeded_max_step';
+    max_step: number;
+}
+export interface SetSpotPriceResponseDataTimeToLowering {
+    error: 'can_lower_every_600_seconds';
+    time_to_lowering: number;
+}
+export interface SetSpotPriceResponseDataNormal {
+    error: undefined;
+}
+export type SetSpotPriceResponseDataCommon = SetSpotPriceResponseDataMaxStep | SetSpotPriceResponseDataTimeToLowering | SetSpotPriceResponseDataNormal;

package/build/common/endpoints/setSpotPrice.js

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

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

@@ -0,0 +1,19 @@
+import type { Currency, Pricing, Visibility } from '../../common/types.js';
+export interface SpotMarketplaceResponseDataOfferCommon {
+    active: boolean;
+    bid: number;
+    currency: Currency;
+    my: boolean;
+    offer_id: number;
+}
+export interface SpotMarketplaceResponseDataServerCommon {
+    min_pricing: Pricing;
+    mrl: number;
+    online: boolean;
+    visibility: Visibility;
+}
+export interface SpotMarketplaceResponseDataCommon {
+    currency_rates_in_usd: Pricing;
+    offers: SpotMarketplaceResponseDataOfferCommon[];
+    server: SpotMarketplaceResponseDataServerCommon;
+}

package/build/common/errors.d.ts

@@ -1,5 +1,5 @@
 import { AxiosError } from 'axios';
-import type { AxiosErrorParameters } from './types.js';
+export type AxiosErrorParameters = ConstructorParameters<typeof AxiosError>;
 export declare class DatabaseError extends AxiosError {
     constructor(...args: AxiosErrorParameters);
 }
@@ -15,7 +15,7 @@ export declare class InvalidEndpointError extends AxiosError {
 export declare class ExceededError extends AxiosError {
     constructor(...args: AxiosErrorParameters);
 }
-export declare class CustomError extends AxiosError {
+export declare class OtherError extends AxiosError {
     constructor(...args: AxiosErrorParameters);
 }
 export declare class UnknownError extends AxiosError {

package/build/common/errors.js

@@ -29,10 +29,10 @@ export class ExceededError extends AxiosError {
         this.name = 'ExceededError';
     }
 }
-export class CustomError extends AxiosError {
+export class OtherError extends AxiosError {
     constructor(...args) {
         super(...args);
-        this.name = 'CustomError';
+        this.name = 'OtherError';
     }
 }
 export class UnknownError extends AxiosError {

package/build/common/helpers.d.ts

@@ -0,0 +1,6 @@
+import type { AxiosRequestConfig } from 'axios';
+import type { QueueAddOptions } from 'p-queue';
+export declare function getErrorMessage(statusCode?: number | string, errorField?: string): string;
+export declare function getQueueOptions(priority: number, config?: AxiosRequestConfig): QueueAddOptions & {
+    throwOnTimeout: true;
+};

package/build/common/helpers.js

@@ -0,0 +1,25 @@
+export function getErrorMessage(statusCode, errorField) {
+    const messages = [];
+    if (statusCode != null) {
+        messages.push(`Status code "${statusCode}".`);
+    }
+    if (errorField != null) {
+        messages.push(`Error field "${errorField}".`);
+    }
+    return messages.join(' ');
+}
+export function getQueueOptions(priority, config) {
+    const defaultQueueOptions = {
+        throwOnTimeout: true,
+        priority,
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- GenericAbortSignal
+    const signal = config?.signal;
+    if (signal == null) {
+        return defaultQueueOptions;
+    }
+    return {
+        ...defaultQueueOptions,
+        signal,
+    };
+}

package/build/common/index.d.ts

@@ -1,5 +1,10 @@
-export * from './api.js';
 export * from './constants.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/setSpotPrice.js';
+export type * from './endpoints/spotMarketplace.js';
 export * from './errors.js';
-export * from './getErrorMessage.js';
-export * from './types.js';
+export * from './helpers.js';
+export type * from './types.js';

package/build/common/index.js

@@ -1,5 +1,3 @@
-export * from './api.js';
 export * from './constants.js';
 export * from './errors.js';
-export * from './getErrorMessage.js';
-export * from './types.js';
+export * from './helpers.js';

package/build/common/types.d.ts

@@ -1,8 +1,61 @@
-import type { AxiosError, CreateAxiosDefaults } from 'axios';
-export type AxiosErrorParameters = ConstructorParameters<typeof AxiosError>;
+import type { CreateAxiosDefaults } from 'axios';
+import type { Options, Queue, QueueAddOptions } from 'p-queue';
+export type PQueueOptions = Options<Queue<() => Promise<unknown>, QueueAddOptions>, QueueAddOptions>;
 export interface CommonConfig {
     axiosConfig?: CreateAxiosDefaults;
+    rateLimitQueueOptions?: PQueueOptions;
+    rateLimitQueueOptionsCreateOrder?: PQueueOptions;
 }
-export interface CommonOutput<T = string> {
-    error?: T | undefined;
+export interface CommonResponseData {
+    error?: string;
+}
+export type OrderType = 'on-demand' | 'spot';
+export type Visibility = 'public' | 'hidden';
+export type Currency = 'CLORE-Blockchain' | 'bitcoin' | 'usd';
+export interface Pricing {
+    'CLORE-Blockchain': number;
+    'bitcoin': number;
+    'usd'?: number;
+}
+export interface PricingInUSD {
+    on_demand_btc: number;
+    on_demand_clore: number;
+    spot: number;
+}
+export interface Price {
+    on_demand: Pricing;
+    spot: Pricing;
+    usd?: PricingInUSD;
+}
+export interface Net {
+    cc: string;
+    down: number;
+    up: number;
+    test_history: string[];
+}
+export interface Overclock {
+    model: string;
+    core_offset: number | null;
+    mem_offset: number | null;
+    core_lock: number | null;
+    mem_lock: number | null;
+}
+export interface Specs {
+    backend_version: number;
+    cpu: string;
+    cpus: string;
+    disk: string;
+    disk_speed: number;
+    gpu: string;
+    gpuram: number;
+    mb: string;
+    net: Net;
+    pcie_rev: number;
+    pcie_width: number;
+    pl: number[];
+    ram: number;
+    stock_oc: Overclock[] | 'default';
+    stock_oc_override: boolean;
+    stock_pl: number[];
+    xfs: number;
 }

package/build/webapi/WebAPI.d.ts

@@ -1,22 +1,22 @@
 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 { GetSpotBody, GetSpotOutput } from './endpoints/getSpot.js';
-import type { OrdersBody, OrdersOutput } from './endpoints/orders.js';
-import type { ServersOutput } from './endpoints/servers.js';
-import type { SetSpotPriceBody, SetSpotPriceOutput } from './endpoints/setSpotPrice.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 { MyOrdersRequestData, MyOrdersResponseData } from './endpoints/myOrders.js';
+import type { SetSpotPriceRequestData, SetSpotPriceResponseData } from './endpoints/setSpotPrice.js';
+import type { SpotMarketplaceRequestData, SpotMarketplaceResponseData } from './endpoints/spotMarketplace.js';
 import type { Config } from './types.js';
 declare class WebAPI {
-    readonly axios: AxiosInstance;
-    readonly rateLimitQueue: PQueue;
-    readonly rateLimitCreateOrderQueue: PQueue;
+    axios: AxiosInstance;
+    rateLimitQueue: PQueue;
+    rateLimitQueueCreateOrder: PQueue;
     constructor(config: Config);
-    servers(axiosConfig?: AxiosRequestConfig, queueOptions?: QueueAddOptions): Promise<ServersOutput>;
-    orders(body: OrdersBody, axiosConfig?: AxiosRequestConfig<OrdersBody>, queueOptions?: QueueAddOptions): Promise<OrdersOutput>;
-    getSpot(body: GetSpotBody, axiosConfig?: AxiosRequestConfig<GetSpotBody>, queueOptions?: QueueAddOptions): Promise<GetSpotOutput>;
-    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>;
+    marketplace(config?: AxiosRequestConfig): Promise<MarketplaceResponseData>;
+    myOrders(data: MyOrdersRequestData, config?: AxiosRequestConfig): Promise<MyOrdersResponseData>;
+    spotMarketplace(data: SpotMarketplaceRequestData, config?: AxiosRequestConfig): Promise<SpotMarketplaceResponseData>;
+    setSpotPrice(data: SetSpotPriceRequestData, config?: AxiosRequestConfig): Promise<SetSpotPriceResponseData>;
+    cancelOrder(data: CancelOrderRequestData, config?: AxiosRequestConfig): Promise<CancelOrderResponseData>;
+    createOrder(data: CreateOrderRequestData, config?: AxiosRequestConfig): Promise<CreateOrderResponseData>;
 }
 export default WebAPI;

package/build/webapi/WebAPI.js

@@ -1,29 +1,33 @@
 import axios from 'axios';
 import PQueue from 'p-queue';
+import { priorityLevels, RATE_LIMIT, RATE_LIMIT_CREATE_ORDER } from '../common/constants.js';
 import { UnknownError } from '../common/errors.js';
-import { getErrorMessage, RATE_LIMIT, RATE_LIMIT_CREATE_ORDER } from '../common/index.js';
+import { getErrorMessage, getQueueOptions } from '../common/helpers.js';
 class WebAPI {
     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 { token, 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://clore.ai/webapi',
         });
         this.axios.interceptors.request.use((request) => {
             request.data = {
                 ...request.data,
-                token,
+                token: config.token,
             };
             return request;
         });
@@ -36,50 +40,40 @@ class WebAPI {
             throw new UnknownError(errorMessage, undefined, response.config, response.request, response);
         });
     }
-    async servers(axiosConfig, queueOptions) {
+    async marketplace(config) {
         const response = await this.rateLimitQueue.add(async () => {
-            return await this.axios.post('/marketplace/servers', null, axiosConfig);
-        }, { ...queueOptions, throwOnTimeout: true });
+            return await this.axios.post('/marketplace/servers', null, config);
+        }, getQueueOptions(priorityLevels.NORMAL, config));
         return response.data;
     }
-    async orders(body, axiosConfig, queueOptions) {
+    async myOrders(data, config) {
         const response = await this.rateLimitQueue.add(async () => {
-            return await this.axios.post('/marketplace/orders', body, axiosConfig);
-        }, { ...queueOptions, throwOnTimeout: true });
+            return await this.axios.post('/marketplace/orders', data, config);
+        }, getQueueOptions(priorityLevels.NORMAL, config));
         return response.data;
     }
-    async getSpot(body, axiosConfig, queueOptions) {
+    async spotMarketplace(data, config) {
         const response = await this.rateLimitQueue.add(async () => {
-            return await this.axios.post('/marketplace/get_spot', body, axiosConfig);
-        }, { ...queueOptions, throwOnTimeout: true });
+            return await this.axios.post('/marketplace/get_spot', data, config);
+        }, getQueueOptions(priorityLevels.NORMAL, 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('/marketplace/set_spot_price', body, axiosConfig);
-        }, { ...queueOptions, throwOnTimeout: true });
+            return await this.axios.post('/marketplace/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('/marketplace/cancel_order', body, axiosConfig);
-        }, { ...queueOptions, throwOnTimeout: true });
+            return await this.axios.post('/marketplace/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/webapi/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 {
     rating: number;
 }
-export interface CancelOrderOutput extends Output {
-}
+export type CancelOrderResponseData = ResponseData;

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

@@ -1,27 +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;
-    remember_password?: 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/webapi/endpoints/marketplace.d.ts

@@ -0,0 +1,10 @@
+import type { MarketplaceResponseDataServerCommon } from '../../common/endpoints/marketplace.js';
+import type { Price } from '../../common/types.js';
+import type { ResponseData } from '../types.js';
+export interface MarketplaceResponseData extends ResponseData {
+    all_servers: MarketplaceResponseDataServerCommon[];
+    creation_fees: Price;
+    disable_usd: boolean;
+    my_servers: MarketplaceResponseDataServerCommon[];
+    not_rented_available_servers: MarketplaceResponseDataServerCommon[];
+}

package/build/webapi/endpoints/marketplace.js

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

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

@@ -0,0 +1,15 @@
+import type { MyOrdersResponseDataOrderCommon } from '../../common/endpoints/myOrders.js';
+import type { Currency, Price } from '../../common/types.js';
+import type { ResponseData } from '../types.js';
+export interface MyOrdersRequestData {
+    rc: boolean;
+}
+export interface MyOrdersResponseData extends ResponseData {
+    PoH_active: boolean;
+    PoH_rates: Record<Currency, Record<string, Price>>;
+    allowed_features: string[];
+    eo: boolean;
+    http_endpoint_by_proxy: Record<string, string>;
+    ol: number;
+    orders: MyOrdersResponseDataOrderCommon[];
+}

package/build/webapi/endpoints/myOrders.js

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

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

@@ -1,17 +1,4 @@
-import type { Output } from '../types.js';
-export interface SetSpotPriceBody {
-    desired_price: number;
-    order_id: 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/webapi/endpoints/spotMarketplace.d.ts

@@ -0,0 +1,8 @@
+import type { SpotMarketplaceResponseDataCommon } from '../../common/endpoints/spotMarketplace.js';
+import type { ResponseData } from '../types.js';
+export interface SpotMarketplaceRequestData {
+    id: number;
+}
+export interface SpotMarketplaceResponseData extends ResponseData {
+    data: SpotMarketplaceResponseDataCommon;
+}

package/build/webapi/endpoints/spotMarketplace.js

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

package/build/webapi/index.d.ts

@@ -1,9 +1,9 @@
 import WebAPI from './WebAPI.js';
-export * from './endpoints/cancelOrder.js';
-export * from './endpoints/createOrder.js';
-export * from './endpoints/getSpot.js';
-export * from './endpoints/orders.js';
-export * from './endpoints/servers.js';
-export * from './endpoints/setSpotPrice.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/setSpotPrice.js';
+export type * from './endpoints/spotMarketplace.js';
+export type * from './types.js';
 export default WebAPI;

package/build/webapi/index.js

@@ -1,9 +1,2 @@
 import WebAPI from './WebAPI.js';
-export * from './endpoints/cancelOrder.js';
-export * from './endpoints/createOrder.js';
-export * from './endpoints/getSpot.js';
-export * from './endpoints/orders.js';
-export * from './endpoints/servers.js';
-export * from './endpoints/setSpotPrice.js';
-export * from './types.js';
 export default WebAPI;

package/build/webapi/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 {
     token: string;
 }
-export interface Output extends CommonOutput {
+export interface ResponseData extends CommonResponseData {
     status: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloreai",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "type": "module",
   "description": "CLORE.AI API client",
   "repository": {
@@ -34,22 +34,22 @@
     "prepack": "npm run clean && npm run build && npm run check",
     "prepare": "husky",
     "typecheck": "tsc --noEmit",
-    "update-latest": "npm-check-updates --peer --upgrade && npm update"
+    "upgrade": "npm-check-updates --peer --upgrade && npm update"
   },
   "dependencies": {
-    "axios": "^1.7.7",
+    "axios": "^1.7.9",
     "p-queue": "^8.0.1"
   },
   "devDependencies": {
     "@tsconfig/strictest": "^2.0.5",
-    "eslint": "^8.57.0",
-    "eslint-config-vladpuz": "^0.15.0",
-    "husky": "^9.1.6",
-    "jiti": "^1.21.6",
-    "npm-check-updates": "^17.1.1",
-    "prettier": "^3.3.3",
-    "prettier-config-vladpuz": "^0.8.0",
+    "eslint": "^9.17.0",
+    "eslint-config-vladpuz": "^0.20.0",
+    "husky": "^9.1.7",
+    "jiti": "^2.4.1",
+    "npm-check-updates": "^17.1.11",
+    "prettier": "^3.4.2",
+    "prettier-config-vladpuz": "^0.9.0",
     "rimraf": "^6.0.1",
-    "typescript": "^5.6.2"
+    "typescript": "^5.7.2"
   }
 }

package/build/common/api.d.ts

@@ -1,30 +0,0 @@
-export type OrderType = 'on-demand' | 'spot';
-export type Visibility = 'public' | 'hidden';
-export type Currency = 'CLORE-Blockchain' | 'bitcoin';
-export type Pricing = Record<Currency, number>;
-export interface Price {
-    on_demand: Pricing;
-    spot: Pricing;
-}
-export interface Net {
-    cc: string;
-    down: number;
-    up: number;
-}
-export interface Specs {
-    mb: string;
-    cpu: string;
-    cpus: string;
-    ram: number;
-    disk: string;
-    disk_speed: number;
-    gpu: string;
-    gpuram: number;
-    net: Net;
-    backend_version: number;
-    pcie_rev: number;
-    pcie_width: number;
-    pl: number[];
-    stock_oc_override: boolean;
-    stock_pl: number[];
-}

package/build/common/getErrorMessage.d.ts

@@ -1 +0,0 @@
-export declare function getErrorMessage(statusCode?: number | string, errorField?: string): string;

package/build/common/getErrorMessage.js

@@ -1,11 +0,0 @@
-export function getErrorMessage(statusCode, errorField) {
-    const statusCodeMessage = statusCode != null ? `Status code "${statusCode}".` : null;
-    const errorFieldMessage = errorField != null ? `Error field "${errorField}".` : null;
-    const errorMessageArray = [
-        statusCodeMessage,
-        errorFieldMessage,
-    ].filter((message) => {
-        return message != null;
-    });
-    return errorMessageArray.join(' ');
-}

package/build/webapi/endpoints/getSpot.d.ts

@@ -1,26 +0,0 @@
-import type { Currency, Pricing, Visibility } from '../../common/index.js';
-import type { Output } from '../types.js';
-export interface GetSpotBody {
-    id: number;
-}
-export interface GetSpotDataOffer {
-    offer_id: number;
-    bid: number;
-    active: boolean;
-    my: boolean;
-    currency: Currency;
-}
-export interface GetSpotDataServer {
-    min_pricing: Pricing;
-    mrl: number;
-    visibility: Visibility;
-    online: boolean;
-}
-export interface GetSpotData {
-    currency_rates_in_usd: Pricing;
-    offers: GetSpotDataOffer[];
-    server: GetSpotDataServer;
-}
-export interface GetSpotOutput extends Output {
-    data: GetSpotData;
-}