oilpriceapi 0.5.3 → 0.7.0

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,6 +57,54 @@ export declare class OilPriceAPI {
      * Price alerts resource (create, manage, and monitor alerts)
      */
     readonly alerts: AlertsResource;
+    /**
+     * 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
@@ -103,6 +165,24 @@ export declare class OilPriceAPI {
      * ```
      */
     getHistoricalPrices(options?: HistoricalPricesOptions): Promise<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
  *
@@ -31,18 +43,32 @@ import { SDK_VERSION, SDK_NAME, buildUserAgent } from './version.js';
 export class OilPriceAPI {
     constructor(config) {
         if (!config.apiKey) {
-            throw new OilPriceAPIError('API key is required');
+            throw new OilPriceAPIError("API key is required");
         }
         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
@@ -122,15 +148,24 @@ export class OilPriceAPI {
                 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": 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 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,
-                        },
+                        method: "GET",
+                        headers,
                         signal: controller.signal,
                     });
                     clearTimeout(timeoutId);
@@ -142,7 +177,8 @@ 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
@@ -155,7 +191,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 +206,19 @@ 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");
                         }
                     }
                     // Parse successful response
                     const responseData = await response.json();
-                    this.log('Response data received', {
+                    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 +226,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');
+                    this.log("Returning data as-is");
                     return responseData.data;
                 }
                 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 +246,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 +259,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 +270,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 +292,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
@@ -294,6 +330,20 @@ export class OilPriceAPI {
         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
@@ -301,7 +351,37 @@ 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);
+    }
+    /**
+     * 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
@@ -315,7 +395,7 @@ export class OilPriceAPI {
      * ```
      */
     async getCommodities() {
-        return this.request('/v1/commodities', {});
+        return this.request("/v1/commodities", {});
     }
     /**
      * Get all commodity categories with their commodities
@@ -330,7 +410,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/index.d.ts

@@ -5,9 +5,34 @@
  *
  * @packageDocumentation
  */
-export { OilPriceAPI } from './client.js';
-export { SDK_VERSION, SDK_NAME } from './version.js';
-export type { OilPriceAPIConfig, RetryStrategy, Price, LatestPricesOptions, HistoricalPricesOptions, HistoricalPeriod, 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, 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";

package/dist/index.js

@@ -5,6 +5,20 @@
  *
  * @packageDocumentation
  */
-export { OilPriceAPI } from './client.js';
-export { SDK_VERSION, SDK_NAME } from './version.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 { OilPriceAPIError, AuthenticationError, RateLimitError, NotFoundError, ServerError, 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";

package/dist/resources/alerts.d.ts

@@ -3,11 +3,11 @@
  *
  * Manage price alert configurations for automated notifications.
  */
-import type { OilPriceAPI } from '../client.js';
+import type { OilPriceAPI } from "../client.js";
 /**
  * Valid condition operators for price alerts
  */
-export type AlertOperator = 'greater_than' | 'less_than' | 'equals' | 'greater_than_or_equal' | 'less_than_or_equal';
+export type AlertOperator = "greater_than" | "less_than" | "equals" | "greater_than_or_equal" | "less_than_or_equal";
 /**
  * Price alert configuration
  */
@@ -275,24 +275,61 @@ export declare class AlertsResource {
      */
     delete(id: string): Promise<void>;
     /**
-     * Test a webhook endpoint
+     * Test an alert
      *
-     * **NOTE:** This feature is not yet available in the API. The `/v1/alerts/test_webhook`
-     * endpoint has not been implemented yet. This method will throw an error until the
-     * backend endpoint is added.
+     * Triggers a test run of the alert to verify it's working correctly.
+     * Does not affect the alert's cooldown or trigger count.
      *
-     * To test if an alert would trigger, use the backend's `/v1/alerts/test` endpoint instead:
-     * ```bash
-     * curl -X POST "https://api.oilpriceapi.com/v1/alerts/:id/test" \
-     *   -H "Authorization: Bearer YOUR_API_KEY"
+     * @param alertId - The alert ID to test
+     * @returns Test results
+     *
+     * @throws {NotFoundError} If alert not found
+     * @throws {OilPriceAPIError} If API request fails
+     *
+     * @example
+     * ```typescript
+     * const result = await client.alerts.test(alertId);
+     * console.log(`Test ${result.success ? 'passed' : 'failed'}`);
+     * if (result.response_time_ms) {
+     *   console.log(`Webhook response time: ${result.response_time_ms}ms`);
+     * }
      * ```
+     */
+    test(alertId: string): Promise<WebhookTestResponse>;
+    /**
+     * Get available alert triggers
+     *
+     * Returns list of supported trigger conditions and event types.
      *
-     * @param webhookUrl - The HTTPS webhook URL to test
-     * @returns Test results including response time and status
+     * @returns Array of available triggers
      *
-     * @throws {Error} Feature not yet available
+     * @throws {OilPriceAPIError} If API request fails
      *
-     * @deprecated This feature is not yet available in the API
+     * @example
+     * ```typescript
+     * const triggers = await client.alerts.triggers();
+     * triggers.forEach(trigger => {
+     *   console.log(`${trigger.name}: ${trigger.description}`);
+     * });
+     * ```
+     */
+    triggers(): Promise<any[]>;
+    /**
+     * Get alert analytics history
+     *
+     * Returns historical analytics data for alerts including trigger frequency,
+     * success rates, and response times.
+     *
+     * @returns Analytics history data
+     *
+     * @throws {OilPriceAPIError} If API request fails
+     *
+     * @example
+     * ```typescript
+     * const analytics = await client.alerts.analyticsHistory();
+     * console.log(`Total triggers: ${analytics.total_triggers}`);
+     * console.log(`Success rate: ${analytics.success_rate}%`);
+     * ```
      */
-    testWebhook(webhookUrl: string): Promise<WebhookTestResponse>;
+    analyticsHistory(): Promise<any>;
 }