oilpriceapi 0.7.0 → 0.9.0

package/dist/cjs/client.js

@@ -0,0 +1,610 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OilPriceAPI = void 0;
+const errors_js_1 = require("./errors.js");
+const diesel_js_1 = require("./resources/diesel.js");
+const alerts_js_1 = require("./resources/alerts.js");
+const commodities_js_1 = require("./resources/commodities.js");
+const futures_js_1 = require("./resources/futures.js");
+const storage_js_1 = require("./resources/storage.js");
+const rig_counts_js_1 = require("./resources/rig-counts.js");
+const bunker_fuels_js_1 = require("./resources/bunker-fuels.js");
+const analytics_js_1 = require("./resources/analytics.js");
+const forecasts_js_1 = require("./resources/forecasts.js");
+const data_quality_js_1 = require("./resources/data-quality.js");
+const drilling_js_1 = require("./resources/drilling.js");
+const index_js_1 = require("./resources/ei/index.js");
+const webhooks_js_1 = require("./resources/webhooks.js");
+const data_sources_js_1 = require("./resources/data-sources.js");
+const version_js_1 = require("./version.js");
+const spreads_js_1 = require("./resources/spreads.js");
+const indicators_js_1 = require("./resources/indicators.js");
+const raw_js_1 = require("./resources/raw.js");
+const streaming_js_1 = require("./resources/streaming.js");
+/**
+ * Official Node.js client for Oil Price API
+ *
+ * @example
+ * ```typescript
+ * import { OilPriceAPI } from 'oilpriceapi';
+ *
+ * const client = new OilPriceAPI({
+ *   apiKey: 'your_api_key_here',
+ *   retries: 3,
+ *   timeout: 30000
+ * });
+ *
+ * // Get latest prices
+ * const prices = await client.getLatestPrices();
+ *
+ * // Get WTI price only
+ * const wti = await client.getLatestPrices({ commodity: 'WTI_USD' });
+ *
+ * // Get historical data
+ * const historical = await client.getHistoricalPrices({
+ *   period: 'past_week',
+ *   commodity: 'BRENT_CRUDE_USD'
+ * });
+ * ```
+ */
+class OilPriceAPI {
+    constructor(config = {}) {
+        this.apiKey = config.apiKey || process.env.OILPRICEAPI_KEY || "";
+        if (!this.apiKey) {
+            throw new errors_js_1.OilPriceAPIError("API key required. Set OILPRICEAPI_KEY env var or pass apiKey in config.");
+        }
+        this.baseUrl = config.baseUrl || "https://api.oilpriceapi.com";
+        this.retries = config.retries !== undefined ? config.retries : 3;
+        this.retryDelay = config.retryDelay || 1000;
+        this.retryStrategy = config.retryStrategy || "exponential";
+        this.timeout = config.timeout || 90000; // 90 seconds for slow historical queries
+        this.debug = config.debug || false;
+        this.appUrl = config.appUrl;
+        this.appName = config.appName;
+        // Initialize resources
+        this.diesel = new diesel_js_1.DieselResource(this);
+        this.alerts = new alerts_js_1.AlertsResource(this);
+        this.commodities = new commodities_js_1.CommoditiesResource(this);
+        this.futures = new futures_js_1.FuturesResource(this);
+        this.storage = new storage_js_1.StorageResource(this);
+        this.rigCounts = new rig_counts_js_1.RigCountsResource(this);
+        this.bunkerFuels = new bunker_fuels_js_1.BunkerFuelsResource(this);
+        this.analytics = new analytics_js_1.AnalyticsResource(this);
+        this.forecasts = new forecasts_js_1.ForecastsResource(this);
+        this.dataQuality = new data_quality_js_1.DataQualityResource(this);
+        this.drilling = new drilling_js_1.DrillingIntelligenceResource(this);
+        this.ei = new index_js_1.EnergyIntelligenceResource(this);
+        this.webhooks = new webhooks_js_1.WebhooksResource(this);
+        this.dataSources = new data_sources_js_1.DataSourcesResource(this);
+        this.spreads = new spreads_js_1.SpreadsResource(this);
+        this.indicators = new indicators_js_1.IndicatorsResource(this);
+        this.raw = new raw_js_1.RawResource(this);
+        this.stream = new streaming_js_1.StreamingResource(this);
+    }
+    /**
+     * Log debug messages if debug mode is enabled
+     */
+    log(message, data) {
+        if (this.debug) {
+            const timestamp = new Date().toISOString();
+            console.log(`[OilPriceAPI ${timestamp}] ${message}`, data || "");
+        }
+    }
+    /**
+     * Calculate delay for retry based on strategy
+     */
+    calculateRetryDelay(attempt) {
+        switch (this.retryStrategy) {
+            case "exponential":
+                return this.retryDelay * Math.pow(2, attempt);
+            case "linear":
+                return this.retryDelay * (attempt + 1);
+            case "fixed":
+            default:
+                return this.retryDelay;
+        }
+    }
+    /**
+     * Sleep for specified milliseconds
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Determine if error is retryable
+     */
+    isRetryable(error) {
+        // Retry on network errors
+        if (error instanceof TypeError && error.message.includes("fetch")) {
+            return true;
+        }
+        // Retry on timeout errors
+        if (error instanceof errors_js_1.TimeoutError) {
+            return true;
+        }
+        // Retry on 5xx server errors
+        if (error instanceof errors_js_1.ServerError) {
+            return true;
+        }
+        // Retry on rate limit errors (with delay)
+        if (error instanceof errors_js_1.RateLimitError) {
+            return true;
+        }
+        // Don't retry on client errors (4xx except 429)
+        return false;
+    }
+    /**
+     * Shape a parsed JSON response body into the value returned to callers.
+     *
+     * Centralizes the response-structure handling so that both {@link request}
+     * and {@link requestRaw} return identical data. Handles the latest/historical
+     * envelope shapes as well as the generic `{ data }` fallback used by resource
+     * mutations, alerts, webhooks, etc.
+     */
+    shapeResponseData(responseData) {
+        // Handle different response structures
+        // Latest endpoint: { status, data: { price, ... } }
+        // Historical endpoint: { status, data: { prices: [...] } }
+        if (responseData.status === "success" && responseData.data) {
+            if (responseData.data.prices) {
+                // Historical endpoint - return prices array
+                this.log(`Returning ${responseData.data.prices.length} prices`);
+                return responseData.data.prices;
+            }
+            else if (responseData.data.price !== undefined) {
+                // Latest endpoint - wrap single price in array
+                this.log("Returning single price (wrapped in array)");
+                return [responseData.data];
+            }
+        }
+        // Fallback - return data as-is (used by resource mutations, alerts, webhooks, etc.)
+        this.log("Returning data as-is");
+        return (responseData.data !== undefined ? responseData.data : responseData);
+    }
+    /**
+     * Internal method to make HTTP requests with retry and timeout.
+     * Supports all HTTP methods (GET, POST, PATCH, DELETE) with consistent
+     * retry logic, timeout handling, and typed error responses.
+     */
+    async request(endpoint, params, options) {
+        const { data } = await this.requestRaw(endpoint, params, options);
+        return data;
+    }
+    /**
+     * Internal method identical to {@link request} but returns the underlying
+     * HTTP status and headers alongside the parsed data.
+     *
+     * Used by the public {@link raw} accessor to expose response metadata
+     * (issue #7) without changing the return shape of existing methods.
+     */
+    async requestRaw(endpoint, params, options) {
+        // Build URL with query parameters
+        const url = new URL(`${this.baseUrl}${endpoint}`);
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.append(key, value);
+                }
+            });
+        }
+        this.log(`Request: ${url.toString()}`);
+        let lastError = null;
+        // Retry loop
+        for (let attempt = 0; attempt <= this.retries; attempt++) {
+            try {
+                // Add retry info to logs
+                if (attempt > 0) {
+                    this.log(`Retry attempt ${attempt}/${this.retries}`);
+                }
+                // Create abort controller for timeout
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+                try {
+                    // Build headers with optional telemetry
+                    const headers = {
+                        Authorization: `Bearer ${this.apiKey}`,
+                        "Content-Type": "application/json",
+                        "User-Agent": (0, version_js_1.buildUserAgent)(),
+                        "X-SDK-Name": version_js_1.SDK_NAME,
+                        "X-SDK-Version": version_js_1.SDK_VERSION,
+                    };
+                    // Add optional telemetry headers (10% bonus for appUrl!)
+                    if (this.appUrl) {
+                        headers["X-App-URL"] = this.appUrl;
+                    }
+                    if (this.appName) {
+                        headers["X-App-Name"] = this.appName;
+                    }
+                    const fetchOptions = {
+                        method: options?.method || "GET",
+                        headers,
+                        signal: controller.signal,
+                    };
+                    if (options?.body !== undefined) {
+                        fetchOptions.body = JSON.stringify(options.body);
+                    }
+                    const response = await fetch(url.toString(), fetchOptions);
+                    clearTimeout(timeoutId);
+                    this.log(`Response: ${response.status} ${response.statusText}`);
+                    // Handle error responses
+                    if (!response.ok) {
+                        const errorBody = await response.text();
+                        let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+                        // Try to parse JSON error response
+                        try {
+                            const errorJson = JSON.parse(errorBody);
+                            errorMessage = errorJson.message || errorJson.error || errorMessage;
+                        }
+                        catch {
+                            // Use default error message if response isn't JSON
+                        }
+                        this.log(`Error response: ${errorMessage}`);
+                        // Throw specific error types based on status code
+                        switch (response.status) {
+                            case 401:
+                                throw new errors_js_1.AuthenticationError(errorMessage);
+                            case 404:
+                                throw new errors_js_1.NotFoundError(errorMessage);
+                            case 429:
+                                const retryAfter = response.headers.get("Retry-After");
+                                const rateLimitError = new errors_js_1.RateLimitError(errorMessage, retryAfter ? parseInt(retryAfter, 10) : undefined);
+                                // If rate limited and we have retries left, wait and retry
+                                if (attempt < this.retries && rateLimitError.retryAfter) {
+                                    this.log(`Rate limited. Waiting ${rateLimitError.retryAfter}s`);
+                                    await this.sleep(rateLimitError.retryAfter * 1000);
+                                    continue;
+                                }
+                                throw rateLimitError;
+                            case 500:
+                            case 502:
+                            case 503:
+                            case 504:
+                                throw new errors_js_1.ServerError(errorMessage, response.status);
+                            default:
+                                throw new errors_js_1.OilPriceAPIError(errorMessage, response.status, "HTTP_ERROR");
+                        }
+                    }
+                    // Handle empty responses (e.g., 204 No Content from DELETE)
+                    const responseText = await response.text();
+                    if (!responseText) {
+                        this.log("Empty response body");
+                        return {
+                            data: {},
+                            status: response.status,
+                            headers: response.headers,
+                        };
+                    }
+                    // Parse successful response
+                    const responseData = JSON.parse(responseText);
+                    this.log("Response data received", {
+                        status: responseData.status,
+                        hasData: !!responseData.data,
+                    });
+                    return {
+                        data: this.shapeResponseData(responseData),
+                        status: response.status,
+                        headers: response.headers,
+                    };
+                }
+                catch (error) {
+                    // Handle abort (timeout)
+                    if (error instanceof Error && error.name === "AbortError") {
+                        throw new errors_js_1.TimeoutError("Request timeout", this.timeout);
+                    }
+                    throw error;
+                }
+            }
+            catch (error) {
+                lastError = error;
+                this.log(`Request failed: ${lastError.message}`, {
+                    attempt,
+                    retryable: this.isRetryable(lastError),
+                });
+                // Re-throw our custom errors if not retryable
+                if (error instanceof errors_js_1.OilPriceAPIError && !this.isRetryable(error)) {
+                    throw error;
+                }
+                // If this was our last attempt, throw the error
+                if (attempt === this.retries) {
+                    if (error instanceof errors_js_1.OilPriceAPIError) {
+                        throw error;
+                    }
+                    // Wrap fetch errors (network issues, etc.)
+                    if (error instanceof Error) {
+                        throw new errors_js_1.OilPriceAPIError(`Request failed after ${this.retries + 1} attempts: ${error.message}`, undefined, "NETWORK_ERROR");
+                    }
+                    throw error;
+                }
+                // Calculate delay and retry
+                const delay = this.calculateRetryDelay(attempt);
+                this.log(`Waiting ${delay}ms before retry...`);
+                await this.sleep(delay);
+            }
+        }
+        // This should never be reached, but TypeScript wants it
+        throw lastError || new errors_js_1.OilPriceAPIError("Unknown error occurred");
+    }
+    /**
+     * Get the latest prices for all commodities or a specific commodity
+     *
+     * @param options - Optional filters
+     * @returns Array of price objects
+     *
+     * @example
+     * ```typescript
+     * // Get all latest prices
+     * const allPrices = await client.getLatestPrices();
+     *
+     * // Get WTI price only
+     * const wti = await client.getLatestPrices({ commodity: 'WTI_USD' });
+     * ```
+     */
+    async getLatestPrices(options) {
+        const params = {};
+        if (options?.commodity) {
+            params.by_code = options.commodity;
+        }
+        return this.request("/v1/prices/latest", params);
+    }
+    /**
+     * Get historical prices for a time period
+     *
+     * @param options - Time period and filter options
+     * @returns Array of historical price objects
+     *
+     * @example
+     * ```typescript
+     * // Get past week of WTI prices
+     * const weekPrices = await client.getHistoricalPrices({
+     *   period: 'past_week',
+     *   commodity: 'WTI_USD'
+     * });
+     *
+     * // Get custom date range
+     * const customPrices = await client.getHistoricalPrices({
+     *   startDate: '2024-01-01',
+     *   endDate: '2024-12-31',
+     *   commodity: 'BRENT_CRUDE_USD'
+     * });
+     * ```
+     */
+    async getHistoricalPrices(options) {
+        const params = {};
+        if (options?.period) {
+            params.period = options.period;
+        }
+        if (options?.commodity) {
+            params.by_code = options.commodity;
+        }
+        if (options?.startDate) {
+            params.start_date = options.startDate;
+        }
+        if (options?.endDate) {
+            params.end_date = options.endDate;
+        }
+        // PERFORMANCE FIX (December 24, 2025):
+        // Pass interval parameter to enable aggregated queries
+        // This reduces response times from 74s to <1s for year-long queries
+        // by returning 365 daily points instead of 600k+ raw points
+        if (options?.interval) {
+            params.interval = options.interval;
+        }
+        // Pagination parameters
+        if (options?.perPage !== undefined) {
+            params.per_page = options.perPage.toString();
+        }
+        if (options?.page !== undefined) {
+            params.page = options.page.toString();
+        }
+        // CRITICAL FIX (December 17, 2025):
+        // Use /v1/prices/past_year endpoint instead of /v1/prices
+        // The /v1/prices endpoint does NOT correctly handle start_date/end_date parameters
+        // This was the same bug that affected the Python SDK (fixed in v1.4.4)
+        // Issue: SDK was returning wrong dates for historical queries
+        // Root Cause: Backend has_scope :by_period not working on /v1/prices
+        // Solution: Use /v1/prices/past_year which uses direct WHERE clauses
+        return this.request("/v1/prices/past_year", params);
+    }
+    /**
+     * Paginate through historical prices automatically.
+     *
+     * Returns an async generator that yields pages of prices, fetching
+     * the next page only when needed. Avoids loading all data into memory.
+     *
+     * @param options - Same options as getHistoricalPrices, plus perPage (default: 100)
+     *
+     * @example
+     * ```typescript
+     * // Iterate through all pages
+     * for await (const page of client.paginateHistoricalPrices({
+     *   commodity: 'BRENT_CRUDE_USD',
+     *   startDate: '2024-01-01',
+     *   endDate: '2024-12-31',
+     *   perPage: 100,
+     * })) {
+     *   console.log(`Got ${page.length} prices`);
+     *   // Process each page...
+     * }
+     *
+     * // Or collect all prices
+     * const allPrices: Price[] = [];
+     * for await (const page of client.paginateHistoricalPrices({ commodity: 'WTI_USD' })) {
+     *   allPrices.push(...page);
+     * }
+     * ```
+     */
+    async *paginateHistoricalPrices(options) {
+        const perPage = options?.perPage || 100;
+        let page = 1;
+        while (true) {
+            const results = await this.getHistoricalPrices({
+                ...options,
+                page,
+                perPage,
+            });
+            if (results.length === 0)
+                break;
+            yield results;
+            if (results.length < perPage)
+                break;
+            page++;
+        }
+    }
+    /**
+     * Get prices from your connected data sources (BYOS)
+     *
+     * Requires Data Connector feature enabled on your organization.
+     *
+     * @example
+     * ```typescript
+     * // Get all connected prices
+     * const prices = await client.getDataConnectorPrices();
+     *
+     * // Filter by fuel type
+     * const vlsfo = await client.getDataConnectorPrices({ fuelType: 'VLSFO' });
+     *
+     * // Filter by port
+     * const singapore = await client.getDataConnectorPrices({ port: 'SINGAPORE' });
+     * ```
+     */
+    async getDataConnectorPrices(options = {}) {
+        const params = {};
+        if (options.fuelType)
+            params.fuel_type = options.fuelType;
+        if (options.port)
+            params.port = options.port;
+        if (options.region)
+            params.region = options.region;
+        if (options.since)
+            params.since = options.since;
+        const response = await this.request("/v1/prices/data-connector", params);
+        return response.prices;
+    }
+    /**
+     * Get metadata for all supported commodities
+     *
+     * @returns Object containing array of commodities
+     *
+     * @example
+     * ```typescript
+     * const response = await client.getCommodities();
+     * console.log(response.commodities); // Array of commodity objects
+     * ```
+     */
+    async getCommodities() {
+        return this.request("/v1/commodities", {});
+    }
+    /**
+     * Get all commodity categories with their commodities
+     *
+     * @returns Object with category keys mapped to category objects
+     *
+     * @example
+     * ```typescript
+     * const categories = await client.getCommodityCategories();
+     * console.log(categories.oil.name); // "Oil"
+     * console.log(categories.oil.commodities.length); // 11
+     * ```
+     */
+    async getCommodityCategories() {
+        return this.request("/v1/commodities/categories", {});
+    }
+    /**
+     * Get metadata for a specific commodity by code
+     *
+     * @param code - Commodity code (e.g., "WTI_USD", "BRENT_CRUDE_USD")
+     * @returns Commodity metadata object
+     *
+     * @example
+     * ```typescript
+     * const commodity = await client.getCommodity('WTI_USD');
+     * console.log(commodity.name); // "WTI Crude Oil"
+     * ```
+     */
+    async getCommodity(code) {
+        return this.request(`/v1/commodities/${code}`, {});
+    }
+    /**
+     * Fetch live sample prices from the public, no-auth demo endpoint.
+     *
+     * Hits `GET /v1/demo/prices` (no API key required) and returns the parsed
+     * `{ prices, meta }` envelope. Useful for trying the client without
+     * credentials. Subject to the demo rate limit (~20 requests/hour).
+     *
+     * @example
+     * ```typescript
+     * const demo = await client.getDemoPrices();
+     * const brent = demo.prices.find(p => p.code === 'BRENT_CRUDE_USD');
+     * console.log(brent?.price);
+     * ```
+     */
+    async getDemoPrices() {
+        return this.requestDemo("/v1/demo/prices");
+    }
+    /**
+     * Fetch the catalogue of commodities from the public, no-auth demo endpoint.
+     *
+     * Hits `GET /v1/demo/commodities` (no API key required) and returns the parsed
+     * `{ commodities, meta }` envelope, where `meta.free_commodities` lists the
+     * codes available on the free demo tier.
+     *
+     * @example
+     * ```typescript
+     * const demo = await client.getDemoCommodities();
+     * console.log(demo.meta.total, demo.meta.free_commodities);
+     * ```
+     */
+    async getDemoCommodities() {
+        return this.requestDemo("/v1/demo/commodities");
+    }
+    /**
+     * Minimal fetch for the no-auth demo endpoints.
+     *
+     * Unlike {@link request}, this does NOT run the latest/historical response
+     * shaping (which would strip the `meta` block) and does NOT require an API
+     * key — it returns the raw `data` envelope from `{ status, data }`.
+     */
+    async requestDemo(endpoint) {
+        const url = `${this.baseUrl}${endpoint}`;
+        this.log(`Demo request: ${url}`);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(url, {
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                    "User-Agent": (0, version_js_1.buildUserAgent)(),
+                    "X-SDK-Name": version_js_1.SDK_NAME,
+                    "X-SDK-Version": version_js_1.SDK_VERSION,
+                },
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const body = await response.text();
+                let message = `HTTP ${response.status}: ${response.statusText}`;
+                try {
+                    const json = JSON.parse(body);
+                    message = json.message || json.error || message;
+                }
+                catch {
+                    // non-JSON error body
+                }
+                throw new errors_js_1.OilPriceAPIError(message, response.status, "HTTP_ERROR");
+            }
+            const parsed = JSON.parse(await response.text());
+            // Demo envelope is { status: "success", data: { ... } }.
+            return (parsed.data !== undefined ? parsed.data : parsed);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new errors_js_1.TimeoutError("Request timeout", this.timeout);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+exports.OilPriceAPI = OilPriceAPI;

package/dist/cjs/errors.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutError = exports.ValidationError = exports.ServerError = exports.NotFoundError = exports.RateLimitError = exports.AuthenticationError = exports.OilPriceAPIError = void 0;
+/**
+ * Base error class for all Oil Price API errors
+ */
+class OilPriceAPIError extends Error {
+    constructor(message, statusCode, code) {
+        super(message);
+        this.name = "OilPriceAPIError";
+        this.statusCode = statusCode;
+        this.code = code;
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+exports.OilPriceAPIError = OilPriceAPIError;
+/**
+ * Thrown when API authentication fails (401)
+ */
+class AuthenticationError extends OilPriceAPIError {
+    constructor(message = "Invalid API key") {
+        super(message, 401, "AUTHENTICATION_ERROR");
+        this.name = "AuthenticationError";
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+/**
+ * Thrown when rate limit is exceeded (429)
+ */
+class RateLimitError extends OilPriceAPIError {
+    constructor(message = "Rate limit exceeded", retryAfter) {
+        super(message, 429, "RATE_LIMIT_ERROR");
+        this.name = "RateLimitError";
+        this.retryAfter = retryAfter;
+    }
+}
+exports.RateLimitError = RateLimitError;
+/**
+ * Thrown when requested resource is not found (404)
+ */
+class NotFoundError extends OilPriceAPIError {
+    constructor(message = "Resource not found") {
+        super(message, 404, "NOT_FOUND_ERROR");
+        this.name = "NotFoundError";
+    }
+}
+exports.NotFoundError = NotFoundError;
+/**
+ * Thrown when server returns 5xx error
+ */
+class ServerError extends OilPriceAPIError {
+    constructor(message = "Internal server error", statusCode = 500) {
+        super(message, statusCode, "SERVER_ERROR");
+        this.name = "ServerError";
+    }
+}
+exports.ServerError = ServerError;
+/**
+ * Thrown when SDK-side input validation fails
+ */
+class ValidationError extends OilPriceAPIError {
+    constructor(message) {
+        super(message, undefined, "VALIDATION_ERROR");
+        this.name = "ValidationError";
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * Thrown when request exceeds timeout
+ */
+class TimeoutError extends OilPriceAPIError {
+    constructor(message = "Request timeout", timeout) {
+        super(`${message} (${timeout}ms)`, undefined, "TIMEOUT_ERROR");
+        this.name = "TimeoutError";
+    }
+}
+exports.TimeoutError = TimeoutError;