@chainlink/external-adapter-framework 0.0.14 → 0.0.16

package/rate-limiting/request/simple-counting.d.ts

@@ -1,20 +0,0 @@
-import { AdapterRateLimitTier, RateLimiter } from '..';
-import { AdapterEndpoint } from '../../adapter';
-/**
- * This rate limiter is the simplest stateful option.
- * On startup, it'll compare the different thresholds for each tier, calculate them all
- * in the finest window we'll use (seconds), and use the most restrictive one.
- * This is so if the EA were to restart, we don't need to worry about persisting state
- * for things like daily quotas. The downside is that this does not work well for bursty
- * loads or spikes, in cases where e.g. the per second limit is high but daily quotas low.
- */
-export declare class SimpleCountingRateLimiter implements RateLimiter {
-    latestSecondInterval: number;
-    requestsThisSecond: number;
-    latestMinuteInterval: number;
-    requestsThisMinute: number;
-    perSecondLimit: number;
-    perMinuteLimit: number;
-    initialize(endpoints: AdapterEndpoint[], limits?: AdapterRateLimitTier): this;
-    isUnderLimits(): boolean;
-}

package/test.d.ts

@@ -1 +0,0 @@
-export {};

package/transports/batch-warming.d.ts

@@ -1,35 +0,0 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import { Cache } from '../cache';
-import { AdapterConfig, SettingsMap } from '../config';
-import { BackgroundExecuteRateLimiter } from '../rate-limiting';
-import { SubscriptionSet } from '../util';
-import { AdapterRequest, ProviderResult } from '../util/request';
-import { Transport } from './';
-import { AdapterContext, AdapterDependencies } from '../adapter';
-/**
- * Transport implementation that takes incoming batches requests and keeps a warm cache of values.
- * Within the setup function, adapter params are added to an set that also keeps track and expires values.
- * In the background execute, the list of non-expired items in the set is fetched.
- * Then, the list is passed through the `prepareRequest` function, that returns an AxiosRequestConfig.
- * The Data Provider response is, they are passed through the `parseResponse` function to create a [[CacheEntry]] list.
- * Finally, the items in that [[CacheEntry]] list are set in the Cache so the Adapter can fetch values from there.
- *
- * @typeParam AdapterParams - interface for the adapter request body
- * @typeParam ProviderRequestBody - interface for the body of the request to the Data Provider
- * @typeParam ProviderResponseBody - interface for the body of the Data Provider's response
- */
-export declare class BatchWarmingTransport<AdapterParams, ProviderRequestBody, ProviderResponseBody, CustomSettings extends SettingsMap> implements Transport<AdapterParams, ProviderResponseBody, CustomSettings> {
-    private config;
-    cache: Cache;
-    rateLimiter: BackgroundExecuteRateLimiter;
-    subscriptionSet: SubscriptionSet<AdapterParams>;
-    WARMER_ACTIVE: boolean;
-    constructor(config: {
-        prepareRequest: (params: AdapterParams[], context: AdapterContext<CustomSettings>) => AxiosRequestConfig<ProviderRequestBody>;
-        parseResponse: (res: AxiosResponse<ProviderResponseBody>, context: AdapterContext<CustomSettings>) => ProviderResult<AdapterParams>[];
-    });
-    initialize(dependencies: AdapterDependencies): Promise<void>;
-    hasBeenSetUp(req: AdapterRequest<AdapterParams>): Promise<boolean>;
-    setup(req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>): Promise<void>;
-    backgroundExecute(context: AdapterContext<CustomSettings>): Promise<number>;
-}

package/transports/index.d.ts

