@decaf-ts/integrations 0.10.8 → 0.12.0

package/lib/types/feature-flags/EngineCapabilityFeatureFlag.service.d.cts

@@ -0,0 +1,116 @@
+import { FeatureFlag } from "./models/FeatureFlag.model.d.cts";
+import { FeatureFlagReader } from "./readers/FeatureFlagReader.d.cts";
+import { FeatureFlagService, type FeatureFlagServiceConfig } from "./services/FeatureFlag.service.d.cts";
+import type { FeatureFlagAccessSubject, FeatureFlagRegistry } from "./types.d.cts";
+/** The normalized per-feature verdict served in an engine capability manifest. */
+export type EngineCapabilityFeatureVerdict = "SUPPORTED" | "NOT_SUPPORTED" | "EXTENSION_POINT";
+/** One engine entry of the manifest the flag registry is derived from. */
+export interface EngineCapabilityFlagSource {
+    /** Allowlisted engine id. */
+    engineId: string;
+    /** The engine's feature/verdict rows. */
+    capabilities: ReadonlyArray<{
+        feature: string;
+        verdict: EngineCapabilityFeatureVerdict;
+    }>;
+}
+/** The manifest subset the capability flag registry is derived from. */
+export interface EngineCapabilityManifestInput {
+    /** One entry per available engine. */
+    engines: ReadonlyArray<EngineCapabilityFlagSource>;
+    /** Engine id the server defaults to. */
+    defaultEngineId?: string;
+}
+/**
+ * Builds the canonical, collision-safe feature-flag key for an engine, or for one
+ * feature of an engine. Keys are `engine<Pascal(engineId)>` and
+ * `engine<Pascal(engineId)><Pascal(feature)>`; use this helper rather than
+ * assembling keys by hand.
+ *
+ * @param engineId - The engine id.
+ * @param feature - The feature name, when a feature key is wanted.
+ * @returns The canonical flag key.
+ */
+export declare function engineCapabilityFlagKey(engineId: string, feature?: string): string;
+/**
+ * Derives a fail-closed feature-flag registry from an engine capability manifest:
+ * an engine key is enabled, and a feature key is enabled **only** when the engine
+ * declares that feature `SUPPORTED`. Features declared `NOT_SUPPORTED` or
+ * `EXTENSION_POINT`, and features absent from the manifest, are all disabled.
+ *
+ * @param manifest - The served engine capability manifest.
+ * @returns The derived flag registry.
+ */
+export declare function engineCapabilityFlagRegistry(manifest: EngineCapabilityManifestInput): FeatureFlagRegistry;
+/** Configuration for {@link EngineCapabilityFeatureFlagService}. */
+export interface EngineCapabilityFeatureFlagServiceConfig extends FeatureFlagServiceConfig {
+    /**
+     * The served engine capability manifest the flag values are derived from.
+     * When omitted the registry is empty, so every feature resolves denied
+     * (fail-closed).
+     */
+    manifest?: EngineCapabilityManifestInput;
+}
+/**
+ * A {@link FeatureFlagService} whose values come from the served engine
+ * capability manifest. Every read path (`isEnabled`, `resolveFeatureFlags`,
+ * `isEnabledForSubject`, `resolveFeatureFlagsForSubject`) resolves against the
+ * derived registry only; a feature the manifest does not declare is denied.
+ * `syncFromEnvironment` is overridden to fail closed rather than read the
+ * environment.
+ *
+ * Carries its own `@service()` decorator: the parent {@link FeatureFlagService}
+ * is itself `@service(...)`-decorated, so without a decorator of its own the
+ * parent constructor's singleton wrapper would be returned and the capability
+ * methods below would be unreachable. Decorating the leaf subclass restores it;
+ * the subclass does not rely on the parent's environment/repository fields.
+ *
+ * The constructor additionally re-parents the constructed instance when the parent's
+ * singleton wrapper has already cached a `FeatureFlagService` (which would otherwise
+ * be returned through `super()`), so the capability methods stay reachable on every
+ * construction.
+ */
+export declare class EngineCapabilityFeatureFlagService extends FeatureFlagService {
+    constructor();
+    private capabilityRegistry;
+    /**
+     * Initializes the service from its manifest, replacing the base service's
+     * environment/repository-backed registry with the capability-derived one. No
+     * environment source is read.
+     */
+    initialize(...args: any[]): Promise<{
+        config: EngineCapabilityFeatureFlagServiceConfig;
+        client: FeatureFlagReader;
+    }>;
+    /**
+     * Whether an engine is available in the manifest.
+     *
+     * @param engineId - The engine id to check.
+     * @returns `true` when the engine is declared.
+     */
+    isEngineEnabled(engineId: string): boolean;
+    /**
+     * Whether an engine declares a feature as `SUPPORTED`. An undeclared feature,
+     * or one declared `NOT_SUPPORTED`/`EXTENSION_POINT`, resolves `false`.
+     *
+     * @param engineId - The engine id to check.
+     * @param feature - The feature name to check.
+     * @returns `true` only when the manifest declares the feature `SUPPORTED`.
+     */
+    isEngineFeatureEnabled(engineId: string, feature: string): boolean;
+    /** Resolves a flag from the capability registry; undeclared keys are denied. */
+    isEnabled(key: string): boolean;
+    /** Returns a copy of the capability-derived registry. */
+    resolveFeatureFlags(): Promise<FeatureFlagRegistry>;
+    /** Returns a copy of the capability-derived registry (not subject-scoped). */
+    resolveFeatureFlagsForSubject(subject: FeatureFlagAccessSubject, ...args: any[]): Promise<FeatureFlagRegistry>;
+    /** Resolves a flag from the capability registry; undeclared keys are denied. */
+    isEnabledForSubject(key: string, subject: FeatureFlagAccessSubject, ...args: any[]): Promise<boolean>;
+    /** Lists the enabled capability flags as models, without touching a repository. */
+    listEnabled(...args: any[]): Promise<FeatureFlag[]>;
+    /**
+     * Fails closed: capability flags are derived from the served engine manifest
+     * and are never synced from the environment.
+     */
+    syncFromEnvironment(...args: any[]): Promise<FeatureFlag[]>;
+}

