@unito/integration-sdk 0.1.11 → 1.0.0

package/dist/src/integration.js

@@ -3,6 +3,7 @@ import { InvalidHandler } from './errors.js';
 import correlationIdMiddleware from './middlewares/correlationId.js';
 import loggerMiddleware from './middlewares/logger.js';
 import credentialsMiddleware from './middlewares/credentials.js';
+import signalMiddleware from './middlewares/signal.js';
 import secretsMiddleware from './middlewares/secrets.js';
 import selectsMiddleware from './middlewares/selects.js';
 import errorsMiddleware from './middlewares/errors.js';
@@ -14,14 +15,56 @@ function printErrorMessage(message) {
     console.error(`\x1b[31m Oops! Something went wrong! \x1b[0m`);
     console.error(message);
 }
+/**
+ * Main class for the Integration SDK providing an abstraction layer between the Integration's Graph definition
+ * and the underlying HTTP server.
+ *
+ * An `Integration` instance can have multiple handlers configured to handle different routes. Upon receiving a request,
+ * the Integration will parse the request to extract meaninful information, match the request to the appropriate handler
+ * method and forward that information in the form a {@link Context} object.
+ * The Integration also offer standardized error handling and logging to help you build a robust
+ * and reliable Integration.
+ *
+ * See our {@link https://dev.unito.io/docs/ | documentation} for more examples on how to build an integration.
+ */
 export default class Integration {
     handlers;
     instance = undefined;
     port;
+    /**
+     * Creates a new Integration instance with default port set to 9200.
+     *
+     * @param options The {@link Options} to configure the Integration instance. Can be used to override the default port.
+     */
     constructor(options = {}) {
         this.port = options.port || 9200;
         this.handlers = [];
     }
+    /**
+     * Adds a group of common handlers to the integration.
+     *
+     * Handlers added to the integration can be one of the following:
+     * - `ItemHandlers`: A group of handlers defining the implementation of the Operations available for a given item.
+     * - `CredentialAccountHandlers`: A handler returning the CredentialAccount linked to the caller's credentials.
+     * - `ParseWebhookHandlers`: A handler parsing the content of an incoming webhook.
+     * - `WebhookSubscriptionHandlers`: A handler subscribing or unsubscribing to a particular webhook.
+     * - `AcknowledgeWebhookHandlers`: A handler acknowledging the reception of a webhook.
+     *
+     * To accomodate the fact that ItemHandlers may specify multiple operations, some at the collection level, some at the
+     * item level, we need a way to define the route for each of these operations.
+     * To achieve this, we assume that if the last part of the path is a variable, then it is the item identifier.
+     *
+     * @example The following path: `/trainer/:trainerId/pokemons/:pokemonId` will lead to the following
+     * routes:
+     * - getCollection will be called for `GET /trainer/:trainerId/pokemons/` requests
+     * - getItem will be called for `GET /trainer/:trainerId/pokemons/:pokemonId` requests
+     * - createItem will be called for `POST /trainer/:trainerId/pokemons/` requests
+     * - updateItem will be called for `PATCH /trainer/:trainerId/pokemons/:pokemonId` requests
+     * - deleteItem will be called for `DELETE /trainer/:trainerId/pokemons/:pokemonId` requests
+     *
+     * @param path The path to be used as Route for the handlers.
+     * @param handlers The Handlers definition.
+     */
     addHandler(path, handlers) {
         if (this.instance) {
             printErrorMessage(`
@@ -54,6 +97,13 @@ export default class Integration {
             process.exit(1);
         }
     }
+    /**
+     * Starts the server and listens on the specified port (default to 9200).
+     *
+     * @remarks
+     * This function should be called after all the handlers have been added to the integration
+     * and any other configuration is completed.
+     */
     start() {
         // Express Server initialization
         const app = express();
@@ -67,6 +117,7 @@ export default class Integration {
         app.use(credentialsMiddleware);
         app.use(secretsMiddleware);
         app.use(selectsMiddleware);
+        app.use(signalMiddleware);
         // Load handlers as needed.
         if (this.handlers.length) {
             for (const handler of this.handlers) {

package/dist/src/middlewares/filters.d.ts

@@ -7,10 +7,19 @@ declare global {
         }
     }
 }
-export interface Filter {
+/**
+ * Represents one filter parsed from the filters query param.
+ *
+ *  Given a filters query param containing:
+ *  `filters=[...],name=John,[...]`
+ *
+ *  Filter for `name=John` will be:
+ * `{ field: 'name', operator: 'EQUAL', values: ['John'] }`
+ */
+export type Filter = {
     field: string;
     operator: OperatorType;
     values: string[] | undefined;
-}
+};
 declare const middleware: (req: Request, res: Response, next: NextFunction) => void;
 export default middleware;

package/dist/src/middlewares/secrets.d.ts

@@ -6,6 +6,11 @@ declare global {
         }
     }
 }
+/**
+ * Represents the secrets parsed from the X-Unito-Secrets header.
+ *
+ * This is the decrypted payload of the secrets defined in the integration's configuration.
+ */
 export type Secrets = {
     [keys: string]: unknown;
 };

package/dist/src/middlewares/signal.d.ts

@@ -0,0 +1,15 @@
+import { Request, Response, NextFunction } from 'express';
+declare global {
+    namespace Express {
+        interface Locals {
+            /**
+             * An AbortSignal instantiated with the X-Unito-Operation-Deadline header. This header contains the timestamp
+             * after which Unito will consider the operation to be timed out. You can use this signal to abort any
+             * operation that would exceed this time frame.
+             */
+            signal: AbortSignal;
+        }
+    }
+}
+declare const middleware: (req: Request, res: Response, next: NextFunction) => void;
+export default middleware;

package/dist/src/middlewares/signal.js

@@ -0,0 +1,22 @@
+import { TimeoutError } from '../httpErrors.js';
+const OPERATION_DEADLINE_HEADER = 'X-Unito-Operation-Deadline';
+const middleware = (req, res, next) => {
+    const operationDeadlineHeader = Number(req.header(OPERATION_DEADLINE_HEADER));
+    if (operationDeadlineHeader) {
+        // `operationDeadlineHeader` represents a timestamp in the future, in seconds.
+        // We need to convert it to a number of milliseconds.
+        const deadline = operationDeadlineHeader * 1000 - Date.now();
+        if (deadline > 0) {
+            res.locals.signal = AbortSignal.timeout(deadline);
+        }
+        else {
+            throw new TimeoutError('Request already timed out upon reception');
+        }
+    }
+    else {
+        // Default to 20s, which is the maximum time frame allowed for an operation by Unito.
+        res.locals.signal = AbortSignal.timeout(20000);
+    }
+    next();
+};
+export default middleware;

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

@@ -1,14 +1,64 @@
 import { FetchingFunction, CachableValue } from 'cachette';
+/**
+ * The Cache class provides caching capabilities that can be used across your integration.
+ * It can be backed by a Redis instance (by passing it a URL to the instance) or a local cache.
+ *
+ * @see {@link Cache.create}
+ */
 export declare class Cache {
     private cacheInstance;
     private constructor();
+    /**
+     * Get or fetch a value
+     *
+     * @param key     The key of the value to get
+     * @param ttl     The time to live of the value in seconds.
+     * @param fetchFn The function that can retrieve the original value
+     * @param lockTtl Global distributed lock TTL (in seconds) protecting fetching.
+     *                If undefined, 0 or falsy, locking is not preformed
+     * @param shouldCacheError A callback being passed errors, controlling whether
+     *                         to cache or not errors. Defaults to never cache.
+     *
+     * @returns       The cached or fetched value
+     */
     getOrFetchValue<F extends FetchingFunction = FetchingFunction>(key: string, ttl: number, fetcher: F, lockTtl?: number, shouldCacheError?: (err: Error) => boolean): Promise<ReturnType<F>>;
+    /**
+     * Get a value from the cache.
+     *
+     * @param key   The key of the value to get.
+     *
+     * @return      The value associated with the key, or undefined if
+     *              no such value exists.
+     */
     getValue(key: string): Promise<CachableValue>;
+    /**
+     * Set a value in the cache.
+     *
+     * @param key        The key of the value to set.
+     * @param value      The value to set.
+     * @param ttl        The time to live of the value in seconds.
+     *                   By default, the value will not expire
+     *
+     * @return true if the value was stored, false otherwise.
+     */
     setValue(key: string, value: CachableValue, ttl?: number): Promise<boolean>;
+    /**
+     * Delete a value from the cache.
+     * @param key — The key of the value to set.
+     */
     delValue(key: string): Promise<void>;
+    /**
+     * Get the TTL of an entry, in ms
+     *
+     * @param key   The key of the entry whose ttl to retrieve
+     *
+     * @return      The remaining TTL on the entry, in ms.
+     *              undefined if the entry does not exist.
+     *              0 if the entry does not expire.
+     */
     getTtl(key: string): Promise<number | undefined>;
     /**
-     * Initializes a WriteThroughCache instance with the provided redis url if present, or a LocalCache otherwise.
+     * Initializes a Cache backed by the Redis instance at the provided url if present, or a LocalCache otherwise.
      *
      * @param redisUrl - The redis url to connect to (optional).
      * @returns A cache instance.

package/dist/src/resources/cache.js

@@ -1,28 +1,78 @@
 import { WriteThroughCache, LocalCache } from 'cachette';
 import * as uuid from 'uuid';
 import Logger from './logger.js';
+/**
+ * The Cache class provides caching capabilities that can be used across your integration.
+ * It can be backed by a Redis instance (by passing it a URL to the instance) or a local cache.
+ *
+ * @see {@link Cache.create}
+ */
 export class Cache {
     cacheInstance;
     constructor(cacheInstance) {
         this.cacheInstance = cacheInstance;
     }
+    /**
+     * Get or fetch a value
+     *
+     * @param key     The key of the value to get
+     * @param ttl     The time to live of the value in seconds.
+     * @param fetchFn The function that can retrieve the original value
+     * @param lockTtl Global distributed lock TTL (in seconds) protecting fetching.
+     *                If undefined, 0 or falsy, locking is not preformed
+     * @param shouldCacheError A callback being passed errors, controlling whether
+     *                         to cache or not errors. Defaults to never cache.
+     *
+     * @returns       The cached or fetched value
+     */
     getOrFetchValue(key, ttl, fetcher, lockTtl, shouldCacheError) {
         return this.cacheInstance.getOrFetchValue(key, ttl, fetcher, lockTtl, shouldCacheError);
     }
+    /**
+     * Get a value from the cache.
+     *
+     * @param key   The key of the value to get.
+     *
+     * @return      The value associated with the key, or undefined if
+     *              no such value exists.
+     */
     getValue(key) {
         return this.cacheInstance.getValue(key);
     }
+    /**
+     * Set a value in the cache.
+     *
+     * @param key        The key of the value to set.
+     * @param value      The value to set.
+     * @param ttl        The time to live of the value in seconds.
+     *                   By default, the value will not expire
+     *
+     * @return true if the value was stored, false otherwise.
+     */
     setValue(key, value, ttl) {
         return this.cacheInstance.setValue(key, value, ttl);
     }
+    /**
+     * Delete a value from the cache.
+     * @param key — The key of the value to set.
+     */
     delValue(key) {
         return this.cacheInstance.delValue(key);
     }
+    /**
+     * Get the TTL of an entry, in ms
+     *
+     * @param key   The key of the entry whose ttl to retrieve
+     *
+     * @return      The remaining TTL on the entry, in ms.
+     *              undefined if the entry does not exist.
+     *              0 if the entry does not expire.
+     */
     getTtl(key) {
         return this.cacheInstance.getTtl(key);
     }
     /**
-     * Initializes a WriteThroughCache instance with the provided redis url if present, or a LocalCache otherwise.
+     * Initializes a Cache backed by the Redis instance at the provided url if present, or a LocalCache otherwise.
      *
      * @param redisUrl - The redis url to connect to (optional).
      * @returns A cache instance.

package/dist/src/resources/context.d.ts

@@ -3,7 +3,20 @@ import Logger from './logger.js';
 import { Credentials } from '../middlewares/credentials.js';
 import { Secrets } from 'src/middlewares/secrets.js';
 import { Filter } from '../middlewares/filters.js';
-export type Context<P extends Record<string, string>, Q extends ParsedQueryString> = {
+type Maybe<T> = T | null;
+type Empty = Record<string, never>;
+type Params = Record<string, string>;
+type Query = {
+    [key: string]: undefined | string | string[] | Query | Query[];
+};
+type CreateItemBody = API.CreateItemRequestPayload;
+type UpdateItemBody = API.UpdateItemRequestPayload;
+/**
+ * The base context object is passed to every handler function.
+ *
+ * It contains the parsed request params, query string, credentials, secrets, etc.
+ */
+export type Context<P extends Maybe<Params> = Params, Q extends Maybe<Query> = Query> = {
     /**
      * The parsed credentials associated with the request through the X-Unito-Credentials header.
      *
@@ -20,6 +33,12 @@ export type Context<P extends Record<string, string>, Q extends ParsedQueryStrin
      * The logger pre decorated with the correlation ID and the additionnal metadata provided through the request headers.
      */
     logger: Logger;
+    /**
+     * Each request is expected to complete within a certain time frame. This signal object has been instantiated with the
+     * X-Unito-Operation-Deadline header. This header contains the timestamp after which Unito will consider the operation
+     * to be timed out. You can use this signal to abort any operation that would exceed this time frame.
+     */
+    signal: AbortSignal;
     /**
      * The request params.
      *
@@ -36,8 +55,19 @@ export type Context<P extends Record<string, string>, Q extends ParsedQueryStrin
      */
     query: Q;
 };
-export type GetItemContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>> = Context<P, Q>;
-export type GetCollectionContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>> = Context<P, Q> & {
+/**
+ * Context received by the `GetItemHandler`.
+ *
+ * @see {@link Context}
+ */
+export type GetItemContext<P extends Maybe<Params> = Empty, Q extends Query = Empty> = Context<P, Q>;
+/**
+ * Context received by the `GetCollectionHandler`.
+ *
+ * @filters Array of {@link Filter} representing the filterss parsed from the query params
+ * @see {@link Context} for base params
+ */
+export type GetCollectionContext<P extends Maybe<Params> = Empty, Q extends Query = Empty> = Context<P, Q> & {
     /**
      * Parsed filter query param yielding a list of filters.
      *
@@ -49,6 +79,8 @@ export type GetCollectionContext<P extends Record<string, string> = Record<strin
      *    { field: 'name', operator: 'EQUAL', values: ['John'] },
      *    { field: 'department.name', operator: 'EQUAL', values: ['Engineering'] }
      *  ]
+     *
+     * @see {@link Filter}
      */
     filters: Filter[];
     /**
@@ -62,24 +94,21 @@ export type GetCollectionContext<P extends Record<string, string> = Record<strin
      */
     selects: string[];
 };
-export type CreateItemContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>, B extends API.CreateItemRequestPayload = API.CreateItemRequestPayload> = Context<P, Q> & {
+export type CreateItemContext<P extends Maybe<Params> = Empty, Q extends Maybe<Query> = Empty, B extends CreateItemBody = API.CreateItemRequestPayload> = Context<P, Q> & {
     body: B;
 };
-export type UpdateItemContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>, B extends API.UpdateItemRequestPayload = API.UpdateItemRequestPayload> = Context<P, Q> & {
+export type UpdateItemContext<P extends Maybe<Params> = Empty, Q extends Maybe<Query> = Empty, B extends UpdateItemBody = API.UpdateItemRequestPayload> = Context<P, Q> & {
     body: B;
 };
-export type DeleteItemContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>> = Context<P, Q>;
-export type GetCredentialAccountContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>> = Context<P, Q>;
-export type ParseWebhooksContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>, B extends API.WebhookParseRequestPayload = API.WebhookParseRequestPayload> = Omit<Context<P, Q>, 'credentials'> & {
+export type DeleteItemContext<P extends Maybe<Params> = Empty, Q extends Query = Empty> = Context<P, Q>;
+export type GetCredentialAccountContext<P extends Maybe<Params> = Empty, Q extends Query = Empty> = Context<P, Q>;
+export type ParseWebhooksContext<P extends Maybe<Params> = Empty, Q extends Maybe<Query> = Empty, B extends API.WebhookParseRequestPayload = API.WebhookParseRequestPayload> = Omit<Context<P, Q>, 'credentials'> & {
     body: B;
 };
-export type UpdateWebhookSubscriptionsContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>, B extends API.WebhookSubscriptionRequestPayload = API.WebhookSubscriptionRequestPayload> = Context<P, Q> & {
+export type UpdateWebhookSubscriptionsContext<P extends Maybe<Params> = Empty, Q extends Maybe<Query> = Empty, B extends API.WebhookSubscriptionRequestPayload = API.WebhookSubscriptionRequestPayload> = Context<P, Q> & {
     body: B;
 };
-export type AcknowledgeWebhooksContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>, B extends API.WebhookParseRequestPayload = API.WebhookParseRequestPayload> = Omit<Context<P, Q>, 'credentials'> & {
+export type AcknowledgeWebhooksContext<P extends Maybe<Params> = Empty, Q extends Maybe<Query> = Empty, B extends API.WebhookParseRequestPayload = API.WebhookParseRequestPayload> = Omit<Context<P, Q>, 'credentials'> & {
     body: B;
 };
-interface ParsedQueryString {
-    [key: string]: undefined | string | string[] | ParsedQueryString | ParsedQueryString[];
-}
 export {};

package/dist/src/resources/logger.d.ts

@@ -6,6 +6,9 @@ export type Metadata = Value & {
     message?: never;
 };
 type ForbidenMetadataKey = 'message';
+/**
+ * Logger class that can be configured with metadata add creation and when logging to add additional context to your logs.
+ */
 export default class Logger {
     private metadata;
     constructor(metadata?: Metadata);
@@ -44,8 +47,22 @@ export default class Logger {
      * @param metadata Additional metadata to be added to the logger.
      */
     decorate(metadata: Metadata): void;
+    /**
+     * Return a copy of the Logger's metadata.
+     * @returns The  {@link Metadata} associated with the logger.
+     */
     getMetadata(): Metadata;
+    /**
+     * Sets a key-value pair in the metadata. If the key already exists, it will be overwritten.
+     *
+     * @param key Key of the metadata to be set.
+     * May be any string other than 'message', which is reserved for the actual message logged.
+     * @param value Value of the metadata to be set.
+     */
     setMetadata<Key extends string>(key: Key extends ForbidenMetadataKey ? never : Key, value: PrimitiveValue | Value): void;
+    /**
+     * Clears the Logger's metadata.
+     */
     clearMetadata(): void;
     private send;
     private snakifyKeys;

package/dist/src/resources/logger.js

@@ -6,6 +6,9 @@ var LogLevel;
     LogLevel["LOG"] = "log";
     LogLevel["DEBUG"] = "debug";
 })(LogLevel || (LogLevel = {}));
+/**
+ * Logger class that can be configured with metadata add creation and when logging to add additional context to your logs.
+ */
 export default class Logger {
     metadata;
     constructor(metadata = {}) {
@@ -58,12 +61,26 @@ export default class Logger {
     decorate(metadata) {
         this.metadata = { ...this.metadata, ...metadata };
     }
+    /**
+     * Return a copy of the Logger's metadata.
+     * @returns The  {@link Metadata} associated with the logger.
+     */
     getMetadata() {
         return structuredClone(this.metadata);
     }
+    /**
+     * Sets a key-value pair in the metadata. If the key already exists, it will be overwritten.
+     *
+     * @param key Key of the metadata to be set.
+     * May be any string other than 'message', which is reserved for the actual message logged.
+     * @param value Value of the metadata to be set.
+     */
     setMetadata(key, value) {
         this.metadata[key] = value;
     }
+    /**
+     * Clears the Logger's metadata.
+     */
     clearMetadata() {
         this.metadata = {};
     }

package/dist/src/resources/provider.d.ts

@@ -20,21 +20,48 @@ export type RateLimiter = <T>(options: {
     credentials: Credentials;
     logger: Logger;
 }, targetFunction: () => Promise<Response<T>>) => Promise<Response<T>>;
-export interface RequestOptions {
+/**
+ * RequestOptions are the options passed to the Provider's call.
+ *
+ * @property credentials - The credentials to use for the call.
+ * @property logger - The logger to use during the call.
+ * @property queryParams - The query parameters to add when calling the provider.
+ * @property additionnalheaders - The headers to add when calling the provider.
+ */
+export type RequestOptions = {
     credentials: Credentials;
     logger: Logger;
+    signal: AbortSignal;
     queryParams?: {
         [key: string]: string;
     };
     additionnalheaders?: {
         [key: string]: string;
     };
-}
-export interface Response<T> {
+};
+/**
+ * Response object returned by the Provider's method.
+ *
+ * Contains;
+ * - the body typed as specified when calling the method
+ * - the status code of the response
+ * - the headers of the response.
+ */
+export type Response<T> = {
     body: T;
     status: number;
     headers: Headers;
-}
+};
+/**
+ * The Provider class is a wrapper around the fetch function to call a provider's HTTP API.
+ *
+ * Defines methods for the following HTTP methods: GET, POST, PUT, PATCH, DELETE.
+ *
+ * Needs to be initialized with a prepareRequest function to define the Provider's base URL and any specific headers to
+ * add to the requests, and can also be configured to use a provided rate limiting function.
+ * @see {@link RateLimiter}
+ * @see {@link prepareRequest}
+ */
 export declare class Provider {
     protected rateLimiter: RateLimiter | undefined;
     protected prepareRequest: (options: {
@@ -45,7 +72,7 @@ export declare class Provider {
         headers: Record<string, string>;
     };
     /**
-     * Initialize a Provider with the given options.
+     * Initializes a Provider with the given options.
      *
      * @property prepareRequest - function to define the Provider's base URL and specific headers to add to the request.
      * @property rateLimiter - function to limit the rate of calls to the provider based on the caller's credentials.
@@ -54,10 +81,68 @@ export declare class Provider {
         prepareRequest: typeof Provider.prototype.prepareRequest;
         rateLimiter?: RateLimiter;
     });
+    /**
+     * Performs a GET request to the provider.
+     *
+     * Uses the prepareRequest function to get the base URL and any specific headers to add to the request and by default
+     * adds the following headers:
+     * - Accept: application/json
+     *
+     * @param endpoint Path to the provider's resource. Will be added to the URL returned by the prepareRequest function.
+     * @param options RequestOptions used to adjust the call made to the provider (use to override default headers).
+     * @returns The {@link Response} extracted from the provider.
+     */
     get<T>(endpoint: string, options: RequestOptions): Promise<Response<T>>;
+    /**
+     * Performs a POST request to the provider.
+     *
+     * Uses the prepareRequest function to get the base URL and any specific headers to add to the request and by default
+     * adds the following headers:
+     * - Content-Type: application/json',
+     * - Accept: application/json
+     *
+     * @param endpoint Path to the provider's resource. Will be added to the URL returned by the prepareRequest function.
+     * @param options RequestOptions used to adjust the call made to the provider (use to override default headers).
+     * @returns The {@link Response} extracted from the provider.
+     */
     post<T>(endpoint: string, body: Record<string, unknown>, options: RequestOptions): Promise<Response<T>>;
+    /**
+     * Performs a PUT request to the provider.
+     *
+     * Uses the prepareRequest function to get the base URL and any specific headers to add to the request and by default
+     * adds the following headers:
+     * - Content-Type: application/json',
+     * - Accept: application/json
+     *
+     * @param endpoint Path to the provider's resource. Will be added to the URL returned by the prepareRequest function.
+     * @param options RequestOptions used to adjust the call made to the provider (use to override default headers).
+     * @returns The {@link Response} extracted from the provider.
+     */
     put<T>(endpoint: string, body: Record<string, unknown>, options: RequestOptions): Promise<Response<T>>;
+    /**
+     * Performs a PATCH request to the provider.
+     *
+     * Uses the prepareRequest function to get the base URL and any specific headers to add to the request and by default
+     * adds the following headers:
+     * - Content-Type: application/json',
+     * - Accept: application/json
+     *
+     * @param endpoint Path to the provider's resource. Will be added to the URL returned by the prepareRequest function.
+     * @param options RequestOptions used to adjust the call made to the provider (use to override default headers).
+     * @returns The {@link Response} extracted from the provider.
+     */
     patch<T>(endpoint: string, body: Record<string, unknown>, options: RequestOptions): Promise<Response<T>>;
+    /**
+     * Performs a DELETE request to the provider.
+     *
+     * Uses the prepareRequest function to get the base URL and any specific headers to add to the request and by default
+     * adds the following headers:
+     * - Accept: application/json
+     *
+     * @param endpoint Path to the provider's resource. Will be added to the URL returned by the prepareRequest function.
+     * @param options RequestOptions used to adjust the call made to the provider (use to override default headers).
+     * @returns The {@link Response} extracted from the provider.
+     */
     delete<T = undefined>(endpoint: string, options: RequestOptions): Promise<Response<T>>;
     private fetchWrapper;
 }