@@ -1,70 +0,0 @@
-import { FastifyReply } from 'fastify';
-import { AdapterContext, AdapterDependencies, InitializedAdapter } from '../adapter';
-import { CacheEntry } from '../cache';
-import { AdapterConfig, SettingsMap } from '../config';
-import { AdapterRequest, AdapterResponse, ProviderResult } from '../util/request';
-export * from './batch-warming';
-export * from './rest';
-export * from './websocket';
-/**
- * Generic interface for a Transport.
- * A Transport defines the way in which an AdapterEndpoint will process incoming requests to
- * fetch data from a Data Provider. The setup phase will take care of the former, while the
- * backgroundExecute will be in charge of the latter.
- * This separation gives us the ability of splitting these concerns, and optionally parallelizing
- * the reading and writing of data to a centralized Cache.
- *
- * @typeParam Params - the structure of the AdapterRequest's body
- * @typeParam Result - the structure of the AdapterResponse's body
- */
-export interface Transport<Params, Result, CustomSettings extends SettingsMap> {
-    /**
-     * Initializes the transport in the Adapter context.
-     *
-     * @param dependencies - Adapter dependencies (e.g. cache instance)
-     * @returns an empty Promise
-     */
-    initialize: (dependencies: AdapterDependencies) => Promise<void>;
-    /**
-     * Checks if the Transport has already set up the incoming request.
-     * This will likely use the cacheKey generated in the provided request.
-     *
-     * @param req - the incoming AdapterRequest
-     * @returns a Promise that returns true if setup is in place
-     */
-    hasBeenSetUp: (req: AdapterRequest<Params>) => Promise<boolean>;
-    /**
-     * Sets up the incoming request within the Transport.
-     * In other words, it means that the Adapter has recognized this request, and will begin
-     * fetching the necessary data from a Data Provider.
-     *
-     * @param req - the incoming AdapterRequest
-     * @param config - common configuration for the Adapter as a whole
-     * @returns a Promise that _optionally_ returns an AdapterResponse, if the Transport has the capability of
-     *   immediately fetching data and returning it without the background process.
-     */
-    setup: (req: AdapterRequest<Params>, config: AdapterConfig<CustomSettings>) => Promise<AdapterResponse<Result> | void>;
-    /**
-     * If the Transport relies on an async mechanism, implementing this function will make it
-     * so the background task executor calls it on Adapter startup.
-     *
-     * @param context - background context for the execution (e.g. endpoint name)
-     */
-    backgroundExecute?: (context: AdapterContext<CustomSettings>) => Promise<number>;
-}
-/**
- * Helper method to build cache entries to set after getting a bunch of responses from a DP.
- *
- * @param results - a list of results coming from a DataProvider
- * @param context - context for the Adapter
- * @returns a list of CacheEntries of AdapterResponses
- */
-export declare const buildCacheEntriesFromResults: <Params, CustomSettings extends SettingsMap>(results: ProviderResult<Params>[], context: AdapterContext<CustomSettings>) => CacheEntry<AdapterResponse<null>>[];
-/**
- * Takes an Adapter, its configuration, and its dependencies, and it creates an express middleware
- * that will pass along the AdapterRequest to the appropriate Transport (acc. to the endpoint in the req.)
- *
- * @param adapter - main adapter object, already initialized
- * @returns the transport handler middleware function
- */
-export declare const buildTransportHandler: (adapter: InitializedAdapter) => (req: AdapterRequest, reply: FastifyReply) => Promise<never>;

package/transports/metrics.d.ts

@@ -1,21 +0,0 @@
-import * as client from 'prom-client';
-import { AdapterContext } from '../adapter';
-export declare const dataProviderMetricsLabel: (providerStatusCode?: number, method?: string) => {
-    provider_status_code: number | undefined;
-    method: string;
-};
-export declare const dataProviderRequests: client.Counter<"method" | "provider_status_code">;
-export declare const dataProviderRequestDurationSeconds: client.Histogram<string>;
-export declare const connectionErrorLabels: (message: string) => {
-    message: string;
-};
-export declare const messageSubsLabels: (feed_id: string, cache_key: string) => {
-    feed_id: string;
-    subscription_key: string;
-};
-export declare const recordWsMessageMetrics: <AdapterParams>(context: AdapterContext, subscribes: AdapterParams[], unsubscrices: AdapterParams[]) => void;
-export declare const wsConnectionActive: client.Gauge<"url">;
-export declare const wsConnectionErrors: client.Counter<"message" | "url">;
-export declare const wsSubscriptionActive: client.Gauge<"feed_id" | "connection_url" | "subscription_key">;
-export declare const wsSubscriptionTotal: client.Counter<"feed_id" | "connection_url" | "subscription_key">;
-export declare const wsMessageTotal: client.Counter<"feed_id" | "subscription_key">;

