oilpriceapi 0.6.0 → 0.8.2

package/dist/client.d.ts

@@ -1,6 +1,18 @@
-import type { OilPriceAPIConfig, Price, LatestPricesOptions, HistoricalPricesOptions, Commodity, CommoditiesResponse, CategoriesResponse } from './types.js';
-import { DieselResource } from './resources/diesel.js';
-import { AlertsResource } from './resources/alerts.js';
+import type { OilPriceAPIConfig, Price, LatestPricesOptions, HistoricalPricesOptions, Commodity, CommoditiesResponse, CategoriesResponse, DataConnectorPrice, DataConnectorOptions } from "./types.js";
+import { DieselResource } from "./resources/diesel.js";
+import { AlertsResource } from "./resources/alerts.js";
+import { CommoditiesResource } from "./resources/commodities.js";
+import { FuturesResource } from "./resources/futures.js";
+import { StorageResource } from "./resources/storage.js";
+import { RigCountsResource } from "./resources/rig-counts.js";
+import { BunkerFuelsResource } from "./resources/bunker-fuels.js";
+import { AnalyticsResource } from "./resources/analytics.js";
+import { ForecastsResource } from "./resources/forecasts.js";
+import { DataQualityResource } from "./resources/data-quality.js";
+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";
 /**
  * Official Node.js client for Oil Price API
  *
@@ -35,6 +47,8 @@ export declare class OilPriceAPI {
     private retryStrategy;
     private timeout;
     private debug;
+    private appUrl?;
+    private appName?;
     /**
      * Diesel prices resource (state averages + station-level pricing)
      */