package/lib/types/feature-flags/EngineCapabilityFeatureFlag.service.d.mts

@@ -0,0 +1,116 @@
+import { FeatureFlag } from "./models/FeatureFlag.model.d.mts";
+import { FeatureFlagReader } from "./readers/FeatureFlagReader.d.mts";
+import { FeatureFlagService, type FeatureFlagServiceConfig } from "./services/FeatureFlag.service.d.mts";
+import type { FeatureFlagAccessSubject, FeatureFlagRegistry } from "./types.d.mts";
+/** The normalized per-feature verdict served in an engine capability manifest. */
+export type EngineCapabilityFeatureVerdict = "SUPPORTED" | "NOT_SUPPORTED" | "EXTENSION_POINT";
+/** One engine entry of the manifest the flag registry is derived from. */
+export interface EngineCapabilityFlagSource {
+    /** Allowlisted engine id. */
+    engineId: string;
+    /** The engine's feature/verdict rows. */
+    capabilities: ReadonlyArray<{
+        feature: string;
+        verdict: EngineCapabilityFeatureVerdict;
+    }>;
+}
+/** The manifest subset the capability flag registry is derived from. */
+export interface EngineCapabilityManifestInput {
+    /** One entry per available engine. */
+    engines: ReadonlyArray<EngineCapabilityFlagSource>;
+    /** Engine id the server defaults to. */
+    defaultEngineId?: string;
+}
+/**
+ * Builds the canonical, collision-safe feature-flag key for an engine, or for one
+ * feature of an engine. Keys are `engine<Pascal(engineId)>` and
+ * `engine<Pascal(engineId)><Pascal(feature)>`; use this helper rather than
+ * assembling keys by hand.
+ *
+ * @param engineId - The engine id.
+ * @param feature - The feature name, when a feature key is wanted.
+ * @returns The canonical flag key.
+ */
+export declare function engineCapabilityFlagKey(engineId: string, feature?: string): string;
+/**
+ * Derives a fail-closed feature-flag registry from an engine capability manifest:
+ * an engine key is enabled, and a feature key is enabled **only** when the engine
+ * declares that feature `SUPPORTED`. Features declared `NOT_SUPPORTED` or
+ * `EXTENSION_POINT`, and features absent from the manifest, are all disabled.
+ *
+ * @param manifest - The served engine capability manifest.
+ * @returns The derived flag registry.
+ */
+export declare function engineCapabilityFlagRegistry(manifest: EngineCapabilityManifestInput): FeatureFlagRegistry;
+/** Configuration for {@link EngineCapabilityFeatureFlagService}. */
+export interface EngineCapabilityFeatureFlagServiceConfig extends FeatureFlagServiceConfig {
+    /**
+     * The served engine capability manifest the flag values are derived from.
+     * When omitted the registry is empty, so every feature resolves denied
+     * (fail-closed).
+     */
+    manifest?: EngineCapabilityManifestInput;
+}
+/**
+ * A {@link FeatureFlagService} whose values come from the served engine
+ * capability manifest. Every read path (`isEnabled`, `resolveFeatureFlags`,
+ * `isEnabledForSubject`, `resolveFeatureFlagsForSubject`) resolves against the
+ * derived registry only; a feature the manifest does not declare is denied.
+ * `syncFromEnvironment` is overridden to fail closed rather than read the
+ * environment.
+ *
+ * Carries its own `@service()` decorator: the parent {@link FeatureFlagService}
+ * is itself `@service(...)`-decorated, so without a decorator of its own the
+ * parent constructor's singleton wrapper would be returned and the capability
+ * methods below would be unreachable. Decorating the leaf subclass restores it;
+ * the subclass does not rely on the parent's environment/repository fields.
+ *
+ * The constructor additionally re-parents the constructed instance when the parent's
+ * singleton wrapper has already cached a `FeatureFlagService` (which would otherwise
+ * be returned through `super()`), so the capability methods stay reachable on every
+ * construction.
+ */
+export declare class EngineCapabilityFeatureFlagService extends FeatureFlagService {
+    constructor();
+    private capabilityRegistry;
+    /**
+     * Initializes the service from its manifest, replacing the base service's
+     * environment/repository-backed registry with the capability-derived one. No
+     * environment source is read.
+     */
+    initialize(...args: any[]): Promise<{
+        config: EngineCapabilityFeatureFlagServiceConfig;
+        client: FeatureFlagReader;
+    }>;
+    /**
+     * Whether an engine is available in the manifest.
+     *
+     * @param engineId - The engine id to check.
+     * @returns `true` when the engine is declared.
+     */
+    isEngineEnabled(engineId: string): boolean;
+    /**
+     * Whether an engine declares a feature as `SUPPORTED`. An undeclared feature,
+     * or one declared `NOT_SUPPORTED`/`EXTENSION_POINT`, resolves `false`.
+     *
+     * @param engineId - The engine id to check.
+     * @param feature - The feature name to check.
+     * @returns `true` only when the manifest declares the feature `SUPPORTED`.
+     */
+    isEngineFeatureEnabled(engineId: string, feature: string): boolean;
+    /** Resolves a flag from the capability registry; undeclared keys are denied. */
+    isEnabled(key: string): boolean;
+    /** Returns a copy of the capability-derived registry. */
+    resolveFeatureFlags(): Promise<FeatureFlagRegistry>;
+    /** Returns a copy of the capability-derived registry (not subject-scoped). */
+    resolveFeatureFlagsForSubject(subject: FeatureFlagAccessSubject, ...args: any[]): Promise<FeatureFlagRegistry>;
+    /** Resolves a flag from the capability registry; undeclared keys are denied. */
+    isEnabledForSubject(key: string, subject: FeatureFlagAccessSubject, ...args: any[]): Promise<boolean>;
+    /** Lists the enabled capability flags as models, without touching a repository. */
+    listEnabled(...args: any[]): Promise<FeatureFlag[]>;
+    /**
+     * Fails closed: capability flags are derived from the served engine manifest
+     * and are never synced from the environment.
+     */
+    syncFromEnvironment(...args: any[]): Promise<FeatureFlag[]>;
+}

