@gravito/echo 3.0.0 → 3.1.0

package/dist/echo/src/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview \@gravito/echo - Enterprise Webhook Orchestration
+ *
+ * Echo provides a secure, reliable, and observable layer for handling webhooks
+ * in Gravito applications. It standardizes incoming webhook reception with
+ * signature verification and dynamic key rotation, while ensuring reliable
+ * outgoing delivery via exponential backoff and circuit breaking.
+ *
+ * @example Receiving webhooks from Stripe
+ * ```typescript
+ * import { OrbitEcho, WebhookReceiver } from '@gravito/echo'
+ *
+ * const core = new PlanetCore()
+ * core.install(new OrbitEcho({
+ *   providers: {
+ *     stripe: { name: 'stripe', secret: process.env.STRIPE_SECRET! }
+ *   }
+ * }))
+ *
+ * const receiver = core.container.make<WebhookReceiver>('echo.receiver')
+ * receiver.on('stripe', 'payment_intent.succeeded', async (event) => {
+ *   // Securely process validated payment
+ * })
+ * ```
+ *
+ * @example Dispatching reliable outgoing webhooks
+ * ```typescript
+ * import { WebhookDispatcher } from '@gravito/echo'
+ *
+ * const dispatcher = new WebhookDispatcher({ secret: 'app-secret' })
+ * await dispatcher.dispatch({
+ *   url: 'https://consumer.com/hook',
+ *   event: 'order.created',
+ *   data: { id: 123 }
+ * })
+ * ```
+ *
+ * @module @gravito/echo
+ */
+export type { DeadLetterEvent, DeadLetterQueue } from './dlq/DeadLetterQueue';
+export { MemoryDeadLetterQueue } from './dlq/MemoryDeadLetterQueue';
+export { createRequestBufferMiddleware, RequestBufferMiddleware } from './middleware';
+export { OrbitEcho } from './OrbitEcho';
+export type { EchoLogEvent, EchoLogger } from './observability/logging';
+export { ConsoleEchoLogger } from './observability/logging';
+export type { MetricsProvider, WebhookMetricLabels } from './observability/metrics';
+export { EchoMetrics, NoopMetricsProvider, PrometheusMetricsProvider, } from './observability/metrics';
+export type { Span, SpanOptions, Tracer } from './observability/tracing';
+export { NoopSpan, NoopTracer, SpanStatusCode } from './observability/tracing';
+export { BaseProvider, type ProviderOptions } from './providers/base/BaseProvider';
+export { GenericProvider } from './providers/GenericProvider';
+export { GitHubProvider } from './providers/GitHubProvider';
+export { LinearProvider } from './providers/LinearProvider';
+export { PaddleProvider } from './providers/PaddleProvider';
+export { ShopifyProvider } from './providers/ShopifyProvider';
+export { SlackProvider } from './providers/SlackProvider';
+export { StripeProvider } from './providers/StripeProvider';
+export { TwilioProvider } from './providers/TwilioProvider';
+export { computeHmacSha1, computeHmacSha256, parseStripeSignature, timingSafeEqual, validateTimestamp, } from './receive/SignatureValidator';
+export { WebhookReceiver } from './receive/WebhookReceiver';
+export { WebhookReplayService } from './replay/WebhookReplayService';
+export { CircuitBreaker } from './resilience';
+export { KeyRotationManager } from './rotation';
+export type { BufferedRequest, CircuitBreakerConfig, CircuitBreakerMetrics, CircuitBreakerState, EchoConfig, EchoObservabilityConfig, KeyRotationConfig, ProviderKeyEntry, ReplayOptions, ReplayResult, RequestBufferConfig, RetryConfig, WebhookDeliveryResult, WebhookDispatcherConfig, WebhookEvent, WebhookHandler, WebhookPayload, WebhookProvider, WebhookProviderConfig, WebhookProviderConfigWithRotation, WebhookVerificationResult, } from './types';