@@ -43,7 +57,55 @@ export declare class OilPriceAPI {
      * Price alerts resource (create, manage, and monitor alerts)
      */
     readonly alerts: AlertsResource;
-    constructor(config: OilPriceAPIConfig);
+    /**
+     * Commodities resource (metadata and categories)
+     */
+    readonly commodities: CommoditiesResource;
+    /**
+     * Futures resource (contracts, OHLC, curves, spreads)
+     */
+    readonly futures: FuturesResource;
+    /**
+     * Storage resource (inventory levels, Cushing, SPR)
+     */
+    readonly storage: StorageResource;
+    /**
+     * Rig counts resource (Baker Hughes rig count data)
+     */
+    readonly rigCounts: RigCountsResource;
+    /**
+     * Bunker fuels resource (marine fuel prices at ports)
+     */
+    readonly bunkerFuels: BunkerFuelsResource;
+    /**
+     * Analytics resource (performance, statistics, correlations)
+     */
+    readonly analytics: AnalyticsResource;
+    /**
+     * Forecasts resource (EIA/IEA forecasts and accuracy)
+     */
+    readonly forecasts: ForecastsResource;
+    /**
+     * Data quality resource (quality metrics and reports)
+     */
+    readonly dataQuality: DataQualityResource;
+    /**
+     * Drilling intelligence resource (US onshore drilling activity)
+     */
+    readonly drilling: DrillingIntelligenceResource;
+    /**
+     * Energy intelligence resource (comprehensive market intelligence)
+     */
+    readonly ei: EnergyIntelligenceResource;
+    /**
+     * Webhooks resource (webhook endpoint management)
+     */
+    readonly webhooks: WebhooksResource;
+    /**
+     * Data sources resource (BYOS - Bring Your Own Source)
+     */
+    readonly dataSources: DataSourcesResource;
+    constructor(config?: OilPriceAPIConfig);
     /**
      * Log debug messages if debug mode is enabled
      */
@@ -61,7 +123,9 @@ export declare class OilPriceAPI {
      */
     private isRetryable;
     /**
-     * Internal method to make HTTP requests with retry and timeout
+     * 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;
     /**
@@ -103,6 +167,53 @@ 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)
+     *
+     * 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' });
+     * ```
+     */
+    getDataConnectorPrices(options?: DataConnectorOptions): Promise<DataConnectorPrice[]>;
     /**
      * Get metadata for all supported commodities
      *

package/dist/client.js

@@ -1,7 +1,19 @@
-import { OilPriceAPIError, AuthenticationError, RateLimitError, NotFoundError, ServerError, TimeoutError, } from './errors.js';
-import { DieselResource } from './resources/diesel.js';
-import { AlertsResource } from './resources/alerts.js';
-import { SDK_VERSION, SDK_NAME, buildUserAgent } from './version.js';
+import { OilPriceAPIError, AuthenticationError, RateLimitError, NotFoundError, ServerError, TimeoutError, } from "./errors.js";
+import { DieselResource } from "./resources/diesel.js";
+import { AlertsResource } from "./resources/alerts.js";
+import { CommoditiesResource } from "./resources/commodities.js";
+import { FuturesResource } from "./resources/futures.js";
+import { StorageResource } from "./resources/storage.js";
+import { RigCountsResource } from "./resources/rig-counts.js";
+import { BunkerFuelsResource } from "./resources/bunker-fuels.js";
+import { AnalyticsResource } from "./resources/analytics.js";
+import { ForecastsResource } from "./resources/forecasts.js";
+import { DataQualityResource } from "./resources/data-quality.js";
+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 { SDK_VERSION, SDK_NAME, buildUserAgent } from "./version.js";
 /**
  * Official Node.js client for Oil Price API
  *
@@ -29,20 +41,34 @@ 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.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.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 DieselResource(this);
         this.alerts = new AlertsResource(this);
+        this.commodities = new CommoditiesResource(this);
+        this.futures = new FuturesResource(this);
+        this.storage = new StorageResource(this);
+        this.rigCounts = new RigCountsResource(this);
+        this.bunkerFuels = new BunkerFuelsResource(this);
+        this.analytics = new AnalyticsResource(this);
+        this.forecasts = new ForecastsResource(this);
+        this.dataQuality = new DataQualityResource(this);
+        this.drilling = new DrillingIntelligenceResource(this);
+        this.ei = new EnergyIntelligenceResource(this);
+        this.webhooks = new WebhooksResource(this);
+        this.dataSources = new DataSourcesResource(this);
     }
     /**
      * Log debug messages if debug mode is enabled
@@ -50,7 +76,7 @@ export class OilPriceAPI {
     log(message, data) {
         if (this.debug) {
             const timestamp = new Date().toISOString();
-            console.log(`[OilPriceAPI ${timestamp}] ${message}`, data || '');
+            console.log(`[OilPriceAPI ${timestamp}] ${message}`, data || "");
         }
     }
     /**
@@ -58,11 +84,11 @@ export class OilPriceAPI {
      */
     calculateRetryDelay(attempt) {
         switch (this.retryStrategy) {
-            case 'exponential':
+            case "exponential":
                 return this.retryDelay * Math.pow(2, attempt);
-            case 'linear':
+            case "linear":
                 return this.retryDelay * (attempt + 1);
-            case 'fixed':
+            case "fixed":
             default:
                 return this.retryDelay;
         }
@@ -71,14 +97,14 @@ export class OilPriceAPI {
      * Sleep for specified milliseconds
      */
     sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, 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')) {
+        if (error instanceof TypeError && error.message.includes("fetch")) {
             return true;
         }
         // Retry on timeout errors
@@ -97,9 +123,11 @@ export class OilPriceAPI {
         return false;
     }
     /**
-     * Internal method to make HTTP requests with retry and timeout
+     * 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) {
+    async request(endpoint, params, options) {
         // Build URL with query parameters
         const url = new URL(`${this.baseUrl}${endpoint}`);
         if (params) {
@@ -122,17 +150,30 @@ export class OilPriceAPI {
                 const controller = new AbortController();
                 const timeoutId = setTimeout(() => controller.abort(), this.timeout);
                 try {
-                    const response = await fetch(url.toString(), {
-                        method: 'GET',
-                        headers: {
-                            'Authorization': `Bearer ${this.apiKey}`,
-                            'Content-Type': 'application/json',
-                            'User-Agent': buildUserAgent(),
-                            'X-Api-Client': SDK_NAME,
-                            'X-Client-Version': SDK_VERSION,
-                        },
+                    // Build headers with optional telemetry
+                    const headers = {
+                        Authorization: `Bearer ${this.apiKey}`,
+                        "Content-Type": "application/json",
+                        "User-Agent": buildUserAgent(),
+                        "X-SDK-Name": SDK_NAME,
+                        "X-SDK-Version": 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
@@ -155,7 +196,7 @@ export class OilPriceAPI {
                             case 404:
                                 throw new NotFoundError(errorMessage);
                             case 429:
-                                const retryAfter = response.headers.get('Retry-After');
+                                const retryAfter = response.headers.get("Retry-After");
                                 const rateLimitError = new RateLimitError(errorMessage, retryAfter ? parseInt(retryAfter, 10) : undefined);
                                 // If rate limited and we have retries left, wait and retry
                                 if (attempt < this.retries && rateLimitError.retryAfter) {
@@ -170,19 +211,25 @@ export class OilPriceAPI {
                             case 504:
                                 throw new ServerError(errorMessage, response.status);
                             default:
-                                throw new OilPriceAPIError(errorMessage, response.status, 'HTTP_ERROR');
+                                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 {};
+                    }
                     // Parse successful response
-                    const responseData = await response.json();
-                    this.log('Response data received', {
+                    const responseData = JSON.parse(responseText);
+                    this.log("Response data received", {
                         status: responseData.status,
-                        hasData: !!responseData.data
+                        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.status === "success" && responseData.data) {
                         if (responseData.data.prices) {
                             // Historical endpoint - return prices array
                             this.log(`Returning ${responseData.data.prices.length} prices`);
@@ -190,18 +237,18 @@ export class OilPriceAPI {
                         }
                         else if (responseData.data.price !== undefined) {
                             // Latest endpoint - wrap single price in array
-                            this.log('Returning single price (wrapped 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;
+                    // 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);
                 }
                 catch (error) {
                     // Handle abort (timeout)
-                    if (error instanceof Error && error.name === 'AbortError') {
-                        throw new TimeoutError('Request timeout', this.timeout);
+                    if (error instanceof Error && error.name === "AbortError") {
+                        throw new TimeoutError("Request timeout", this.timeout);
                     }
                     throw error;
                 }
@@ -210,7 +257,7 @@ export class OilPriceAPI {
                 lastError = error;
                 this.log(`Request failed: ${lastError.message}`, {
                     attempt,
-                    retryable: this.isRetryable(lastError)
+                    retryable: this.isRetryable(lastError),
                 });
                 // Re-throw our custom errors if not retryable
                 if (error instanceof OilPriceAPIError && !this.isRetryable(error)) {
@@ -223,7 +270,7 @@ export class OilPriceAPI {
                     }
                     // Wrap fetch errors (network issues, etc.)
                     if (error instanceof Error) {
-                        throw new OilPriceAPIError(`Request failed after ${this.retries + 1} attempts: ${error.message}`, undefined, 'NETWORK_ERROR');
+                        throw new OilPriceAPIError(`Request failed after ${this.retries + 1} attempts: ${error.message}`, undefined, "NETWORK_ERROR");
                     }
                     throw error;
                 }
@@ -234,7 +281,7 @@ export class OilPriceAPI {
             }
         }
         // This should never be reached, but TypeScript wants it
-        throw lastError || new OilPriceAPIError('Unknown error occurred');
+        throw lastError || new OilPriceAPIError("Unknown error occurred");
     }
     /**
      * Get the latest prices for all commodities or a specific commodity
@@ -256,7 +303,7 @@ export class OilPriceAPI {
         if (options?.commodity) {
             params.by_code = options.commodity;
         }
-        return this.request('/v1/prices/latest', params);
+        return this.request("/v1/prices/latest", params);
     }
     /**
      * Get historical prices for a time period
@@ -315,7 +362,82 @@ export class OilPriceAPI {
         // 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);
+        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
@@ -329,7 +451,7 @@ export class OilPriceAPI {
      * ```
      */
     async getCommodities() {
-        return this.request('/v1/commodities', {});
+        return this.request("/v1/commodities", {});
     }
     /**
      * Get all commodity categories with their commodities
@@ -344,7 +466,7 @@ export class OilPriceAPI {
      * ```
      */
     async getCommodityCategories() {
-        return this.request('/v1/commodities/categories', {});
+        return this.request("/v1/commodities/categories", {});
     }
     /**
      * Get metadata for a specific commodity by code

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

@@ -5,9 +5,48 @@
  *
  * @packageDocumentation
  */
-export { OilPriceAPI } from './client.js';
-export { SDK_VERSION, SDK_NAME } from './version.js';
-export type { OilPriceAPIConfig, RetryStrategy, Price, LatestPricesOptions, HistoricalPricesOptions, HistoricalPeriod, AggregationInterval, Commodity, CommoditiesResponse, CommodityCategory, CategoriesResponse, } from './types.js';
-export type { DieselPrice, DieselStation, DieselStationsResponse, GetDieselStationsOptions, } from './resources/diesel.js';
-export type { PriceAlert, CreateAlertParams, UpdateAlertParams, AlertOperator, WebhookTestResponse, } from './resources/alerts.js';
-export { OilPriceAPIError, AuthenticationError, RateLimitError, NotFoundError, ServerError, TimeoutError, } from './errors.js';
+export { OilPriceAPI } 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 { 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 { 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 { 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, ValidationError, TimeoutError, } from "./errors.js";
+export { DieselResource } from "./resources/diesel.js";
+export { AlertsResource } from "./resources/alerts.js";
+export { CommoditiesResource } from "./resources/commodities.js";
+export { FuturesResource } from "./resources/futures.js";
+export { StorageResource } from "./resources/storage.js";
+export { RigCountsResource } from "./resources/rig-counts.js";
+export { BunkerFuelsResource } from "./resources/bunker-fuels.js";
+export { AnalyticsResource } from "./resources/analytics.js";
+export { ForecastsResource } from "./resources/forecasts.js";
+export { DataQualityResource } from "./resources/data-quality.js";
+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";
+/**
+ * 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;