@chainlink/external-adapter-framework 0.0.10 → 0.0.12

package/dist/src/cache/factory.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheFactory = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+const util_1 = require("../util");
+const local_1 = require("./local");
+const cacheMetrics = __importStar(require("./metrics"));
+const redis_1 = require("./redis");
+const logger = (0, util_1.makeLogger)('CacheFactory');
+class CacheFactory {
+    static buildCache(config) {
+        logger.info(`Using "${config.CACHE_TYPE}" cache.`);
+        if (config.CACHE_TYPE === 'local') {
+            return new local_1.LocalCache();
+        }
+        else if (config.CACHE_TYPE === 'redis') {
+            const redis = new ioredis_1.default({
+                enableAutoPipelining: true,
+                host: config.CACHE_REDIS_HOST,
+                port: config.CACHE_REDIS_PORT,
+            });
+            redis.on('connect', () => {
+                cacheMetrics.redisConnectionsOpen.inc();
+            });
+            return new redis_1.RedisCache(redis);
+        }
+    }
+}
+exports.CacheFactory = CacheFactory;

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

@@ -0,0 +1,94 @@
+import { AdapterEndpoint } from '../adapter';
+import { AdapterConfig, SettingsMap } from '../config';
+import { AdapterMiddlewareBuilder, AdapterResponse, sleep } from '../util';
+export * from './local';
+export * from './redis';
+export * from './factory';
+/**
+ * An object describing an entry in the cache.
+ * @typeParam T - the type of the entry's value
+ */
+export interface CacheEntry<T> {
+    key: string;
+    value: T;
+}
+/**
+ * Generic interface for a local or remote Cache.
+ * @typeParam T - the type of the cache entries' values
+ */
+export interface Cache<T = unknown> {
+    /**
+     * Gets an item from the Cache.
+     *
+     * @param key - the key of the desired entry for which to fetch its value
+     * @returns a Promise of the entry's value, or undefined if not found / expired.
+     */
+    get: (key: string) => Promise<T | undefined>;
+    /**
+     * Sets an item in the Cache.
+     *
+     * @param key - the key of the new entry
+     * @param value - the value of the new entry
+     * @param ttl - the time in milliseconds until the entry expires
+     * @returns an empty Promise that resolves when the entry has been set
+     */
+    set: (key: string, value: T, ttl: number) => Promise<void>;
+    /**
+     * Sets a list of items in the Cache.
+     *
+     * @param entries - a list of cache entries
+     * @param ttl - the time in milliseconds until the entries expire
+     * @returns an empty Promise that resolves when all entries have been set
+     */
+    setMany: (entries: CacheEntry<T>[], ttl: number) => Promise<void>;
+    /**
+     * Deletes the specified item from the Cache
+     *
+     * @param key - the key of the entry to be deleted
+     * @returns an empty Promise that resolves when the entry has been deleted
+     */
+    delete: (key: string) => Promise<void>;
+}
+export declare const calculateCacheKey: <Params, Result, CustomSettings extends SettingsMap>({ adapterEndpoint, adapterConfig, }: {
+    adapterEndpoint: AdapterEndpoint<Params, Result, CustomSettings>;
+    adapterConfig: AdapterConfig<CustomSettings>;
+}, data: unknown) => string;
+export declare const calculateFeedId: <Params, Result, CustomSettings extends SettingsMap>({ adapterEndpoint, adapterConfig, }: {
+    adapterEndpoint: AdapterEndpoint<Params, Result, CustomSettings>;
+    adapterConfig: AdapterConfig<CustomSettings>;
+}, data: unknown) => string;
+/**
+ * Calculates a unique key from the provided data.
+ *
+ * @param data - the request data/body, i.e. the adapter input params
+ * @param paramNames - the keys from adapter endpoint input parameters
+ * @returns the calculated unique key
+ *
+ * @example
+ * ```
+ * calculateKey({ base: 'ETH', quote: 'BTC' }, ['base','quote'])
+ * // equals `|base:eth|quote:btc`
+ * ```
+ */
+export declare const calculateKey: <CustomSettings extends SettingsMap>(data: unknown, paramNames: string[], adapterConfig: AdapterConfig<CustomSettings>) => string;
+/**
+ * Polls the provided Cache for an AdapterResponse set in the provided key. If the maximum
+ * amount of retries is exceeded, it returns undefined instead.
+ *
+ * @param cache - a Cache instance
+ * @param key - the key generated from an AdapterRequest that corresponds to the desired AdapterResponse
+ * @param retry - current retry, only for internal use
+ * @returns the AdapterResponse if found, else undefined
+ */
+export declare const pollResponseFromCache: (cache: Cache<AdapterResponse>, key: string, options: {
+    maxRetries: number;
+    sleep: number;
+}, retry?: number) => Promise<AdapterResponse | undefined>;
+/**
+ * Given a Cache instance in the adapter dependencies, builds a middleware function that will perform
+ * a get from said Cache and return that if found; otherwise it'll continue the middleware chain.
+ *
+ * @param adapter - an initialized adapter
+ * @returns the cache middleware function
+ */
+export declare const buildCacheMiddleware: AdapterMiddlewareBuilder;