package/transports/rest.d.ts

@@ -1,44 +0,0 @@
-import { AdapterRequest, AdapterResponse } from '../util/request';
-import { Transport } from './';
-import { Cache } from '../cache';
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import { AdapterConfig, SettingsMap } from '../config';
-import { RequestRateLimiter } from '../rate-limiting';
-import { AdapterDependencies } from '../adapter';
-/**
- * Transport implementation that takes incoming requests, transforms them into a DataProvider request,
- * and executes that request returning the response immediately from the `setup` function.
- * Optionally, setting the `coalescing` option to `true` will make it so once a request is in flight,
- * new adapter requests for the same feed will not trigger a new one, but return an empty promise from
- * the setup instead so the normal cache polling mechanism is used.
- *
- * @typeParam AdapterParams - interface for the adapter request body
- * @typeParam ProviderRequestBody - interface for the body of the request to the Data Provider
- * @typeParam ProviderResponseBody - interface for the body of the Data Provider's response
- */
-export declare class RestTransport<AdapterParams, ProviderRequestBody, ProviderResponseBody, CustomSettings extends SettingsMap> implements Transport<AdapterParams, ProviderResponseBody, CustomSettings> {
-    protected config: {
-        prepareRequest: (req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>) => AxiosRequestConfig<ProviderRequestBody> | Promise<AxiosRequestConfig<ProviderRequestBody>>;
-        parseResponse: (req: AdapterRequest<AdapterParams>, res: AxiosResponse<ProviderResponseBody>, config: AdapterConfig<CustomSettings>) => AdapterResponse<ProviderResponseBody> | Promise<AdapterResponse<ProviderResponseBody>>;
-        options: {
-            coalescing: boolean;
-        };
-    };
-    inFlightPrefix: string;
-    cache: Cache;
-    rateLimiter: RequestRateLimiter;
-    constructor(config: {
-        prepareRequest: (req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>) => AxiosRequestConfig<ProviderRequestBody> | Promise<AxiosRequestConfig<ProviderRequestBody>>;
-        parseResponse: (req: AdapterRequest<AdapterParams>, res: AxiosResponse<ProviderResponseBody>, config: AdapterConfig<CustomSettings>) => AdapterResponse<ProviderResponseBody> | Promise<AdapterResponse<ProviderResponseBody>>;
-        options: {
-            coalescing: boolean;
-        };
-    });
-    initialize(dependencies: AdapterDependencies): Promise<void>;
-    hasBeenSetUp(req: AdapterRequest<AdapterParams>): Promise<boolean>;
-    protected waitUntilUnderRateLimit(options: {
-        maxRetries: number;
-        msBetweenRetries: number;
-    }, retry?: number): Promise<void>;
-    setup(req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>): Promise<AdapterResponse<ProviderResponseBody> | undefined>;
-}

package/transports/util.d.ts

@@ -1,8 +0,0 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
-/**
- * Performs axios request along with metrics recording and error handling
- *
- * @param request - axios request config
- * @returns axios response for the request
- */
-export declare function axiosRequest<ProviderRequestBody, ProviderResponseBody>(request: AxiosRequestConfig<ProviderRequestBody>): Promise<AxiosResponse<ProviderResponseBody>>;

package/transports/websocket.d.ts

