oilpriceapi 0.7.0 → 0.9.0

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { OilPriceAPIConfig, Price, LatestPricesOptions, HistoricalPricesOptions, Commodity, CommoditiesResponse, CategoriesResponse, DataConnectorPrice, DataConnectorOptions } from "./types.js";
+import type { OilPriceAPIConfig, Price, LatestPricesOptions, HistoricalPricesOptions, Commodity, CommoditiesResponse, CategoriesResponse, DataConnectorPrice, DataConnectorOptions, DemoPricesResponse, DemoCommoditiesResponse } from "./types.js";
 import { DieselResource } from "./resources/diesel.js";
 import { AlertsResource } from "./resources/alerts.js";
 import { CommoditiesResource } from "./resources/commodities.js";
@@ -13,6 +13,26 @@ import { DrillingIntelligenceResource } from "./resources/drilling.js";
 import { EnergyIntelligenceResource } from "./resources/ei/index.js";
 import { WebhooksResource } from "./resources/webhooks.js";
 import { DataSourcesResource } from "./resources/data-sources.js";
+import { SpreadsResource } from "./resources/spreads.js";
+import { IndicatorsResource } from "./resources/indicators.js";
+import { RawResource } from "./resources/raw.js";
+import { StreamingResource } from "./resources/streaming.js";
+/**
+ * Raw HTTP response wrapper.
+ *
+ * Returned by {@link OilPriceAPI.raw} accessors to expose the underlying
+ * HTTP status code and response headers alongside the parsed data.
+ *
+ * @typeParam T - The parsed response body type.
+ */
+export interface APIResponse<T> {
+    /** Parsed response data (same shape the non-raw method would return). */
+    data: T;
+    /** HTTP status code (e.g., 200, 201). */
+    status: number;
+    /** Response headers. */
+    headers: Headers;
+}
 /**
  * Official Node.js client for Oil Price API
  *
@@ -105,7 +125,29 @@ export declare class OilPriceAPI {
      * Data sources resource (BYOS - Bring Your Own Source)
      */
     readonly dataSources: DataSourcesResource;
-    constructor(config: OilPriceAPIConfig);
+    /**
+     * Spreads resource (crack, basis, curve structure, margin, physical premium)
+     */
+    readonly spreads: SpreadsResource;
+    /**
+     * Indicators resource (fuel switching, price context, storage analytics,
+     * annotations, CFTC positioning, congressional trades)
+     */
+    readonly indicators: IndicatorsResource;
+    /**
+     * Raw-response accessor.
+     *
+     * Mirrors the top-level price/commodity methods but returns the underlying
+     * HTTP status and headers alongside the parsed data via {@link APIResponse}.
+     */
+    readonly raw: RawResource;
+    /**
+     * Real-time price streaming resource (WebSocket / ActionCable).
+     *
+     * Streaming requires a Reservoir Mastery (Professional+) plan.
+     */
+    readonly stream: StreamingResource;
+    constructor(config?: OilPriceAPIConfig);
     /**
      * Log debug messages if debug mode is enabled
      */
@@ -123,9 +165,28 @@ export declare class OilPriceAPI {
      */
     private isRetryable;
     /**
-     * Internal method to make HTTP requests with retry and timeout
+     * 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.
+     */
+    private shapeResponseData;
+    /**
+     * 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.
      */
     private request;
+    /**
+     * 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.
+     */
+    private requestRaw;
     /**
      * Get the latest prices for all commodities or a specific commodity
      *
@@ -165,6 +226,35 @@ export declare class OilPriceAPI {
      * ```
      */
     getHistoricalPrices(options?: HistoricalPricesOptions): Promise<Price[]>;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    paginateHistoricalPrices(options?: HistoricalPricesOptions): AsyncGenerator<Price[]>;
     /**
      * Get prices from your connected data sources (BYOS)
      *
@@ -221,4 +311,41 @@ export declare class OilPriceAPI {
      * ```
      */
     getCommodity(code: string): Promise<Commodity>;
+    /**
+     * 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);
+     * ```
+     */
+    getDemoPrices(): Promise<DemoPricesResponse>;
+    /**
+     * 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);
+     * ```
+     */
+    getDemoCommodities(): Promise<DemoCommoditiesResponse>;
+    /**
+     * 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 }`.
+     */
+    private requestDemo;
 }

package/dist/client.js