package/dist/src/cache/index.js

@@ -0,0 +1,173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCacheMiddleware = exports.pollResponseFromCache = exports.calculateKey = exports.calculateFeedId = exports.calculateCacheKey = void 0;
+const util_1 = require("../util");
+const cacheMetrics = __importStar(require("./metrics"));
+__exportStar(require("./local"), exports);
+__exportStar(require("./redis"), exports);
+__exportStar(require("./factory"), exports);
+const logger = (0, util_1.makeLogger)('Cache');
+// Uses calculateKey to generate a unique key from the endpoint name, data, and input parameters
+const calculateCacheKey = ({ adapterEndpoint, adapterConfig, }, data) => {
+    const paramNames = Object.keys(adapterEndpoint.inputParameters);
+    if (paramNames.length === 0) {
+        logger.trace(`Using default cache key ${adapterConfig.DEFAULT_CACHE_KEY}`);
+        return adapterConfig.DEFAULT_CACHE_KEY;
+    }
+    return `${adapterEndpoint.name}-${(0, exports.calculateKey)(data, paramNames, adapterConfig)}`;
+};
+exports.calculateCacheKey = calculateCacheKey;
+const calculateFeedId = ({ adapterEndpoint, adapterConfig, }, data) => {
+    const paramNames = Object.keys(adapterEndpoint.inputParameters);
+    if (paramNames.length === 0) {
+        logger.trace(`Cannot generate Feed ID without input parameters`);
+        return 'N/A';
+    }
+    return (0, exports.calculateKey)(data, paramNames, adapterConfig);
+};
+exports.calculateFeedId = calculateFeedId;
+/**
+ * Calculates a unique key from the provided data.
+ *
+ * @param data - the request data/body, i.e. the adapter input params
+ * @param paramNames - the keys from adapter endpoint input parameters
+ * @returns the calculated unique key
+ *
+ * @example
+ * ```
+ * calculateKey({ base: 'ETH', quote: 'BTC' }, ['base','quote'])
+ * // equals `|base:eth|quote:btc`
+ * ```
+ */
+const calculateKey = (data, paramNames, adapterConfig) => {
+    if (data && typeof data !== 'object') {
+        throw new Error('Data to calculate cache key should be an object');
+    }
+    const params = data;
+    let cacheKey = '';
+    for (const paramName of paramNames) {
+        // Ignore overrides param when generating cache keys
+        if (paramName === 'overrides') {
+            continue;
+        }
+        const param = params[paramName];
+        if (param === undefined) {
+            continue;
+        }
+        cacheKey += `|${paramName}:`;
+        switch (typeof param) {
+            case 'string':
+                cacheKey += param.toLowerCase();
+                break;
+            case 'number':
+            case 'boolean':
+                cacheKey += param.toString();
+                break;
+            case 'object':
+                // Force cache keys to only use performant properties of the input params.
+                // If the object were to be used, we'd have to sort its properties.
+                logger.debug(`Property "${paramName}" in request parameters is of type object, and won't be used in the cacheKey`);
+        }
+    }
+    if (cacheKey.length > adapterConfig.MAX_COMMON_KEY_SIZE) {
+        logger.warn(`Generated cache key for adapter request is bigger than the MAX_COMMON_KEY_SIZE and will be truncated`);
+        cacheKey = cacheKey.slice(0, adapterConfig.MAX_COMMON_KEY_SIZE);
+    }
+    logger.trace(`Generated cache key for request: "${cacheKey}"`);
+    return cacheKey;
+};
+exports.calculateKey = calculateKey;
+// Calculate the amount of time the non-expired entry has been in the cache
+const calculateStaleness = (expirationTimestamp, ttl) => {
+    if (expirationTimestamp) {
+        const createTimestamp = expirationTimestamp - ttl;
+        return (Date.now() - createTimestamp) / 1000;
+    }
+    else {
+        // If expirationTimestamp is not available, staleness cannot be calculated
+        // Defaults to ttl for metrics purposes
+        return ttl;
+    }
+};
+/**
+ * Polls the provided Cache for an AdapterResponse set in the provided key. If the maximum
+ * amount of retries is exceeded, it returns undefined instead.
+ *
+ * @param cache - a Cache instance
+ * @param key - the key generated from an AdapterRequest that corresponds to the desired AdapterResponse
+ * @param retry - current retry, only for internal use
+ * @returns the AdapterResponse if found, else undefined
+ */
+const pollResponseFromCache = async (cache, key, options, retry = 0) => {
+    if (retry > options.maxRetries) {
+        // Ideally this shouldn't happen often (p99 of reqs should be found in the cache)
+        logger.info('Exceeded max cache polling retries');
+        return undefined;
+    }
+    logger.trace('Getting response from cache...');
+    const response = await cache.get(key);
+    if (response) {
+        logger.trace('Got response from cache');
+        return response;
+    }
+    if (options.maxRetries === 0) {
+        logger.debug(`Response not found, retries disabled`);
+        return undefined;
+    }
+    logger.debug(`Response not found, sleeping ${options.sleep} milliseconds...`);
+    await (0, util_1.sleep)(options.sleep);
+    return (0, exports.pollResponseFromCache)(cache, key, options, retry + 1);
+};
+exports.pollResponseFromCache = pollResponseFromCache;
+/**
+ * Given a Cache instance in the adapter dependencies, builds a middleware function that will perform
+ * a get from said Cache and return that if found; otherwise it'll continue the middleware chain.
+ *
+ * @param adapter - an initialized adapter
+ * @returns the cache middleware function
+ */
+const buildCacheMiddleware = (adapter) => async (req, res) => {
+    const response = await adapter.dependencies.cache.get(req.requestContext.cacheKey);
+    if (response) {
+        logger.debug('Found response from cache, sending that');
+        if (adapter.config.METRICS_ENABLED && adapter.config.EXPERIMENTAL_METRICS_ENABLED) {
+            const label = cacheMetrics.cacheMetricsLabel(req.requestContext.cacheKey, req.requestContext.meta?.metrics?.feedId || 'N/A', adapter.config.CACHE_TYPE);
+            // Record cache staleness and cache get count and value
+            const staleness = calculateStaleness(response.maxAge, adapter.config.CACHE_MAX_AGE);
+            cacheMetrics.cacheGet(label, response.result, staleness);
+            req.requestContext.meta = {
+                ...req.requestContext.meta,
+                metrics: { ...req.requestContext.meta?.metrics, cacheHit: true },
+            };
+        }
+        return res.send(response);
+    }
+    logger.debug('Did not find response in cache, moving to next middleware');
+};
+exports.buildCacheMiddleware = buildCacheMiddleware;