@@ -1,81 +0,0 @@
-import WebSocket from 'ws';
-import { AdapterContext, AdapterDependencies } from '../adapter';
-import { Cache } from '../cache';
-import { SettingsMap } from '../config';
-import { BackgroundExecuteRateLimiter } from '../rate-limiting';
-import { SubscriptionSet } from '../util';
-import { AdapterRequest, ProviderResult } from '../util/request';
-import { Transport } from './';
-export declare const DEFAULT_WS_TTL = 10000;
-declare type WebSocketClass = new (url: string, protocols?: string | string[] | undefined) => WebSocket;
-export declare class WebSocketClassProvider {
-    static ctor: WebSocketClass;
-    static set(ctor: WebSocketClass): void;
-    static get(): WebSocketClass;
-}
-/**
- * Config object that is provided to the WebSocketTransport constructor.
- */
-export interface WebSocketTransportConfig<AdapterParams, ProviderDataMessage, CustomSettings extends SettingsMap> {
-    /** Endpoint to which to open the WS connection*/
-    url: string;
-    /** Map of handlers for different WS lifecycle events */
-    handlers: {
-        /**
-         * Handles when the WS is successfully opened
-         *
-         * @param wsConnection - the WebSocket with an established connection
-         * @returns an empty Promise, or void
-         */
-        open: (wsConnection: WebSocket, context: AdapterContext<CustomSettings>) => Promise<void> | void;
-        /**
-         * Handles when the WS receives a message
-         *
-         * @param message - the message received by the WS
-         * @param context - the background context for the Adapter
-         * @returns a list of cache entries of adapter responses to set in the cache
-         */
-        message: (message: ProviderDataMessage, context: AdapterContext<CustomSettings>) => ProviderResult<AdapterParams>[];
-    };
-    /** Map of "builders", functions that will be used to prepare specific WS messages */
-    builders: {
-        /**
-         * Builds a WS message that will be sent to subscribe to a specific feed
-         *
-         * @param params - the body of the adapter request
-         * @returns the WS message (can be any type as long as the [[WebSocket]] doesn't complain)
-         */
-        subscribeMessage: (params: AdapterParams) => unknown;
-        /**
-         * Builds a WS message that will be sent to unsubscribe to a specific feed
-         *
-         * @param params - the body of the adapter request
-         * @returns the WS message (can be any type as long as the [[WebSocket]] doesn't complain)
-         */
-        unsubscribeMessage: (params: AdapterParams) => unknown;
-    };
-}
-/**
- * Transport implementation that takes incoming requests, adds them to an [[subscriptionSet]] and,
- * through a WebSocket connection, subscribes to the relevant feeds to populate the cache.
- *
- * @typeParam AdapterParams - interface for the adapter request body
- * @typeParam ProviderDataMessage - interface for a WS message containing processable data (i.e. not part of open/close/login/etc)
- */
-export declare class WebSocketTransport<AdapterParams, ProviderDataMessage, CustomSettings extends SettingsMap> implements Transport<AdapterParams, null, CustomSettings> {
-    private config;
-    cache: Cache;
-    rateLimiter: BackgroundExecuteRateLimiter;
-    subscriptionSet: SubscriptionSet<AdapterParams>;
-    localSubscriptions: AdapterParams[];
-    wsConnection: WebSocket;
-    constructor(config: WebSocketTransportConfig<AdapterParams, ProviderDataMessage, CustomSettings>);
-    initialize(dependencies: AdapterDependencies): Promise<void>;
-    hasBeenSetUp(req: AdapterRequest<AdapterParams>): Promise<boolean>;
-    setup(req: AdapterRequest<AdapterParams>): Promise<void>;
-    serializeMessage(payload: unknown): string;
-    deserializeMessage(data: WebSocket.Data): ProviderDataMessage;
-    establishWsConnection(context: AdapterContext<CustomSettings>): Promise<unknown>;
-    backgroundExecute(context: AdapterContext<CustomSettings>): Promise<number>;
-}
-export {};

package/util/expiring-sorted-set.d.ts