package/lib/types/feature-flags/index.d.cts

@@ -10,4 +10,5 @@ export * from "./models/FeatureFlag.model.d.cts";
 export * from "./models/FeatureFlagAccess.model.d.cts";
 export * from "./readers/index.d.cts";
 export * from "./services/FeatureFlag.service.d.cts";
+export * from "./EngineCapabilityFeatureFlag.service.d.cts";
 export * from "./decorators.d.cts";

package/lib/types/feature-flags/index.d.mts

@@ -10,4 +10,5 @@ export * from "./models/FeatureFlag.model.d.mts";
 export * from "./models/FeatureFlagAccess.model.d.mts";
 export * from "./readers/index.d.mts";
 export * from "./services/FeatureFlag.service.d.mts";
+export * from "./EngineCapabilityFeatureFlag.service.d.mts";
 export * from "./decorators.d.mts";

package/lib/types/index.d.cts

@@ -7,6 +7,6 @@ export * from "./utils.d.cts";
 export * from "./namespaces/index.d.cts";
 export * from "./feature-flags/index.d.cts";
 export declare const VERSION: string;
-export declare const COMMIT = "9f5df0a";
-export declare const FULL_VERSION = "0.10.7-9f5df0a";
+export declare const COMMIT = "004735e";
+export declare const FULL_VERSION = "0.11.0-004735e";
 export declare const PACKAGE_NAME: string;