package/dist/echo/src/middleware/RequestBufferMiddleware.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Request Buffer Middleware
+ *
+ * 在驗證前緩存原始 Request Body，防止框架自動解析 JSON 導致簽章驗證失敗。
+ * 這個中介軟體會在請求處理鏈的早期階段攔截並緩存原始內容。
+ *
+ * @module @gravito/echo/middleware
+ * @since v1.1
+ */
+import type { GravitoContext } from '@gravito/core';
+import type { BufferedRequest, RequestBufferConfig } from '../types';
+/**
+ * Request Buffer 中介軟體類別
+ *
+ * 提供原始 Body 緩存功能，確保簽章驗證使用正確的未解析內容。
+ *
+ * @example
+ * ```typescript
+ * const middleware = new RequestBufferMiddleware({
+ *   maxBodySize: 5 * 1024 * 1024, // 5MB
+ * })
+ *
+ * core.adapter.use('*', middleware.handler())
+ * ```
+ */
+export declare class RequestBufferMiddleware {
+    private config;
+    constructor(config?: RequestBufferConfig);
+    /**
+     * 建立中介軟體處理函式
+     *
+     * @returns 中介軟體處理函式
+     */
+    handler(): (c: GravitoContext, next: () => Promise<Response | undefined>) => Promise<Response | undefined>;
+    /**
+     * 從請求中讀取原始 body
+     *
+     * @param c - Gravito Context
+     * @returns 原始 body（string 或 Buffer）
+     */
+    private readRawBody;
+}
+/**
+ * 便捷工廠函式，用於建立 Request Buffer 中介軟體
+ *
+ * @param config - 中介軟體配置
+ * @returns 中介軟體處理函式
+ *
+ * @example
+ * ```typescript
+ * core.adapter.use('*', createRequestBufferMiddleware({
+ *   maxBodySize: 5 * 1024 * 1024
+ * }))
+ * ```
+ */
+export declare function createRequestBufferMiddleware(config?: RequestBufferConfig): (c: GravitoContext, next: () => Promise<Response | undefined>) => Promise<Response | undefined>;
+declare module '@gravito/core' {
+    interface GravitoVariables {
+        /** Buffered request for signature verification */
+        bufferedRequest?: BufferedRequest;
+    }
+}

package/dist/echo/src/middleware/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Echo Middleware
+ *
+ * @module @gravito/echo/middleware
+ * @since v1.1
+ */
+export type { BufferedRequest, RequestBufferConfig } from '../types';
+export { createRequestBufferMiddleware, RequestBufferMiddleware } from './RequestBufferMiddleware';

package/dist/echo/src/observability/index.d.ts

@@ -0,0 +1,3 @@
+export * from './logging';
+export * from './metrics';
+export * from './tracing';

package/dist/echo/src/observability/logging/ConsoleEchoLogger.d.ts