@@ -1,21 +0,0 @@
-/**
- * An object describing an entry in the expiring sorted set.
- * @typeParam T - the type of the entry's value
- */
-interface ExpiringSortedSetEntry<T> {
-    value: T;
-    expirationTimestamp: number;
-}
-/**
- * This class implements a set of unique items, each of which has an expiration timestamp.
- * On reads, items that have expired will be deleted from the set and not returned.
- *
- * @typeParam T - the type of the set entries' values
- */
-export declare class ExpiringSortedSet<T> {
-    map: Map<string, ExpiringSortedSetEntry<T>>;
-    add(key: string, value: T, ttl: number): void;
-    get(key: string): T | undefined;
-    getAll(): T[];
-}
-export {};

package/util/expiring-sorted-set.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpiringSortedSet = void 0;
-/**
- * This class implements a set of unique items, each of which has an expiration timestamp.
- * On reads, items that have expired will be deleted from the set and not returned.
- *
- * @typeParam T - the type of the set entries' values
- */
-class ExpiringSortedSet {
-    constructor() {
-        this.map = new Map();
-    }
-    add(key, value, ttl) {
-        this.map.set(key, {
-            value,
-            expirationTimestamp: Date.now() + ttl,
-        });
-    }
-    get(key) {
-        const entry = this.map.get(key);
-        if (!entry) {
-            return;
-        }
-        else if (entry.expirationTimestamp < Date.now()) {
-            return entry.value;
-        }
-        else {
-            this.map.delete(key);
-        }
-    }
-    getAll() {
-        const results = [];
-        const now = Date.now();
-        // Since we're iterating, might as well prune here
-        for (const [key, entry] of this.map.entries()) {
-            if (entry.expirationTimestamp < now) {
-                this.map.delete(key); // In theory, this shouldn't happen frequently for feeds
-            }
-            else {
-                results.push(entry.value);
-            }
-        }
-        return results;
-    }
-}
-exports.ExpiringSortedSet = ExpiringSortedSet;

package/util/index.d.ts

@@ -1,12 +0,0 @@
-export * from './request';
-export * from './logger';
-export * from './subscription-set/subscription-set';
-/**
- * Sleeps for the provided number of milliseconds
- * @param ms - The number of milliseconds to sleep for
- * @returns a Promise that resolves once the specified time passes
- */
-export declare const sleep: (ms: number) => Promise<void>;
-export declare const isObject: (o: unknown) => boolean;
-export declare const isArray: (o: unknown) => boolean;
-export declare type PromiseOrValue<T> = Promise<T> | T;

package/util/logger.d.ts

@@ -1,42 +0,0 @@
-/// <reference types="node" />
-import pino from 'pino';
-import { AdapterRequest } from './request';
-import { FastifyReply, HookHandlerDoneFunction } from 'fastify';
-import { AsyncLocalStorage } from 'node:async_hooks';
-export declare const asyncLocalStorage: AsyncLocalStorage<unknown>;
-export declare type Store = {
-    correlationId: string;
-};
-/**
- * Instead of using a global logger instance, we want to force using a child logger
- * with a specific layer set in it, so that we can filter logs by where they're output from.
- *
- * Details on what each log level represents:
- * "trace": Forensic debugging of issues on a local machine.
- * "debug": Detailed logging level to get more context from users on their environments.
- * "info": High-level informational messages, to describe at a glance the high level state of the system.
- * "warn": A mild error occurred that might require non-urgent action.
- * "error": An unexpected error occurred during the regular operation of a well-maintained EA.
- * "fatal": The EA encountered an unrecoverable problem and had to exit.
- *
- * Full reference this is based on can be found at
- * https://github.com/smartcontractkit/documentation/blob/main/docs/Node%20Operators/configuration-variables.md#log_level
- *
- * @param layer - the layer name to include in the logs (e.g. "SomeMiddleware", "RedisCache", etc.)
- * @returns a layer specific logger
- */
-export declare const makeLogger: (layer: string) => pino.Logger<{
-    level: string;
-    mixin(): {};
-    transport: {
-        target: string;
-        options: {
-            levelFirst: boolean;
-            levelLabel: string;
-            ignore: string;
-            messageFormat: string;
-            translateTime: string;
-        };
-    } | undefined;
-} & pino.ChildLoggerOptions>;
-export declare const loggingContextMiddleware: (req: AdapterRequest, res: FastifyReply, done: HookHandlerDoneFunction) => void;