package/lib/types/index.d.mts

@@ -7,6 +7,6 @@ export * from "./utils.d.mts";
 export * from "./namespaces/index.d.mts";
 export * from "./feature-flags/index.d.mts";
 export declare const VERSION: string;
-export declare const COMMIT = "9f5df0a";
-export declare const FULL_VERSION = "0.10.7-9f5df0a";
+export declare const COMMIT = "004735e";
+export declare const FULL_VERSION = "0.11.0-004735e";
 export declare const PACKAGE_NAME: string;

package/lib/types/io/airtable/AirtableService.d.cts

@@ -0,0 +1,268 @@
+import { HttpApiService, type HttpApiServiceConfig } from "../../shared/http/index.d.cts";
+/**
+ * @description Configuration for the Airtable service
+ * @summary Extends {@link HttpApiServiceConfig} with the Airtable personal
+ * access token (sent as a bearer token) and the default `baseId` used when a
+ * call does not override it. When omitted, the `io.airtable` environment
+ * slice supplies the token (and optional `baseId`, `baseUrl`, `timeout`).
+ * @category IO
+ * @memberOf module:integrations/io/airtable/service
+ */
+export interface AirtableServiceConfig extends HttpApiServiceConfig {
+    /**
+     * @description Airtable personal access token
+     * @summary Sent as `Authorization: Bearer <token>` with every API call.
+     */
+    token?: string;
+    /**
+     * @description Default base ID used when a call does not override it
+     */
+    baseId?: string;
+}
+/**
+ * @description Normalized Airtable record descriptor
+ * @summary The Airtable record envelope: the record `id`, the `fields` map
+ * (column name to value), and the optional `createdTime` timestamp.
+ * @category IO
+ * @memberOf module:integrations/io/airtable/service
+ */
+export interface AirtableRecord {
+    id: string;
+    fields: Record<string, unknown>;
+    createdTime?: string;
+}
+/**
+ * @description Options for listing Airtable records
+ * @summary Carries the required `table` name plus the view, formula filter,
+ * record caps and paging offset, field projection, and first-sort configuration
+ * Airtable supports. Only the first sort entry is sent (Airtable's
+ * `sort[0][field]`/`sort[0][direction]` query parameters); paging works by
+ * passing the previous page's `offset` back as `offset`.
+ * @category IO
+ * @memberOf module:integrations/io/airtable/service
+ */
+export interface AirtableListOptions {
+    /**
+     * @description Table name or ID to list records from (required)
+     */
+    table: string;
+    /**
+     * @description View name or ID to restrict the listing to
+     */
+    view?: string;
+    /**
+     * @description Airtable formula restricting the returned records (e.g. `"{Status} = 'Active'"`)
+     */
+    filterByFormula?: string;
+    /**
+     * @description Maximum number of records to return in total
+     */
+    maxRecords?: number;
+    /**
+     * @description Number of records per page
+     */
+    pageSize?: number;
+    /**
+     * @description The `offset` from the previous page's result
+     */
+    offset?: string;
+    /**
+     * @description Column names to project
+     */
+    fields?: string[];
+    /**
+     * @description First sort entry applied to the listing
+     */
+    sort?: Array<{
+        field: string;
+        direction?: "asc" | "desc";
+    }>;
+}
+/**
+ * @description Result of an Airtable record listing
+ * @summary Carries the page of `records` and the `offset` cursor to pass back
+ * as `AirtableListOptions.offset` when more pages exist.
+ * @category IO
+ * @memberOf module:integrations/io/airtable/service
+ */
+export interface AirtableListResult {
+    records: AirtableRecord[];
+    offset?: string;
+}
+/**
+ * @description Input for creating or updating an Airtable record
+ * @summary Carries the required `table` name, the `fields` map to write, and
+ * the `typecast` flag letting Airtable convert values to the column types.
+ * `updateRecord` additionally carries the `recordId`.
+ * @category IO
+ * @memberOf module:integrations/io/airtable/service
+ */
+export interface AirtableWriteInput {
+    table: string;
+    fields: Record<string, unknown>;
+    typecast?: boolean;
+}
+/**
+ * @description Airtable Web API integration service
+ * @summary An undecorated HTTP service for listing records
+ * with filtering, sorting, and cursor paging; fetching, creating, updating,
+ * and deleting individual records. Base targets resolve per call from the
+ * `baseId` argument, falling back to the configured value, and throw
+ * `InternalError` when unresolved. Every operation requires a token
+ * (`requireToken()`), and transport failures are mapped to decaf errors via
+ * {@link httpError}.
+ * @class AirtableService
+ * @category IO
+ * @example
+ * ```ts
+ * import { AirtableService } from "@decaf-ts/integrations/io/airtable";
+ *
+ * const airtable = new AirtableService();
+ * await airtable.initialize({
+ *   token: process.env.GRAPH_CREDENTIAL_AIRTABLE_TOKEN,
+ *   baseId: "appExampleBase",
+ * });
+ * const created = await airtable.createRecord({
+ *   table: "Tasks",
+ *   fields: { Name: "Ship release", Status: "Todo" },
+ * });
+ * ```
+ * @memberOf module:integrations/io/airtable/service
+ */
+export declare class AirtableService extends HttpApiService<AirtableServiceConfig> {
+    /**
+     * @description The provider name used in error messages
+     */
+    protected readonly serviceName = "Airtable";
+    /**
+     * @description The Airtable Web API v0 base URL
+     * @summary Used when the resolved config carries no `baseUrl`.
+     * @returns {string} `"https://api.airtable.com/v0"`.
+     */
+    protected defaultBaseUrl(): string;
+    /**
+     * @description Builds the Airtable bearer authorization headers
+     * @summary Returns the `Authorization: Bearer <token>` header when the
+     * config carries a token, and no headers otherwise.
+     * @param {AirtableServiceConfig} config - The resolved service configuration.
+     * @returns {Record<string, string>} The authorization headers (empty without a token).
+     */
+    protected authHeaders(config: AirtableServiceConfig): Record<string, string>;
+    /**
+     * @description Reads the Airtable credentials and defaults from the environment
+     * @summary Reads the `io.airtable` environment slice and returns a partial
+     * config when a token is configured, `undefined` otherwise. Values pass
+     * through `envString`/`envNumber` to reject unset-leaf proxies.
+     * @returns {Partial<AirtableServiceConfig> | undefined} A partial config, or `undefined` when no Airtable token is configured.
+     */
+    protected configFromEnvironment(): Partial<AirtableServiceConfig> | undefined;
+    /**
+     * @description Resolves the URL-encoded base path for a call
+     * @summary Builds `/<baseId>` from the given base ID, falling back to the
+     * configured value, and throws when neither is available.
+     * @param {string} [baseId] - The per-call base override.
+     * @returns {string} The URL-encoded base API path.
+     * @throws {InternalError} When neither the input nor the config yields a base ID.
+     */
+    protected basePath(baseId?: string): string;
+    /**
+     * @description Resolves the URL-encoded table path for a call
+     * @summary Builds `<basePath>/<table>` with both segments URL-encoded, and
+     * throws when the table name is empty (or the base cannot be resolved).
+     * @param {string} table - The table name or ID.
+     * @param {string} [baseId] - The per-call base override.
+     * @returns {string} The URL-encoded table API path.
+     * @throws {InternalError} When the table name is empty or the base ID cannot be resolved.
+     */
+    protected tablePath(table: string, baseId?: string): string;
+    /**
+     * @description Lists records in an Airtable table with cursor paging
+     * @summary `GET`s the table endpoint with the configured view, formula
+     * filter, record caps, page size, page offset, field projection, and first
+     * sort entry. Return the `offset` cursor as the next call's
+     * `AirtableListOptions.offset` to fetch further pages.
+     * @param {AirtableListOptions} options - The table and filter/sort/paging options.
+     * @param {string} [baseId] - The base override; falls back to the configured `baseId`.
+     * @returns {Promise<AirtableListResult>} The page of records and the next offset cursor when more pages exist.
+     * @throws {InternalError} When no token is configured or the table/base cannot be resolved.
+     * @throws {NotFoundError} When the base or table does not exist (HTTP 404).
+     * @throws {ConflictError} When Airtable answers with HTTP 409.
+     * @throws {BadRequestError} When Airtable answers with any other HTTP error status (e.g. invalid formula).
+     * @example
+     * ```ts
+     * let offset: string | undefined;
+     * do {
+     *   const page = await airtable.listRecords({
+     *     table: "Tasks",
+     *     filterByFormula: "{Status} = 'Active'",
+     *     pageSize: 100,
+     *     offset,
+     *     sort: [{ field: "Name", direction: "asc" }],
+     *   });
+     *   console.log(page.records);
+     *   offset = page.offset;
+     * } while (offset);
+     * ```
+     */
+    listRecords(options: AirtableListOptions, baseId?: string): Promise<AirtableListResult>;
+    /**
+     * @description Fetches a single Airtable record
+     * @summary `GET`s the table endpoint with the record ID appended and
+     * returns the record envelope.
+     * @param {string} table - The table name or ID.
+     * @param {string} recordId - The record ID to fetch (e.g. `"rec1234567890"`).
+     * @param {string} [baseId] - The base override; falls back to the configured `baseId`.
+     * @returns {Promise<AirtableRecord>} The record envelope.
+     * @throws {InternalError} When no token is configured or the table/base cannot be resolved.
+     * @throws {NotFoundError} When the record does not exist (HTTP 404).
+     * @throws {ConflictError} When Airtable answers with HTTP 409.
+     * @throws {BadRequestError} When Airtable answers with any other HTTP error status.
+     */
+    getRecord(table: string, recordId: string, baseId?: string): Promise<AirtableRecord>;
+    /**
+     * @description Creates an Airtable record
+     * @summary `POST`s the fields map to the table endpoint; `typecast` lets
+     * Airtable coerce values into the column types (disabled by default).
+     * @param {AirtableWriteInput} input - The table, fields, and typecast option.
+     * @param {string} [baseId] - The base override; falls back to the configured `baseId`.
+     * @returns {Promise<AirtableRecord>} The created record envelope.
+     * @throws {InternalError} When no token is configured or the table/base cannot be resolved.
+     * @throws {NotFoundError} When the base or table does not exist (HTTP 404).
+     * @throws {ConflictError} When Airtable answers with HTTP 409.
+     * @throws {BadRequestError} When Airtable answers with any other HTTP error status (e.g. invalid field values).
+     */
+    createRecord(input: AirtableWriteInput, baseId?: string): Promise<AirtableRecord>;
+    /**
+     * @description Updates an Airtable record
+     * @summary `PATCH`es the fields map onto the record identified by
+     * `recordId`; only the provided fields change. `typecast` lets Airtable
+     * coerce values into the column types (disabled by default).
+     * @param {AirtableWriteInput & {recordId: string}} input - The table, fields, typecast option, and target record ID.
+     * @param {string} [baseId] - The base override; falls back to the configured `baseId`.
+     * @returns {Promise<AirtableRecord>} The updated record envelope.
+     * @throws {InternalError} When no token is configured or the table/base cannot be resolved.
+     * @throws {NotFoundError} When the record does not exist (HTTP 404).
+     * @throws {ConflictError} When Airtable answers with HTTP 409.
+     * @throws {BadRequestError} When Airtable answers with any other HTTP error status (e.g. invalid field values).
+     */
+    updateRecord(input: AirtableWriteInput & {
+        recordId: string;
+    }, baseId?: string): Promise<AirtableRecord>;
+    /**
+     * @description Deletes an Airtable record
+     * @summary `DELETE`s the record identified by `recordId` and returns the
+     * Airtable deletion confirmation.
+     * @param {string} table - The table name or ID.
+     * @param {string} recordId - The record ID to delete.
+     * @param {string} [baseId] - The base override; falls back to the configured `baseId`.
+     * @returns {Promise<{id: string, deleted: boolean}>} The deleted record's ID and Airtable's `deleted` confirmation.
+     * @throws {InternalError} When no token is configured or the table/base cannot be resolved.
+     * @throws {NotFoundError} When the record does not exist (HTTP 404).
+     * @throws {ConflictError} When Airtable answers with HTTP 409.
+     * @throws {BadRequestError} When Airtable answers with any other HTTP error status.
+     */
+    deleteRecord(table: string, recordId: string, baseId?: string): Promise<{
+        id: string;
+        deleted: boolean;
+    }>;
+}