package/dist/src/cache/redis.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisCache = void 0;
+const util_1 = require("../util");
+const cacheMetrics = __importStar(require("./metrics"));
+const logger = (0, util_1.makeLogger)('RedisCache');
+/**
+ * Redis implementation of a Cache. It uses a simple js Object, storing entries with both
+ * a value and an expiration timestamp. Expired entries are deleted on reads (i.e. no background gc/upkeep).
+ *
+ * @typeParam T - the type for the entries' values
+ */
+class RedisCache {
+    constructor(client) {
+        this.client = client;
+    }
+    async get(key) {
+        logger.trace(`Getting key ${key}`);
+        const value = await this.client.get(key);
+        // Record get command sent to Redis
+        cacheMetrics.redisCommandsSentCount
+            .labels({ status: cacheMetrics.CMD_SENT_STATUS.SUCCESS, function_name: 'get' })
+            .inc();
+        if (!value) {
+            logger.debug(`No entry in redis cache for key "${key}", returning undefined`);
+            return undefined;
+        }
+        return JSON.parse(value);
+    }
+    async delete(key) {
+        logger.trace(`Deleting key ${key}`);
+        await this.client.del(key);
+        // Record delete command sent to Redis
+        cacheMetrics.redisCommandsSentCount
+            .labels({ status: cacheMetrics.CMD_SENT_STATUS.SUCCESS, function_name: 'delete' })
+            .inc();
+    }
+    async set(key, value, ttl) {
+        logger.trace(`Setting key ${key}`);
+        await this.client.set(key, JSON.stringify(value), 'PX', ttl);
+        // Only record metrics if feed Id is present, otherwise assuming value is not adapter response to record
+        const feedId = value.meta?.metrics?.feedId;
+        if (feedId) {
+            // Record cache set count, max age, and staleness (set to 0 for cache set)
+            const label = cacheMetrics.cacheMetricsLabel(key, feedId, cacheMetrics.CacheTypes.Redis);
+            cacheMetrics.cacheSet(label, ttl);
+        }
+        // Record set command sent to Redis
+        cacheMetrics.redisCommandsSentCount
+            .labels({ status: cacheMetrics.CMD_SENT_STATUS.SUCCESS, function_name: 'set' })
+            .inc();
+    }
+    async setMany(entries, ttl) {
+        logger.trace(`Setting a bunch of keys`);
+        // Unfortunately, there's no ttl for mset
+        let chain = this.client.multi();
+        for (const entry of entries) {
+            chain = chain.set(entry.key, JSON.stringify(entry.value), 'PX', ttl);
+        }
+        await chain.exec();
+        // Loop again, but this time to record these in metrics
+        for (const entry of entries) {
+            // Only record metrics if feed Id is present, otherwise assuming value is not adapter response to record
+            const feedId = entry.value.meta?.metrics?.feedId;
+            if (feedId) {
+                // Record cache set count, max age, and staleness (set to 0 for cache set)
+                const label = cacheMetrics.cacheMetricsLabel(entry.key, feedId, cacheMetrics.CacheTypes.Redis);
+                cacheMetrics.cacheSet(label, ttl);
+            }
+        }
+        // Record setMany command sent to Redis
+        cacheMetrics.redisCommandsSentCount
+            .labels({ status: cacheMetrics.CMD_SENT_STATUS.SUCCESS, function_name: 'exec' })
+            .inc();
+    }
+}
+exports.RedisCache = RedisCache;

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