package/util/request.d.ts

@@ -1,57 +0,0 @@
-import { FastifyReply, FastifyRequest, HookHandlerDoneFunction } from 'fastify';
-import { InitializedAdapter } from '../adapter';
-import { AdapterError } from '../validation/error';
-declare module 'fastify' {
-    interface FastifyRequest {
-        requestContext: AdapterRequestContext;
-    }
-}
-export interface AdapterRequestBody<T = AdapterRequestData> {
-    endpoint?: string;
-    data: T;
-    id?: string;
-}
-export declare type AdapterRequestContext<T = AdapterRequestData> = {
-    id: string;
-    endpointName: string;
-    cacheKey: string;
-    data: T;
-    meta?: AdapterRequestMeta;
-};
-export declare type AdapterRouteGeneric<T = AdapterRequestData> = {
-    Body: AdapterRequestBody<T>;
-};
-export declare type AdapterRequest<T = AdapterRequestData> = FastifyRequest<AdapterRouteGeneric<T>> & {
-    requestContext: AdapterRequestContext<T>;
-};
-/**
- * Meta info that pertains to exposing metrics
- */
-export interface AdapterRequestMeta {
-    metrics?: AdapterMetricsMeta;
-    error?: AdapterError | Error;
-}
-/**
- * Meta info that pertains to exposing metrics
- */
-export interface AdapterMetricsMeta {
-    feedId?: string;
-    cacheHit?: boolean;
-}
-export declare type AdapterRequestData = Record<string, unknown> & {
-    endpoint?: string;
-};
-export interface ProviderResult<Params> {
-    params: Params;
-    value: unknown;
-}
-export declare type AdapterResponse<T = unknown> = {
-    statusCode: number;
-    data: T;
-    result: unknown;
-    maxAge?: number;
-    meta?: AdapterRequestMeta;
-    providerStatusCode?: number;
-};
-export declare type Middleware = ((req: AdapterRequest, reply: FastifyReply, done: HookHandlerDoneFunction) => FastifyReply | void) | ((req: AdapterRequest, reply: FastifyReply) => Promise<FastifyReply | void>);
-export declare type AdapterMiddlewareBuilder = (adapter: InitializedAdapter) => Middleware;

package/util/subscription-set/expiring-sorted-set.d.ts

@@ -1,22 +0,0 @@
-import { SubscriptionSet } from './subscription-set';
-/**
- * An object describing an entry in the expiring sorted set.
- * @typeParam T - the type of the entry's value
- */
-interface ExpiringSortedSetEntry<T> {
-    value: T;
-    expirationTimestamp: number;
-}
-/**
- * This class implements a set of unique items, each of which has an expiration timestamp.
- * On reads, items that have expired will be deleted from the set and not returned.
- *
- * @typeParam T - the type of the set entries' values
- */
-export declare class ExpiringSortedSet<T> implements SubscriptionSet<T> {
-    map: Map<string, ExpiringSortedSetEntry<T>>;
-    add(key: string, value: T, ttl: number): void;
-    get(key: string): T | undefined;
-    getAll(): T[];
-}
-export {};

package/util/subscription-set/subscription-set.d.ts

@@ -1,18 +0,0 @@
-import { PromiseOrValue } from '..';
-import { AdapterConfig } from '../../config';
-/**
- * Set to hold items to subscribe to from a provider (regardless of protocol)
- */
-export interface SubscriptionSet<T> {
-    /** Add a new subscription to the set */
-    add(key: string, value: T, ttl: number): PromiseOrValue<void>;
-    /** Get a specific subscription from the set */
-    get(key: string): PromiseOrValue<T | undefined>;
-    /** Get all subscriptions from the set as a list */
-    getAll(): PromiseOrValue<T[]>;
-}
-export declare class SubscriptionSetFactory {
-    private cacheType;
-    constructor(config: AdapterConfig);
-    buildSet<T>(): SubscriptionSet<T>;
-}