@@ -0,0 +1,37 @@
+import type { EchoLogger } from './EchoLogger';
+/**
+ * A basic implementation of {@link EchoLogger} that outputs logs to the system console.
+ * Logs are formatted as JSON strings to facilitate integration with log aggregators.
+ *
+ * @example
+ * ```typescript
+ * const logger = new ConsoleEchoLogger();
+ * logger.info('Service started');
+ * ```
+ */
+export declare class ConsoleEchoLogger implements EchoLogger {
+    /**
+     * Enriches the log context with default module information and timestamps.
+     *
+     * @param base - The base context object.
+     * @param extra - Additional metadata to include.
+     * @returns A merged context object.
+     */
+    private formatContext;
+    /**
+     * Outputs a debug-level log entry.
+     */
+    debug(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Outputs an info-level log entry.
+     */
+    info(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Outputs a warn-level log entry.
+     */
+    warn(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Outputs an error-level log entry.
+     */
+    error(message: string, context?: Record<string, unknown>): void;
+}

package/dist/echo/src/observability/logging/EchoLogger.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Represents a structured log event within the Echo module.
+ * Used to ensure consistency across different logging implementations.
+ */
+export interface EchoLogEvent {
+    /** Severity level of the log entry. */
+    level: 'debug' | 'info' | 'warn' | 'error';
+    /** Human-readable message describing the event. */
+    message: string;
+    /** Contextual metadata for better traceability. */
+    context: {
+        /** Always 'echo' to identify the source module. */
+        module: 'echo';
+        /** The specific sub-component triggering the log. */
+        component: 'receiver' | 'dispatcher' | 'dlq' | 'replay';
+        [key: string]: unknown;
+    };
+}
+/**
+ * Defines the standard logging interface for the Echo module.
+ * Implementations should handle structured data for observability.
+ *
+ * @example
+ * ```typescript
+ * const logger: EchoLogger = new ConsoleEchoLogger();
+ * logger.info('Webhook received', { provider: 'stripe' });
+ * ```
+ */
+export interface EchoLogger {
+    /** Logs fine-grained informational events that are most useful to debug an application. */
+    debug(message: string, context?: Record<string, unknown>): void;
+    /** Logs informational messages that highlight the progress of the application at coarse-grained level. */
+    info(message: string, context?: Record<string, unknown>): void;
+    /** Logs potentially harmful situations. */
+    warn(message: string, context?: Record<string, unknown>): void;
+    /** Logs error events that might still allow the application to continue running. */
+    error(message: string, context?: Record<string, unknown>): void;
+}

package/dist/echo/src/observability/logging/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ConsoleEchoLogger';
+export * from './EchoLogger';

package/dist/echo/src/observability/metrics/MetricsProvider.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Defines the interface for collecting application metrics.
+ * Implementations can bridge to Prometheus, StatsD, or other monitoring systems.
+ *
+ * @example
+ * ```typescript
+ * const metrics: MetricsProvider = getMetrics();
+ * metrics.increment(EchoMetrics.INCOMING_TOTAL, { provider: 'stripe' });
+ * ```
+ */
+export interface MetricsProvider {
+    /**
+     * Increments a counter by 1.
+     * Counters are used for values that only increase (e.g., total requests).
+     */
+    increment(name: string, labels?: Record<string, string>): void;
+    /**
+     * Records a value in a histogram.
+     * Histograms are used to track the distribution of values (e.g., request latency).
+     */
+    histogram(name: string, value: number, labels?: Record<string, string>): void;
+    /**
+     * Sets a gauge to a specific value.
+     * Gauges are used for values that can go up and down (e.g., current queue size).
+     */
+    gauge(name: string, value: number, labels?: Record<string, string>): void;
+}
+/**
+ * Common labels used for webhook-related metrics.
+ */
+export interface WebhookMetricLabels {
+    /** The webhook provider name (e.g., 'stripe', 'github'). */
+    provider?: string;
+    /** The type of event received or sent. */
+    event_type?: string;
+    /** The outcome of the operation. */
+    status?: 'success' | 'failure';
+    /** The HTTP status code returned by the remote server. */
+    status_code?: string;
+    /** A category for the error if the operation failed. */
+    error_type?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * Standard metric names used across the Echo module.
+ * Use these constants to ensure consistency in dashboards and alerts.
+ */
+export declare const EchoMetrics: {
+    /** Total number of incoming webhooks received. */
+    readonly INCOMING_TOTAL: "echo_incoming_webhooks_total";
+    /** Time taken to process an incoming webhook. */
+    readonly INCOMING_DURATION: "echo_incoming_duration_seconds";
+    /** Total number of incoming webhooks that failed signature verification. */
+    readonly INCOMING_VERIFICATION_FAILURES: "echo_incoming_verification_failures_total";
+    /** Total number of outgoing webhooks dispatched. */
+    readonly OUTGOING_TOTAL: "echo_outgoing_webhooks_total";
+    /** Time taken to deliver an outgoing webhook. */
+    readonly OUTGOING_DURATION: "echo_outgoing_duration_seconds";
+    /** Total number of retry attempts for outgoing webhooks. */
+    readonly OUTGOING_RETRIES: "echo_outgoing_retries_total";
+    /** Total number of outgoing webhooks that failed after all retries. */
+    readonly OUTGOING_FAILURES: "echo_outgoing_failures_total";
+    /** Current number of items in the Dead Letter Queue. */
+    readonly DLQ_SIZE: "echo_dlq_size";
+    /** Total number of items added to the DLQ. */
+    readonly DLQ_ENQUEUED: "echo_dlq_enqueued_total";
+    /** Total number of items successfully processed from the DLQ. */
+    readonly DLQ_PROCESSED: "echo_dlq_processed_total";
+};

package/dist/echo/src/observability/metrics/NoopMetricsProvider.d.ts

@@ -0,0 +1,17 @@
+import type { MetricsProvider } from './MetricsProvider';
+/**
+ * A non-operational implementation of {@link MetricsProvider}.
+ * Used as the default provider to ensure the application remains functional
+ * even if no monitoring system is configured.
+ *
+ * @example
+ * ```typescript
+ * const metrics = new NoopMetricsProvider();
+ * metrics.increment('any_metric'); // Does nothing
+ * ```
+ */
+export declare class NoopMetricsProvider implements MetricsProvider {
+    increment(): void;
+    histogram(): void;
+    gauge(): void;
+}

package/dist/echo/src/observability/metrics/PrometheusMetricsProvider.d.ts

@@ -0,0 +1,39 @@
+import type { MetricsProvider } from './MetricsProvider';
+/**
+ * A Prometheus-compatible metrics provider.
+ * Collects and formats metrics in the Prometheus text-based format.
+ *
+ * @example
+ * ```typescript
+ * const provider = new PrometheusMetricsProvider();
+ * provider.increment('http_requests_total', { method: 'POST' });
+ * console.log(provider.export());
+ * ```
+ */
+export declare class PrometheusMetricsProvider implements MetricsProvider {
+    private counters;
+    private histograms;
+    private gauges;
+    /**
+     * Increments a counter for the given name and labels.
+     */
+    increment(name: string, labels?: Record<string, string>): void;
+    /**
+     * Records a value in a histogram for the given name and labels.
+     */
+    histogram(name: string, value: number, labels?: Record<string, string>): void;
+    /**
+     * Sets a gauge to a specific value for the given name and labels.
+     */
+    gauge(name: string, value: number, labels?: Record<string, string>): void;
+    /**
+     * Exports all collected metrics in Prometheus text format.
+     *
+     * @returns A string containing the formatted metrics.
+     */
+    export(): string;
+    /**
+     * Builds a Prometheus-compatible metric key with labels.
+     */
+    private buildKey;
+}

package/dist/echo/src/observability/metrics/index.d.ts

@@ -0,0 +1,3 @@
+export * from './MetricsProvider';
+export * from './NoopMetricsProvider';
+export * from './PrometheusMetricsProvider';

package/dist/echo/src/observability/tracing/NoopTracer.d.ts

@@ -0,0 +1,33 @@
+import type { Span, Tracer } from './Tracer';
+/**
+ * A non-operational implementation of {@link Span}.
+ * Used as a fallback when tracing is disabled to avoid null checks.
+ */
+export declare class NoopSpan implements Span {
+    setAttribute(): this;
+    setAttributes(): this;
+    addEvent(): this;
+    setStatus(): this;
+    end(): void;
+}
+/**
+ * A non-operational implementation of {@link Tracer}.
+ * Ensures the application can run without a tracing backend.
+ *
+ * @example
+ * ```typescript
+ * const tracer = new NoopTracer();
+ * const span = tracer.startSpan('test');
+ * span.end();
+ * ```
+ */
+export declare class NoopTracer implements Tracer {
+    /**
+     * Returns a {@link NoopSpan} that does nothing.
+     */
+    startSpan(): Span;
+    /**
+     * Executes the function with a {@link NoopSpan}.
+     */
+    withSpan<T>(_name: string, fn: (span: Span) => T | Promise<T>): Promise<T>;
+}

package/dist/echo/src/observability/tracing/Tracer.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Represents a single unit of work in a trace.
+ * Compatible with OpenTelemetry Span interface to allow seamless integration.
+ */
+export interface Span {
+    /**
+     * Sets a single attribute on the span.
+     * Attributes provide additional metadata for the operation.
+     */
+    setAttribute(key: string, value: string | number | boolean): this;
+    /**
+     * Sets multiple attributes on the span at once.
+     */
+    setAttributes(attributes: Record<string, string | number | boolean>): this;
+    /**
+     * Records a specific event that occurred during the span's lifetime.
+     */
+    addEvent(name: string, attributes?: Record<string, string | number>): this;
+    /**
+     * Sets the final status of the span.
+     */
+    setStatus(status: {
+        code: SpanStatusCode;
+        message?: string;
+    }): this;
+    /**
+     * Marks the end of the span, making it ready for export.
+     */
+    end(): void;
+}
+/**
+ * Standard status codes for a {@link Span}.
+ */
+export declare enum SpanStatusCode {
+    /** Default status. */
+    UNSET = 0,
+    /** Operation completed successfully. */
+    OK = 1,
+    /** Operation failed. */
+    ERROR = 2
+}
+/**
+ * Defines the tracing interface for the Echo module.
+ * Used to track the lifecycle of webhook requests and deliveries.
+ *
+ * @example
+ * ```typescript
+ * const tracer: Tracer = getTracer();
+ * await tracer.withSpan('process-webhook', async (span) => {
+ *   span.setAttribute('provider', 'stripe');
+ *   // ... logic
+ * });
+ * ```
+ */
+export interface Tracer {
+    /**
+     * Starts a new span without making it active.
+     * The caller is responsible for ending the span.
+     */
+    startSpan(name: string, options?: SpanOptions): Span;
+    /**
+     * Executes a function within the context of a new span.
+     * Automatically ends the span when the function completes.
+     */
+    withSpan<T>(name: string, fn: (span: Span) => T | Promise<T>): Promise<T>;
+}
+/**
+ * Configuration options for starting a new {@link Span}.
+ */
+export interface SpanOptions {
+    /** The relationship between the span and its neighbors. */
+    kind?: 'client' | 'server' | 'producer' | 'consumer' | 'internal';
+    /** Initial attributes to set on the span. */
+    attributes?: Record<string, string | number | boolean>;
+}

package/dist/echo/src/observability/tracing/index.d.ts

@@ -0,0 +1,2 @@
+export * from './NoopTracer';
+export * from './Tracer';

package/dist/echo/src/providers/GenericProvider.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Generic webhook provider.
+ * @module @gravito/echo/providers
+ */
+import type { WebhookVerificationResult } from '../types';
+import { BaseProvider, type ProviderOptions } from './base/BaseProvider';
+/**
+ * Configuration options for the generic provider.
+ */
+export interface GenericProviderOptions extends ProviderOptions {
+    /**
+     * Custom header name for the signature.
+     * @defaultValue 'x-webhook-signature'
+     */
+    signatureHeader?: string;
+    /**
+     * Custom header name for the timestamp.
+     * @defaultValue 'x-webhook-timestamp'
+     */
+    timestampHeader?: string;
+}
+/**
+ * Generic webhook provider using HMAC-SHA256 for signature verification.
+ *
+ * Expected headers:
+ * - X-Webhook-Signature: HMAC-SHA256 hex signature.
+ * - X-Webhook-Timestamp: Unix timestamp (optional, used for replay protection).
+ *
+ * @example
+ * ```typescript
+ * const provider = new GenericProvider({
+ *   signatureHeader: 'X-Custom-Sig',
+ *   tolerance: 600
+ * });
+ * const result = await provider.verify(body, headers, secret);
+ * ```
+ */
+export declare class GenericProvider extends BaseProvider {
+    readonly name = "generic";
+    private signatureHeader;
+    private timestampHeader;
+    constructor(options?: GenericProviderOptions);
+    /**
+     * Verifies the webhook using HMAC-SHA256.
+     *
+     * @param payload - Raw request body.
+     * @param headers - Request headers.
+     * @param secret - Secret key for HMAC computation.
+     * @returns Verification result.
+     * @throws Error if signature computation fails.
+     */
+    verify(payload: string | Buffer, headers: Record<string, string | string[] | undefined>, secret: string): Promise<WebhookVerificationResult>;
+}

package/dist/echo/src/providers/GitHubProvider.d.ts

@@ -0,0 +1,35 @@
+/**
+ * GitHub webhook provider.
+ * @module @gravito/echo/providers
+ */
+import type { WebhookVerificationResult } from '../types';
+import { BaseProvider } from './base/BaseProvider';
+/**
+ * GitHub webhook provider.
+ *
+ * Verifies GitHub webhook signatures using the `X-Hub-Signature-256` header.
+ * @see {@link https://docs.github.com/en/webhooks/using-webhooks/validating-webhook-deliveries | GitHub Webhook Validation}
+ *
+ * @example
+ * ```typescript
+ * const provider = new GitHubProvider();
+ * const result = await provider.verify(body, headers, process.env.GITHUB_WEBHOOK_SECRET);
+ * ```
+ */
+export declare class GitHubProvider extends BaseProvider {
+    readonly name = "github";
+    /**
+     * Verifies the GitHub webhook signature.
+     *
+     * @param payload - Raw request body.
+     * @param headers - Request headers.
+     * @param secret - GitHub webhook secret.
+     * @returns Verification result.
+     * @throws Error if signature computation fails.
+     */
+    verify(payload: string | Buffer, headers: Record<string, string | string[] | undefined>, secret: string): Promise<WebhookVerificationResult>;
+    /**
+     * Extracts the action from the GitHub payload if available.
+     */
+    parseEventType(payload: unknown): string | undefined;
+}

package/dist/echo/src/providers/LinearProvider.d.ts

@@ -0,0 +1,27 @@
+import type { WebhookVerificationResult } from '../types';
+import { BaseProvider } from './base/BaseProvider';
+/**
+ * Linear webhook provider.
+ *
+ * Verifies Linear webhook signatures using the `Linear-Signature` header.
+ * @see {@link https://developers.linear.app/docs/graphql/webhooks#signature-verification | Linear Webhook Verification}
+ *
+ * @example
+ * ```typescript
+ * const provider = new LinearProvider();
+ * const result = await provider.verify(body, headers, process.env.LINEAR_WEBHOOK_SECRET);
+ * ```
+ */
+export declare class LinearProvider extends BaseProvider {
+    readonly name = "linear";
+    /**
+     * Verifies the Linear webhook signature.
+     *
+     * @param payload - Raw request body.
+     * @param headers - Request headers.
+     * @param secret - Linear webhook secret.
+     * @returns Verification result.
+     * @throws Error if signature computation fails.
+     */
+    verify(payload: string | Buffer, headers: Record<string, string | string[] | undefined>, secret: string): Promise<WebhookVerificationResult>;
+}

package/dist/echo/src/providers/PaddleProvider.d.ts

@@ -0,0 +1,31 @@
+import type { WebhookVerificationResult } from '../types';
+import { BaseProvider } from './base/BaseProvider';
+/**
+ * Paddle webhook provider.
+ *
+ * Verifies Paddle webhook signatures using the `Paddle-Signature` header.
+ * @see {@link https://developer.paddle.com/webhooks/signature-verification | Paddle Signature Verification}
+ *
+ * @example
+ * ```typescript
+ * const provider = new PaddleProvider();
+ * const result = await provider.verify(body, headers, process.env.PADDLE_WEBHOOK_SECRET);
+ * ```
+ */
+export declare class PaddleProvider extends BaseProvider {
+    readonly name = "paddle";
+    /**
+     * Verifies the Paddle webhook signature.
+     *
+     * @param payload - Raw request body.
+     * @param headers - Request headers.
+     * @param secret - Paddle webhook secret.
+     * @returns Verification result.
+     * @throws Error if signature computation fails.
+     */
+    verify(payload: string | Buffer, headers: Record<string, string | string[] | undefined>, secret: string): Promise<WebhookVerificationResult>;
+    /**
+     * Parses the Paddle-Signature header into timestamp and signature components.
+     */
+    private parsePaddleSignature;
+}

package/dist/echo/src/providers/ShopifyProvider.d.ts

@@ -0,0 +1,27 @@
+import type { WebhookVerificationResult } from '../types';
+import { BaseProvider } from './base/BaseProvider';
+/**
+ * Shopify webhook provider.
+ *
+ * Verifies Shopify webhook signatures using the `X-Shopify-Hmac-Sha256` header.
+ * @see {@link https://shopify.dev/docs/apps/webhooks/configuration/https#verify-webhook | Shopify Webhook Verification}
+ *
+ * @example
+ * ```typescript
+ * const provider = new ShopifyProvider();
+ * const result = await provider.verify(body, headers, process.env.SHOPIFY_WEBHOOK_SECRET);
+ * ```
+ */
+export declare class ShopifyProvider extends BaseProvider {
+    readonly name = "shopify";
+    /**
+     * Verifies the Shopify webhook signature.
+     *
+     * @param payload - Raw request body.
+     * @param headers - Request headers.
+     * @param secret - Shopify webhook secret.
+     * @returns Verification result.
+     * @throws Error if signature computation fails.
+     */
+    verify(payload: string | Buffer, headers: Record<string, string | string[] | undefined>, secret: string): Promise<WebhookVerificationResult>;
+}