@@ -14,6 +14,10 @@ import { EnergyIntelligenceResource } from "./resources/ei/index.js";
 import { WebhooksResource } from "./resources/webhooks.js";
 import { DataSourcesResource } from "./resources/data-sources.js";
 import { SDK_VERSION, SDK_NAME, buildUserAgent } from "./version.js";
+import { SpreadsResource } from "./resources/spreads.js";
+import { IndicatorsResource } from "./resources/indicators.js";
+import { RawResource } from "./resources/raw.js";
+import { StreamingResource } from "./resources/streaming.js";
 /**
  * Official Node.js client for Oil Price API
  *
@@ -41,11 +45,11 @@ import { SDK_VERSION, SDK_NAME, buildUserAgent } from "./version.js";
  * ```
  */
 export class OilPriceAPI {
-    constructor(config) {
-        if (!config.apiKey) {
-            throw new OilPriceAPIError("API key is required");
+    constructor(config = {}) {
+        this.apiKey = config.apiKey || process.env.OILPRICEAPI_KEY || "";
+        if (!this.apiKey) {
+            throw new OilPriceAPIError("API key required. Set OILPRICEAPI_KEY env var or pass apiKey in config.");
         }
-        this.apiKey = config.apiKey;
         this.baseUrl = config.baseUrl || "https://api.oilpriceapi.com";
         this.retries = config.retries !== undefined ? config.retries : 3;
         this.retryDelay = config.retryDelay || 1000;
@@ -69,6 +73,10 @@ export class OilPriceAPI {
         this.ei = new EnergyIntelligenceResource(this);
         this.webhooks = new WebhooksResource(this);
         this.dataSources = new DataSourcesResource(this);
+        this.spreads = new SpreadsResource(this);
+        this.indicators = new IndicatorsResource(this);
+        this.raw = new RawResource(this);
+        this.stream = new StreamingResource(this);
     }
     /**
      * Log debug messages if debug mode is enabled
@@ -123,9 +131,50 @@ export class OilPriceAPI {
         return false;
     }
     /**
-     * Internal method to make HTTP requests with retry and timeout
+     * 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 request(endpoint, params) {
+    async requestRaw(endpoint, params, options) {
         // Build URL with query parameters
         const url = new URL(`${this.baseUrl}${endpoint}`);
         if (params) {
@@ -163,11 +212,15 @@ export class OilPriceAPI {
                     if (this.appName) {
                         headers["X-App-Name"] = this.appName;
                     }
-                    const response = await fetch(url.toString(), {
-                        method: "GET",
+                    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
@@ -177,8 +230,7 @@ export class OilPriceAPI {
                         // Try to parse JSON error response
                         try {
                             const errorJson = JSON.parse(errorBody);
-                            errorMessage =
-                                errorJson.message || errorJson.error || errorMessage;
+                            errorMessage = errorJson.message || errorJson.error || errorMessage;
                         }
                         catch {
                             // Use default error message if response isn't JSON
@@ -209,30 +261,27 @@ export class OilPriceAPI {
                                 throw new 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 = await response.json();
+                    const responseData = JSON.parse(responseText);
                     this.log("Response data received", {
                         status: responseData.status,
                         hasData: !!responseData.data,
                     });
-                    // 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
-                    this.log("Returning data as-is");
-                    return responseData.data;
+                    return {
+                        data: this.shapeResponseData(responseData),
+                        status: response.status,
+                        headers: response.headers,
+                    };
                 }
                 catch (error) {
                     // Handle abort (timeout)
@@ -353,6 +402,51 @@ export class OilPriceAPI {
         // 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)
      *
@@ -427,4 +521,86 @@ export class OilPriceAPI {
     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": buildUserAgent(),
+                    "X-SDK-Name": SDK_NAME,
+                    "X-SDK-Version": 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 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 TimeoutError("Request timeout", this.timeout);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
 }

package/dist/errors.d.ts

@@ -40,6 +40,12 @@ export declare class NotFoundError extends OilPriceAPIError {
 export declare class ServerError extends OilPriceAPIError {
     constructor(message?: string, statusCode?: number);
 }
+/**
+ * Thrown when SDK-side input validation fails
+ */
+export declare class ValidationError extends OilPriceAPIError {
+    constructor(message: string);
+}
 /**
  * Thrown when request exceeds timeout
  */

package/dist/errors.js

@@ -4,7 +4,7 @@
 export class OilPriceAPIError extends Error {
     constructor(message, statusCode, code) {
         super(message);
-        this.name = 'OilPriceAPIError';
+        this.name = "OilPriceAPIError";
         this.statusCode = statusCode;
         this.code = code;
         // Maintains proper stack trace for where our error was thrown (only available on V8)
@@ -17,18 +17,18 @@ export class OilPriceAPIError extends Error {
  * Thrown when API authentication fails (401)
  */
 export class AuthenticationError extends OilPriceAPIError {
-    constructor(message = 'Invalid API key') {
-        super(message, 401, 'AUTHENTICATION_ERROR');
-        this.name = 'AuthenticationError';
+    constructor(message = "Invalid API key") {
+        super(message, 401, "AUTHENTICATION_ERROR");
+        this.name = "AuthenticationError";
     }
 }
 /**
  * Thrown when rate limit is exceeded (429)
  */
 export class RateLimitError extends OilPriceAPIError {
-    constructor(message = 'Rate limit exceeded', retryAfter) {
-        super(message, 429, 'RATE_LIMIT_ERROR');
-        this.name = 'RateLimitError';
+    constructor(message = "Rate limit exceeded", retryAfter) {
+        super(message, 429, "RATE_LIMIT_ERROR");
+        this.name = "RateLimitError";
         this.retryAfter = retryAfter;
     }
 }
@@ -36,26 +36,35 @@ export class RateLimitError extends OilPriceAPIError {
  * Thrown when requested resource is not found (404)
  */
 export class NotFoundError extends OilPriceAPIError {
-    constructor(message = 'Resource not found') {
-        super(message, 404, 'NOT_FOUND_ERROR');
-        this.name = 'NotFoundError';
+    constructor(message = "Resource not found") {
+        super(message, 404, "NOT_FOUND_ERROR");
+        this.name = "NotFoundError";
     }
 }
 /**
  * Thrown when server returns 5xx error
  */
 export class ServerError extends OilPriceAPIError {
-    constructor(message = 'Internal server error', statusCode = 500) {
-        super(message, statusCode, 'SERVER_ERROR');
-        this.name = 'ServerError';
+    constructor(message = "Internal server error", statusCode = 500) {
+        super(message, statusCode, "SERVER_ERROR");
+        this.name = "ServerError";
+    }
+}
+/**
+ * Thrown when SDK-side input validation fails
+ */
+export class ValidationError extends OilPriceAPIError {
+    constructor(message) {
+        super(message, undefined, "VALIDATION_ERROR");
+        this.name = "ValidationError";
     }
 }
 /**
  * Thrown when request exceeds timeout
  */
 export class TimeoutError extends OilPriceAPIError {
-    constructor(message = 'Request timeout', timeout) {
-        super(`${message} (${timeout}ms)`, undefined, 'TIMEOUT_ERROR');
-        this.name = 'TimeoutError';
+    constructor(message = "Request timeout", timeout) {
+        super(`${message} (${timeout}ms)`, undefined, "TIMEOUT_ERROR");
+        this.name = "TimeoutError";
     }
 }

package/dist/index.d.ts

@@ -6,22 +6,29 @@
  * @packageDocumentation
  */
 export { OilPriceAPI } from "./client.js";
+export type { APIResponse } from "./client.js";
 export { SDK_VERSION, SDK_NAME } from "./version.js";
-export type { OilPriceAPIConfig, RetryStrategy, Price, LatestPricesOptions, HistoricalPricesOptions, HistoricalPeriod, AggregationInterval, Commodity, CommoditiesResponse, CommodityCategory, CategoriesResponse, DataConnectorPrice, DataConnectorOptions, } from "./types.js";
+export type { OilPriceAPIConfig, RetryStrategy, Price, LatestPricesOptions, HistoricalPricesOptions, HistoricalPeriod, AggregationInterval, Commodity, CommoditiesResponse, CommodityCategory, CategoriesResponse, DataConnectorPrice, DataConnectorOptions, DemoPrice, DemoPricesResponse, DemoCommoditiesResponse, } from "./types.js";
 export type { DieselPrice, DieselStation, DieselStationsResponse, GetDieselStationsOptions, } from "./resources/diesel.js";
 export type { PriceAlert, CreateAlertParams, UpdateAlertParams, AlertOperator, } from "./resources/alerts.js";
-export type { FuturesPrice, HistoricalFuturesPrice, HistoricalFuturesOptions, FuturesOHLC, IntradayPrice, IntradayFuturesData, FuturesSpread, FuturesCurvePoint, FuturesCurveData, ContinuousContractPrice, ContinuousFuturesData, } from "./resources/futures.js";
+export type { FuturesPrice, HistoricalFuturesPrice, HistoricalFuturesOptions, FuturesOHLC, IntradayPrice, IntradayFuturesData, FuturesSpread, FuturesCurvePoint, FuturesCurveData, ContinuousContractPrice, ContinuousFuturesData, FuturesSpreadHistoryPoint, FuturesSpreadHistory, FuturesContractFamilySlug, } from "./resources/futures.js";
+export { FUTURES_CONTRACTS, FUTURES_FAMILY_SLUGS, FuturesContractFamily, } from "./resources/futures.js";
+export type { SpreadType, SpreadValue, HistoricalSpreadValue, HistoricalSpreadOptions, } from "./resources/spreads.js";
+export { SpreadsResource } from "./resources/spreads.js";
+export type { IndicatorType, FuelSwitchingIndicator, PriceContextIndicator, StorageAnalyticsIndicator, AnnotationIndicator, CFTCPositioningIndicator, CongressionalTradeIndicator, } from "./resources/indicators.js";
+export { IndicatorsResource } from "./resources/indicators.js";
+export { RawResource } from "./resources/raw.js";
 export type { StorageData, HistoricalStorageData, HistoricalStorageOptions, } from "./resources/storage.js";
 export type { RigCountData, HistoricalRigCountData, HistoricalRigCountOptions, RigCountTrend, RigCountSummary, } from "./resources/rig-counts.js";
 export type { BunkerFuelPrice, PortBunkerPrices, PortPriceComparison, BunkerFuelSpreads, HistoricalBunkerPrice, HistoricalBunkerOptions, } from "./resources/bunker-fuels.js";
-export type { PerformanceMetrics, PerformanceOptions, StatisticalAnalysis, CorrelationAnalysis, TrendAnalysis, SpreadAnalysis, ForecastPoint, PriceForecast as AnalyticsPriceForecast, } from "./resources/analytics.js";
-export type { MonthlyForecast, ForecastAccuracy, ArchivedForecast, } from "./resources/forecasts.js";
+export type { PerformanceMetrics, PerformanceOptions, StatisticalAnalysis, CorrelationAnalysis, CorrelationOptions, TrendAnalysis, TrendOptions, SpreadAnalysis, SpreadOptions, ForecastOptions, PriceForecast as AnalyticsPriceForecast, } from "./resources/analytics.js";
+export type { MonthlyForecast, ForecastAccuracy, ArchivedForecast } from "./resources/forecasts.js";
 export type { DataQualitySummary, DataQualityReportMeta, DataQualityReport, } from "./resources/data-quality.js";
 export type { DrillingIntelligenceData, LatestDrillingData, DrillingSummary, DrillingTrend, FracSpreadData, WellPermitData, DUCWellData, CompletionData, WellsDrilledData, BasinDrillingData, } from "./resources/drilling.js";
 export type { WellTimelineEvent, WellTimeline, RigCountRecord, RigCountByBasin, RigCountByState, HistoricalRigCount, OilInventoryRecord, OilInventorySummary, InventoryByProduct, HistoricalInventory, CushingInventory, OPECProductionRecord, TotalOPECProduction, ProductionByCountry, HistoricalProduction, TopProducer, DrillingProductivityRecord, DrillingProductivitySummary, DUCWellInventory, ProductivityByBasin, HistoricalProductivity, ProductivityTrend, ForecastRecord, ForecastSummary, PriceForecast, ProductionForecast, HistoricalForecast, ForecastComparison, WellPermitRecord, WellPermitSummary, PermitsByState, PermitsByOperator, PermitsByFormation, WellPermitSearchQuery, FracFocusRecord, FracFocusSummary, DisclosuresByState, DisclosuresByOperator, ChemicalUsage, WellChemical, FracFocusSearchQuery, } from "./resources/ei/index.js";
 export type { WebhookEndpoint, CreateWebhookParams, UpdateWebhookParams, WebhookTestResponse as WebhookTestResult, WebhookEvent, } from "./resources/webhooks.js";
 export type { DataSourceType, DataSourceStatus, DataSource, CreateDataSourceParams, UpdateDataSourceParams, DataSourceTestResponse, DataSourceLog, DataSourceHealth, CredentialRotationResponse, } from "./resources/data-sources.js";
-export { OilPriceAPIError, AuthenticationError, RateLimitError, NotFoundError, ServerError, TimeoutError, } from "./errors.js";
+export { OilPriceAPIError, AuthenticationError, RateLimitError, NotFoundError, ServerError, ValidationError, TimeoutError, } from "./errors.js";
 export { DieselResource } from "./resources/diesel.js";
 export { AlertsResource } from "./resources/alerts.js";
 export { CommoditiesResource } from "./resources/commodities.js";
@@ -36,3 +43,19 @@ export { DrillingIntelligenceResource } from "./resources/drilling.js";
 export { EnergyIntelligenceResource, EIRigCountsResource, EIOilInventoriesResource, EIOPECProductionResource, EIDrillingProductivityResource, EIForecastsResource, EIWellPermitsResource, EIFracFocusResource, } from "./resources/ei/index.js";
 export { WebhooksResource } from "./resources/webhooks.js";
 export { DataSourcesResource } from "./resources/data-sources.js";
+export { StreamingResource, PriceStreamSubscription, ENERGY_PRICES_CHANNEL, } from "./resources/streaming.js";
+export type { StreamPricesOptions, PriceUpdateHandler, StreamMessage, WelcomeMessage, PriceUpdateMessage, RigCountUpdateMessage, StreamedPrice, StreamedPriceMap, } from "./resources/streaming.js";
+/**
+ * Standalone webhook signature verification.
+ *
+ * Convenience function for verifying webhook signatures without
+ * instantiating a full client.
+ *
+ * @example
+ * ```typescript
+ * import { verifyWebhookSignature } from 'oilpriceapi';
+ *
+ * const isValid = verifyWebhookSignature(rawBody, signatureHeader, secret);
+ * ```
+ */
+export declare function verifyWebhookSignature(payload: string | Buffer, signature: string, secret: string): boolean;

package/dist/index.js

@@ -5,9 +5,14 @@
  *
  * @packageDocumentation
  */
+import { createHmac, timingSafeEqual } from "node:crypto";
 export { OilPriceAPI } from "./client.js";
 export { SDK_VERSION, SDK_NAME } from "./version.js";
-export { OilPriceAPIError, AuthenticationError, RateLimitError, NotFoundError, ServerError, TimeoutError, } from "./errors.js";
+export { FUTURES_CONTRACTS, FUTURES_FAMILY_SLUGS, FuturesContractFamily, } from "./resources/futures.js";
+export { SpreadsResource } from "./resources/spreads.js";
+export { IndicatorsResource } from "./resources/indicators.js";
+export { RawResource } from "./resources/raw.js";
+export { OilPriceAPIError, AuthenticationError, RateLimitError, NotFoundError, ServerError, ValidationError, TimeoutError, } from "./errors.js";
 export { DieselResource } from "./resources/diesel.js";
 export { AlertsResource } from "./resources/alerts.js";
 export { CommoditiesResource } from "./resources/commodities.js";
@@ -22,3 +27,26 @@ export { DrillingIntelligenceResource } from "./resources/drilling.js";
 export { EnergyIntelligenceResource, EIRigCountsResource, EIOilInventoriesResource, EIOPECProductionResource, EIDrillingProductivityResource, EIForecastsResource, EIWellPermitsResource, EIFracFocusResource, } from "./resources/ei/index.js";
 export { WebhooksResource } from "./resources/webhooks.js";
 export { DataSourcesResource } from "./resources/data-sources.js";
+export { StreamingResource, PriceStreamSubscription, ENERGY_PRICES_CHANNEL, } from "./resources/streaming.js";
+/**
+ * Standalone webhook signature verification.
+ *
+ * Convenience function for verifying webhook signatures without
+ * instantiating a full client.
+ *
+ * @example
+ * ```typescript
+ * import { verifyWebhookSignature } from 'oilpriceapi';
+ *
+ * const isValid = verifyWebhookSignature(rawBody, signatureHeader, secret);
+ * ```
+ */
+export function verifyWebhookSignature(payload, signature, secret) {
+    const expectedSignature = "sha256=" + createHmac("sha256", secret).update(payload).digest("hex");
+    try {
+        return timingSafeEqual(Buffer.from(expectedSignature), Buffer.from(signature));
+    }
+    catch {
+        return false;
+    }
+}