package/util/test-payload-loader.d.ts

@@ -1,25 +0,0 @@
-import { AdapterRequestData } from './request';
-/**
- * The test payload read in from filesystem
- */
-export interface Payload {
-    requests: Array<AdapterRequestData>;
-}
-/**
- * Test payload with discriminated union so we can tell when we should just do
- * a simple liveness check rather than a sample request
- */
-declare type TestPayload = (Payload & {
-    isDefault: false;
-}) | {
-    isDefault: true;
-};
-/**
- * Load in a JSON file containing a test payload for the current adapter,
- * used in healthchecks to make sample requests
- *
- * @param fileName - name of file that contains the test payload data for the smoke endpoint
- * @returns the parsed payload with individual requests
- */
-export declare function loadTestPayload(fileName?: string): TestPayload;
-export {};

package/validation/error.d.ts

@@ -1,50 +0,0 @@
-import { HttpRequestType } from '../metrics/constants';
-declare type ErrorBasic = {
-    name: string;
-    message: string;
-};
-declare type ErrorFull = ErrorBasic & {
-    stack: string;
-    cause: string;
-};
-export declare type AdapterErrorResponse = {
-    jobRunID: string;
-    status: string;
-    statusCode: number;
-    providerStatusCode?: number;
-    error: ErrorBasic | ErrorFull;
-};
-export declare class AdapterError extends Error {
-    jobRunID: string;
-    status: string;
-    statusCode: number;
-    cause: any;
-    url?: string;
-    errorResponse: any;
-    feedID?: string;
-    providerStatusCode?: number;
-    metricsLabel?: HttpRequestType;
-    name: string;
-    message: string;
-    constructor({ jobRunID, status, statusCode, name, message, cause, url, errorResponse, feedID, providerStatusCode, metricsLabel, }: Partial<AdapterError>);
-    toJSONResponse(): AdapterErrorResponse;
-}
-export declare class AdapterInputError extends AdapterError {
-    constructor(input: Partial<AdapterError>);
-}
-export declare class AdapterRateLimitError extends AdapterError {
-    constructor(input: Partial<AdapterError>);
-}
-export declare class AdapterTimeoutError extends AdapterError {
-    constructor(input: Partial<AdapterError>);
-}
-export declare class AdapterDataProviderError extends AdapterError {
-    constructor(input: Partial<AdapterError>);
-}
-export declare class AdapterConnectionError extends AdapterError {
-    constructor(input: Partial<AdapterError>);
-}
-export declare class AdapterCustomError extends AdapterError {
-    constructor(input: Partial<AdapterError>);
-}
-export {};

package/validation/index.d.ts

@@ -1,5 +0,0 @@
-import { FastifyReply, FastifyRequest } from 'fastify';
-import { AdapterMiddlewareBuilder } from '../util/request';
-export { InputParameters } from './input-params';
-export declare const validatorMiddleware: AdapterMiddlewareBuilder;
-export declare const errorCatchingMiddleware: (err: Error, req: FastifyRequest, res: FastifyReply) => void;

package/validation/input-params.d.ts

@@ -1,15 +0,0 @@
-export declare type Override = Map<string, Map<string, string>>;
-export declare type InputParameter = {
-    aliases?: string[];
-    description?: string;
-    type?: 'bigint' | 'boolean' | 'array' | 'number' | 'object' | 'string';
-    required?: boolean;
-    options?: unknown[];
-    default?: unknown;
-    dependsOn?: string[];
-    exclusive?: string[];
-};
-export declare type InputParameters = {
-    [name: string]: InputParameter | boolean | string[];
-};
-export declare const baseInputParameters: InputParameters;

package/validation/override-functions.d.ts

@@ -1,3 +0,0 @@
-import { InitializedAdapter } from '../adapter';
-import { AdapterRequest } from '../util/request';
-export declare const performSymbolOverrides: (adapter: InitializedAdapter, req: AdapterRequest) => void;