@@ -0,0 +1,214 @@
+export declare const BaseSettings: {
+    readonly API_ENDPOINT: {
+        readonly description: "The URL that the certain transports use to retrieve data";
+        readonly type: "string";
+    };
+    readonly API_KEY: {
+        readonly description: "Default setting for an EA key";
+        readonly type: "string";
+    };
+    readonly BASE_URL: {
+        readonly description: "Starting path for the EA handler endpoint";
+        readonly type: "string";
+        readonly default: "/";
+    };
+    readonly CACHE_MAX_AGE: {
+        readonly description: "Maximum amount of time (in ms) that a response will stay cached";
+        readonly type: "number";
+        readonly default: 90000;
+    };
+    readonly CACHE_REDIS_HOST: {
+        readonly description: "Hostname for the Redis instance to be used";
+        readonly type: "string";
+        readonly default: "127.0.0.1";
+    };
+    readonly CACHE_REDIS_PORT: {
+        readonly description: "Port for the Redis instance to be used";
+        readonly type: "number";
+        readonly default: 6379;
+    };
+    readonly CACHE_TYPE: {
+        readonly description: "The type of cache to use throughout the EA";
+        readonly type: "enum";
+        readonly default: "local";
+        readonly options: readonly ["local", "redis"];
+    };
+    readonly CORRELATION_ID_ENABLED: {
+        readonly description: "Flag to enable correlation IDs for sent requests in logging";
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly EA_PORT: {
+        readonly description: "Port through which the EA will listen for REST requests (if mode is set to \"reader\" or \"reader-writer\")";
+        readonly type: "number";
+        readonly default: 8080;
+    };
+    readonly EXPERIMENTAL_METRICS_ENABLED: {
+        readonly description: "Flag to specify whether or not to collect metrics. Used as fallback for METRICS_ENABLED";
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly LOG_LEVEL: {
+        readonly description: "Minimum level required for logs to be output";
+        readonly type: "string";
+        readonly default: "info";
+    };
+    readonly METRICS_ENABLED: {
+        readonly description: "Flag to specify whether or not to startup the metrics server";
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly METRICS_NAME: {
+        readonly description: "Metrics name";
+        readonly type: "string";
+    };
+    readonly METRICS_PORT: {
+        readonly description: "Port metrics will be exposed to";
+        readonly type: "number";
+        readonly default: 9080;
+    };
+    readonly METRICS_USE_BASE_URL: {
+        readonly description: "Flag to specify whether or not to prepend the BASE_URL to the metrics endpoint";
+        readonly type: "boolean";
+    };
+    readonly RATE_LIMIT_API_TIER: {
+        readonly description: "Rate limiting tier to use from the available options for the adapter. If not present, the adapter will run using the first tier on the list.";
+        readonly type: "string";
+    };
+    readonly WARMUP_SUBSCRIPTION_TTL: {
+        readonly type: "number";
+        readonly description: "TTL for batch warmer subscriptions";
+        readonly default: 10000;
+    };
+    readonly WS_SUBSCRIPTION_TTL: {
+        readonly description: "";
+        readonly type: "number";
+        readonly default: 120000;
+    };
+    readonly CACHE_POLLING_MAX_RETRIES: {
+        readonly description: "Max amount of times to attempt to find EA response in the cache after the Transport has been set up";
+        readonly type: "number";
+        readonly default: 10;
+    };
+    readonly CACHE_POLLING_SLEEP_MS: {
+        readonly description: "The number of ms to sleep between each retry to fetch the EA response in the cache";
+        readonly type: "number";
+        readonly default: 200;
+    };
+    readonly DEFAULT_CACHE_KEY: {
+        readonly description: "Default key to be used when one cannot be determined from request parameters";
+        readonly type: "string";
+        readonly default: "DEFAULT_CACHE_KEY";
+    };
+    readonly EA_HOST: {
+        readonly description: "Host this EA will listen for REST requests on (if mode is set to \"reader\" or \"reader-writer\")";
+        readonly type: "string";
+        readonly default: "::";
+    };
+    readonly EA_MODE: {
+        readonly description: "Port this EA will listen for REST requests on (if mode is set to \"reader\" or \"reader-writer\")";
+        readonly type: "enum";
+        readonly default: "reader-writer";
+        readonly options: readonly ["reader", "writer", "reader-writer"];
+    };
+    readonly REST_TRANSPORT_MAX_RATE_LIMIT_RETRIES: {
+        readonly description: "Maximum amount of times the Rest Transport will attempt to set up a request when blocked by the rate limiter";
+        readonly type: "number";
+        readonly default: 3;
+    };
+    readonly REST_TRANSPORT_MS_BETWEEN_RATE_LIMIT_RETRIES: {
+        readonly description: "Time that the Rest Transport will wait between retries when blocked by the rate limiter";
+        readonly type: "number";
+        readonly default: 400;
+    };
+    readonly MAX_COMMON_KEY_SIZE: {
+        readonly description: "Maximum amount of characters that the common part of the cache key or feed ID can have";
+        readonly type: "number";
+        readonly default: 300;
+        readonly validate: (value?: number) => "MAX_COMMON_KEY_SIZE must be a number between 150 and 500" | undefined;
+    };
+    readonly SMOKE_TEST_PAYLOAD_FILE_NAME: {
+        readonly description: "Name of the test payload file used for the smoke endpoint";
+        readonly type: "string";
+    };
+};
+export declare const buildAdapterConfig: <CustomSettings extends CustomSettingsType<CustomSettings> = EmptySettings>({ overrides, customSettings, }: {
+    overrides?: Partial<BaseAdapterConfig> | undefined;
+    customSettings?: SettingsMap | undefined;
+}) => AdapterConfig<CustomSettings>;
+declare type SettingValueType = string | number | boolean;
+declare type SettingType<C extends Setting> = C['type'] extends 'string' ? string : C['type'] extends 'number' ? number : C['type'] extends 'boolean' ? boolean : C['type'] extends 'enum' ? C['options'] extends readonly string[] ? C['options'][number] : never : never;
+declare type BaseSettingsType = typeof BaseSettings;
+export declare type Setting = {
+    type: 'string';
+    description: string;
+    options?: never;
+    default?: string;
+    validate?: (value?: string) => ValidationErrorMessage;
+    required?: false;
+} | {
+    type: 'string';
+    description: string;
+    options?: never;
+    default?: string;
+    validate?: (value: string) => ValidationErrorMessage;
+    required: true;
+} | {
+    type: 'number';
+    description: string;
+    options?: never;
+    default?: number;
+    validate?: (value?: number) => ValidationErrorMessage;
+    required?: false;
+} | {
+    type: 'number';
+    description: string;
+    options?: never;
+    default?: number;
+    validate?: (value: number) => ValidationErrorMessage;
+    required: true;
+} | {
+    type: 'boolean';
+    description: string;
+    options?: never;
+    default?: boolean;
+    validate?: (value?: boolean) => ValidationErrorMessage;
+    required?: false;
+} | {
+    type: 'boolean';
+    description: string;
+    options?: never;
+    default?: boolean;
+    validate?: (value: boolean) => ValidationErrorMessage;
+    required: true;
+} | {
+    type: 'enum';
+    description: string;
+    default?: string;
+    options: readonly string[];
+    validate?: (value?: string) => ValidationErrorMessage;
+    required?: false;
+} | {
+    type: 'enum';
+    description: string;
+    default?: string;
+    options: readonly string[];
+    validate?: (value: string) => ValidationErrorMessage;
+    required: true;
+};
+export declare type AdapterConfigFromSettings<T extends SettingsMap> = {
+    -readonly [K in keyof T as T[K] extends {
+        default: SettingValueType;
+    } ? K : T[K]['required'] extends true ? K : never]: SettingType<T[K]>;
+} & {
+    -readonly [K in keyof T as T[K] extends {
+        default: SettingValueType;
+    } ? never : T[K]['required'] extends true ? never : K]?: SettingType<T[K]> | undefined;
+};
+export declare type BaseAdapterConfig = AdapterConfigFromSettings<BaseSettingsType>;
+export declare type AdapterConfig<T extends CustomSettingsType<T> = SettingsMap> = AdapterConfigFromSettings<T> & BaseAdapterConfig;
+export declare type CustomSettingsType<T = SettingsMap> = Record<keyof T, Setting>;
+export declare type EmptySettings = Record<string, never>;
+export declare type SettingsMap = Record<string, Setting>;
+export declare type ValidationErrorMessage = string | undefined;
+export {};