@okta/auth-foundation 0.6.0

package/dist/types/types/openid.d.ts

@@ -0,0 +1,320 @@
+/**
+ * @module
+ * @mergeModuleWith OAuth2
+ */
+/**
+ * Interface defining the response payload from `/.well-known/openid-configuration`
+ */
+export interface OpenIdConfiguration {
+    /**
+     * Authorization server's Issuer Identifier URL.
+     */
+    readonly issuer: string;
+    /**
+     * URL of the authorization server's authorization endpoint.
+     */
+    readonly authorization_endpoint?: string;
+    /**
+     * URL of the authorization server's token endpoint.
+     */
+    readonly token_endpoint?: string;
+    /**
+     * URL of the authorization server's JWK Set document.
+     */
+    readonly jwks_uri?: string;
+    /**
+     * URL of the authorization server's Dynamic Client Registration Endpoint.
+     */
+    readonly registration_endpoint?: string;
+    /**
+     * JSON array containing a list of the `scope` values that this authorization server supports.
+     */
+    readonly scopes_supported?: string[];
+    /**
+     * JSON array containing a list of the `response_type` values that this authorization server
+     * supports.
+     */
+    readonly response_types_supported?: string[];
+    /**
+     * JSON array containing a list of the `response_mode` values that this authorization server
+     * supports.
+     */
+    readonly response_modes_supported?: string[];
+    /**
+     * JSON array containing a list of the `grant_type` values that this authorization server
+     * supports.
+     */
+    readonly grant_types_supported?: string[];
+    /**
+     * JSON array containing a list of client authentication methods supported by this token endpoint.
+     */
+    readonly token_endpoint_auth_methods_supported?: string[];
+    /**
+     * JSON array containing a list of the JWS signing algorithms supported by the token endpoint for
+     * the signature on the JWT used to authenticate the client at the token endpoint.
+     */
+    readonly token_endpoint_auth_signing_alg_values_supported?: string[];
+    /**
+     * URL of a page containing human-readable information that developers might want or need to know
+     * when using the authorization server.
+     */
+    readonly service_documentation?: string;
+    /**
+     * Languages and scripts supported for the user interface, represented as a JSON array of language
+     * tag values from RFC 5646.
+     */
+    readonly ui_locales_supported?: string[];
+    /**
+     * URL that the authorization server provides to the person registering the client to read about
+     * the authorization server's requirements on how the client can use the data provided by the
+     * authorization server.
+     */
+    readonly op_policy_uri?: string;
+    /**
+     * URL that the authorization server provides to the person registering the client to read about
+     * the authorization server's terms of service.
+     */
+    readonly op_tos_uri?: string;
+    /**
+     * URL of the authorization server's revocation endpoint.
+     */
+    readonly revocation_endpoint?: string;
+    /**
+     * JSON array containing a list of client authentication methods supported by this revocation
+     * endpoint.
+     */
+    readonly revocation_endpoint_auth_methods_supported?: string[];
+    /**
+     * JSON array containing a list of the JWS signing algorithms supported by the revocation endpoint
+     * for the signature on the JWT used to authenticate the client at the revocation endpoint.
+     */
+    readonly revocation_endpoint_auth_signing_alg_values_supported?: string[];
+    /**
+     * URL of the authorization server's introspection endpoint.
+     */
+    readonly introspection_endpoint?: string;
+    /**
+     * JSON array containing a list of client authentication methods supported by this introspection
+     * endpoint.
+     */
+    readonly introspection_endpoint_auth_methods_supported?: string[];
+    /**
+     * JSON array containing a list of the JWS signing algorithms supported by the introspection
+     * endpoint for the signature on the JWT used to authenticate the client at the introspection
+     * endpoint.
+     */
+    readonly introspection_endpoint_auth_signing_alg_values_supported?: string[];
+    /**
+     * PKCE code challenge methods supported by this authorization server.
+     */
+    readonly code_challenge_methods_supported?: string[];
+    /**
+     * Signed JWT containing metadata values about the authorization server as claims.
+     */
+    readonly signed_metadata?: string;
+    /**
+     * URL of the authorization server's device authorization endpoint.
+     */
+    readonly device_authorization_endpoint?: string;
+    /**
+     * Indicates authorization server support for mutual-TLS client certificate-bound access tokens.
+     */
+    readonly tls_client_certificate_bound_access_tokens?: boolean;
+    /**
+     * JSON object containing alternative authorization server endpoints, which a client intending to
+     * do mutual TLS will use in preference to the conventional endpoints.
+     */
+    /**
+     * URL of the authorization server's UserInfo Endpoint.
+     */
+    readonly userinfo_endpoint?: string;
+    /**
+     * JSON array containing a list of the Authentication Context Class References that this
+     * authorization server supports.
+     */
+    readonly acr_values_supported?: string[];
+    /**
+     * JSON array containing a list of the Subject Identifier types that this authorization server
+     * supports.
+     */
+    readonly subject_types_supported?: string[];
+    /**
+     * JSON array containing a list of the JWS `alg` values supported by the authorization server for
+     * the ID Token.
+     */
+    readonly id_token_signing_alg_values_supported?: string[];
+    /**
+     * JSON array containing a list of the JWE `alg` values supported by the authorization server for
+     * the ID Token.
+     */
+    readonly id_token_encryption_alg_values_supported?: string[];
+    /**
+     * JSON array containing a list of the JWE `enc` values supported by the authorization server for
+     * the ID Token.
+     */
+    readonly id_token_encryption_enc_values_supported?: string[];
+    /**
+     * JSON array containing a list of the JWS `alg` values supported by the UserInfo Endpoint.
+     */
+    readonly userinfo_signing_alg_values_supported?: string[];
+    /**
+     * JSON array containing a list of the JWE `alg` values supported by the UserInfo Endpoint.
+     */
+    readonly userinfo_encryption_alg_values_supported?: string[];
+    /**
+     * JSON array containing a list of the JWE `enc` values supported by the UserInfo Endpoint.
+     */
+    readonly userinfo_encryption_enc_values_supported?: string[];
+    /**
+     * JSON array containing a list of the JWS `alg` values supported by the authorization server for
+     * Request Objects.
+     */
+    readonly request_object_signing_alg_values_supported?: string[];
+    /**
+     * JSON array containing a list of the JWE `alg` values supported by the authorization server for
+     * Request Objects.
+     */
+    readonly request_object_encryption_alg_values_supported?: string[];
+    /**
+     * JSON array containing a list of the JWE `enc` values supported by the authorization server for
+     * Request Objects.
+     */
+    readonly request_object_encryption_enc_values_supported?: string[];
+    /**
+     * JSON array containing a list of the `display` parameter values that the authorization server
+     * supports.
+     */
+    readonly display_values_supported?: string[];
+    /**
+     * JSON array containing a list of the Claim Types that the authorization server supports.
+     */
+    readonly claim_types_supported?: string[];
+    /**
+     * JSON array containing a list of the Claim Names of the Claims that the authorization server MAY
+     * be able to supply values for.
+     */
+    readonly claims_supported?: string[];
+    /**
+     * Languages and scripts supported for values in Claims being returned, represented as a JSON
+     * array of RFC 5646 language tag values.
+     */
+    readonly claims_locales_supported?: string[];
+    /**
+     * Boolean value specifying whether the authorization server supports use of the `claims`
+     * parameter.
+     */
+    readonly claims_parameter_supported?: boolean;
+    /**
+     * Boolean value specifying whether the authorization server supports use of the `request`
+     * parameter.
+     */
+    readonly request_parameter_supported?: boolean;
+    /**
+     * Boolean value specifying whether the authorization server supports use of the `request_uri`
+     * parameter.
+     */
+    readonly request_uri_parameter_supported?: boolean;
+    /**
+     * Boolean value specifying whether the authorization server requires any `request_uri` values
+     * used to be pre-registered.
+     */
+    readonly require_request_uri_registration?: boolean;
+    /**
+     * Indicates where authorization request needs to be protected as Request Object and provided
+     * through either `request` or `request_uri` parameter.
+     */
+    readonly require_signed_request_object?: boolean;
+    /**
+     * URL of the authorization server's pushed authorization request endpoint.
+     */
+    readonly pushed_authorization_request_endpoint?: string;
+    /**
+     * Indicates whether the authorization server accepts authorization requests only via PAR.
+     */
+    readonly require_pushed_authorization_requests?: boolean;
+    /**
+     * JSON array containing a list of algorithms supported by the authorization server for
+     * introspection response signing.
+     */
+    readonly introspection_signing_alg_values_supported?: string[];
+    /**
+     * JSON array containing a list of algorithms supported by the authorization server for
+     * introspection response content key encryption (`alg` value).
+     */
+    readonly introspection_encryption_alg_values_supported?: string[];
+    /**
+     * JSON array containing a list of algorithms supported by the authorization server for
+     * introspection response content encryption (`enc` value).
+     */
+    readonly introspection_encryption_enc_values_supported?: string[];
+    /**
+     * Boolean value indicating whether the authorization server provides the `iss` parameter in the
+     * authorization response.
+     */
+    readonly authorization_response_iss_parameter_supported?: boolean;
+    /**
+     * JSON array containing a list of algorithms supported by the authorization server for
+     * introspection response signing.
+     */
+    readonly authorization_signing_alg_values_supported?: string[];
+    /**
+     * JSON array containing a list of algorithms supported by the authorization server for
+     * introspection response encryption (`alg` value).
+     */
+    readonly authorization_encryption_alg_values_supported?: string[];
+    /**
+     * JSON array containing a list of algorithms supported by the authorization server for
+     * introspection response encryption (`enc` value).
+     */
+    readonly authorization_encryption_enc_values_supported?: string[];
+    /**
+     * CIBA Backchannel Authentication Endpoint.
+     */
+    readonly backchannel_authentication_endpoint?: string;
+    /**
+     * JSON array containing a list of the JWS signing algorithms supported for validation of signed
+     * CIBA authentication requests.
+     */
+    readonly backchannel_authentication_request_signing_alg_values_supported?: string[];
+    /**
+     * Supported CIBA authentication result delivery modes.
+     */
+    readonly backchannel_token_delivery_modes_supported?: string[];
+    /**
+     * Indicates whether the authorization server supports the use of the CIBA `user_code` parameter.
+     */
+    readonly backchannel_user_code_parameter_supported?: boolean;
+    /**
+     * URL of an authorization server iframe that supports cross-origin communications for session
+     * state information with the RP Client, using the HTML5 postMessage API.
+     */
+    readonly check_session_iframe?: string;
+    /**
+     * JSON array containing a list of the JWS algorithms supported for DPoP proof JWTs.
+     */
+    readonly dpop_signing_alg_values_supported?: string[];
+    /**
+     * URL at the authorization server to which an RP can perform a redirect to request that the
+     * End-User be logged out at the authorization server.
+     */
+    readonly end_session_endpoint?: string;
+    /**
+     * Boolean value specifying whether the authorization server can pass `iss` (issuer) and `sid`
+     * (session ID) query parameters to identify the RP session with the authorization server when the
+     * `frontchannel_logout_uri` is used.
+     */
+    readonly frontchannel_logout_session_supported?: boolean;
+    /**
+     * Boolean value specifying whether the authorization server supports HTTP-based logout.
+     */
+    readonly frontchannel_logout_supported?: boolean;
+    /**
+     * Boolean value specifying whether the authorization server can pass a `sid` (session ID) Claim
+     * in the Logout Token to identify the RP session with the OP.
+     */
+    readonly backchannel_logout_session_supported?: boolean;
+    /**
+     * Boolean value specifying whether the authorization server supports back-channel logout.
+     */
+    readonly backchannel_logout_supported?: boolean;
+}

package/dist/types/utils/EventEmitter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @module
+ * @mergeModuleWith Core
+ */
+type EventMap = {
+    [event: string]: any;
+};
+type EventListener<T> = T extends void ? () => void : (event: T) => void;
+/**
+ * @group EventEmitter
+ */
+export interface Emitter<E extends EventMap> {
+    on: (...args: Parameters<EventEmitter<E>['on']>) => void;
+    off: (...args: Parameters<EventEmitter<E>['off']>) => void;
+}
+/**
+ * @group EventEmitter
+ */
+export declare class EventEmitter<Events extends EventMap> {
+    listeners: {
+        [K in keyof Events]?: Array<EventListener<Events[K]>>;
+    };
+    on<K extends keyof Events>(eventName: K, handler: EventListener<Events[K]>): this;
+    off<K extends keyof Events>(eventName: K, handler?: EventListener<Events[K]>): this;
+    emit<K extends keyof Events>(eventName: K, data: Events[K]): void;
+    emit<K extends keyof Events>(eventName: K): void;
+    relay<FromEvents extends EventMap, K extends keyof Events & keyof FromEvents = keyof Events & keyof FromEvents>(emitter: EventEmitter<FromEvents>, events: K[]): void;
+}
+export {};

package/dist/types/utils/PromiseQueue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+type QueueItem = {
+    method: () => Promise<unknown>;
+    resolve: (value?: any) => void;
+    reject: (reason?: unknown) => void;
+};
+/** @internal */
+export declare class PromiseQueue {
+    queue: QueueItem[];
+    isRunning: boolean;
+    get size(): number;
+    push<T>(method: () => Promise<T>): Promise<T>;
+    private run;
+}
+export {};

package/dist/types/utils/TaskBridge.d.ts

@@ -0,0 +1,153 @@
+import type { BroadcastChannelLike } from '../types/index.ts';
+import { AuthSdkError } from '../errors/AuthSdkError.ts';
+/** @useDeclaredType */
+type TypeMap = Record<string, any>;
+/**
+ * A bridge for passing messages between a `TaskHandler` and a `Requestor`. The `Requestor` is "asking" the `TaskHandler`
+ * To perform a `Task` on it's behave. Loosely based on TCP
+ *
+ * When a `TaskRequest` is received, a separate {@link TaskBridge.TaskChannel} is created between the `Handler` and
+ * the `Requestor` to communicate the status of the specific `Task`. Once the `Task` has completed the response will
+ * be sent to the `Requestor` via the {@link TaskBridge.TaskChannel} and the channel will be closed.
+ *
+ * The `TaskHandler` will broadcast a heartbeat, indicating it's still alive, to all pending {@link TaskBridge.TaskChannel}s.
+ * If a `Requestor` does not receive a response or heartbeat within a `timeout` interval, a Timeout error is thrown
+ *
+ * @typeParam M - A TypeMap of message payload structure for `TaskRequests`
+ * @typeParam R - A TypeMap of message payload structure for `TaskReponses`
+ */
+export declare abstract class TaskBridge<M extends TypeMap, R extends TypeMap> {
+    #private;
+    name: string;
+    heartbeatInterval: number;
+    constructor(name: string);
+    /**
+     * A "public" channel opened on a known key (`this.name`) to send/receive task requests
+     *
+     * @remarks
+     * This has been written with an assumption there is one only {@link TaskBridge} listening on
+     * this public channel and responding to messages. There is currently no "message handling arbitartion"
+     */
+    protected abstract createBridgeChannel(): TaskBridge.BridgeChannel<M[keyof M]>;
+    protected abstract createTaskChannel<K extends keyof M & keyof R>(name: string): TaskBridge.TaskChannel<R[K]>;
+    protected onTick(): void;
+    protected pushMessage(message: TaskBridge.Task<any, any>): void;
+    protected clearMessage(messageId: string): void;
+    send<K extends keyof M & keyof R>(message: M[K], options?: TaskBridge.TaskOptions): TaskBridge.TaskResponse<R[K]>;
+    subscribe<K extends keyof M & keyof R>(handler: TaskBridge.TaskHandler<M, R>): void;
+    /**
+     * Returns the number of pending tasks
+     */
+    get pending(): number;
+    close(): void;
+}
+export declare namespace TaskBridge {
+    const BridgeVersion = 2;
+    /**
+     * Possible `status` values indicating the process of an orchestrated request
+     */
+    type TaskStatus = 'PENDING' | 'SUCCESS' | 'FAILED' | 'ABORTED';
+    type BridgeVersions = 1 | 2;
+    /**
+     * The payload of a message sent from Subscriber to Requestor, indicating the process or result of a request
+     */
+    type HandlerMessage<M extends TypeMap> = {
+        status: 'SUCCESS';
+        data: M;
+        __v: BridgeVersions;
+    } | {
+        status: 'FAILED';
+        data: M;
+        __v: BridgeVersions;
+    } | {
+        status: 'PENDING';
+        __v: BridgeVersions;
+    } | {
+        status: 'ABORTED';
+        __v: BridgeVersions;
+    };
+    /**
+     * The payload of a message sent from Requestor to Subscriber to alter the outcome of a request (`CANCEL` for example)
+     */
+    type RequestorMessage = {
+        action: string;
+    };
+    /**
+     * A channel with the purpose of receiving a request from a Requestor
+     */
+    type BridgeChannel<M extends TypeMap> = BroadcastChannelLike<M & {
+        requestId: string;
+        __v: BridgeVersions;
+    }>;
+    /**
+     * A channel created to communicate the results of a pending request (will be isolated to specific Subscriber and Requestor)
+     */
+    type TaskChannel<M extends TypeMap> = BroadcastChannelLike<(RequestorMessage | HandlerMessage<M>) & {
+        __v: BridgeVersions;
+    }>;
+    /**
+     * @internal
+     *
+     * @typeParam Q - re(Q)uest event payload
+     * @typeParam S - re(S)ponse event payload
+     */
+    type TaskInit<Q extends TypeMap, S extends TypeMap> = {
+        __v: BridgeVersions;
+        id: string;
+        message: Q;
+        channel: TaskChannel<S>;
+        reply?: (response: any) => void;
+    };
+    /**
+     * @internal
+     *
+     * @typeParam Q - re(Q)uest event payload
+     * @typeParam S - re(S)ponse event payload
+     */
+    class Task<Q extends TypeMap, S extends TypeMap> {
+        __v: TaskInit<Q, S>['__v'];
+        id: TaskInit<Q, S>['id'];
+        message: TaskInit<Q, S>['message'];
+        channel: TaskInit<Q, S>['channel'];
+        private replyFn;
+        controller: AbortController;
+        constructor({ id, message, channel, __v, reply }: TaskInit<Q, S>);
+        send(): {
+            requestId: string;
+            __v: BridgeVersions;
+        } & Q;
+        reply(data: S, status: TaskBridge.TaskStatus): void;
+        reply(status: 'PENDING' | 'ABORTED'): void;
+        abort(...args: Parameters<AbortController['abort']>): void;
+        get signal(): AbortSignal;
+    }
+    /**
+     * @internal
+     */
+    type TaskOptions = {
+        timeout?: number | null;
+        signal?: AbortSignal;
+    };
+    /**
+     * @internal
+     */
+    type TaskResponse<R extends TypeMap> = {
+        result: Promise<R>;
+        abort: () => void;
+    };
+    /**
+     * @internal
+     */
+    type TaskHandler<M extends TypeMap, R extends TypeMap> = (message: M[keyof M], reply: (response: R[keyof R]) => any, options?: {
+        signal: AbortSignal;
+    }) => any;
+    /**
+     * @group Errors
+     */
+    class TimeoutError extends AuthSdkError {
+        #private;
+        constructor(...args: ConstructorParameters<typeof AuthSdkError>);
+        get timeout(): boolean;
+    }
+}
+export {};

package/dist/types/utils/TimeCoordinator.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @module
+ * @mergeModuleWith Core
+ */
+import type { EpochTimestamp, Seconds } from '../types/index.ts';
+/**
+ * Utility class for parse timestamps and performing time/date calculations
+ *
+ * @group TimeCoordinator
+ */
+export declare class Timestamp {
+    private ts;
+    constructor(ts: EpochTimestamp);
+    static from(t: Timestamp): Timestamp;
+    static from(t: Date): Timestamp;
+    static from(t: EpochTimestamp): Timestamp;
+    static from(t: EpochTimestamp | Date | Timestamp): Timestamp;
+    get value(): EpochTimestamp;
+    get asDate(): Date;
+    isBefore(t: Timestamp): boolean;
+    isBefore(t: Date): boolean;
+    isBefore(t: EpochTimestamp): boolean;
+    isAfter(t: Timestamp): boolean;
+    isAfter(t: Date): boolean;
+    isAfter(t: EpochTimestamp): boolean;
+    timeSince(t: Timestamp): Seconds;
+    timeSince(t: Date): Seconds;
+    timeSince(t: EpochTimestamp): Seconds;
+    timeSinceNow(): number;
+}
+/**
+ * @group TimeCoordinator
+ */
+export interface TimeCoordinator {
+    clockSkew: Seconds;
+    clockTolerance: Seconds;
+    now: () => Timestamp;
+}
+/**
+ * @group TimeCoordinator
+ */
+export declare class DefaultTimeCoordinator implements TimeCoordinator {
+    #private;
+    get clockSkew(): Seconds;
+    set clockSkew(skew: Seconds);
+    get clockTolerance(): Seconds;
+    set clockTolerance(tolerance: Seconds);
+    now(): Timestamp;
+}

package/dist/types/utils/buildUrl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module
+ * @mergeModuleWith Core
+ */
+/**
+ * Utility function to build a URL from path segments
+ *
+ * @group Utils
+ */
+export declare function buildURL(base: URL, ...path: string[]): URL;

package/dist/types/utils/equality.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @module
+ * @mergeModuleWith Core
+ */
+/**
+ * Utility function to verify two arrays contain the same items
+ *
+ * @remarks
+ * Requires array contain unique items
+ *
+ * @group Utils
+ */
+export declare function hasSameValues<T>(a1: T[], a2: T[], strict?: boolean): boolean;
+/**
+ * Utility function to verify an object contains specific key/value pairs
+ *
+ * @group Utils
+ */
+export declare function doesPartialMatch(target: Record<string, unknown>, partial: Record<string, unknown>): boolean;

package/dist/types/utils/getSearchParam.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module
+ * @mergeModuleWith Core
+ */
+/**
+ * Extracts a query parameter from a {@link !URLSearchParams} instance. Throws when more than one value exists for given parameter
+ * (which is allowed in the URI spec, but is not practiced in OAuth2)
+ *
+ * @throws {@link NetworkError}
+ *
+ * @group Utils
+ */
+export declare function getSearchParam(parameters: URLSearchParams, name: string): string | undefined;

package/dist/types/utils/hashObject.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @internal
+ *
+ * Hashes an object into a string to be used as a key within a map
+ */
+export declare function hashObject(obj: object): Promise<string>;

package/dist/types/utils/ignoreUndefineds.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+/**
+ * @internal
+ * Removes `undefined` properties from an object (results in a new object)
+ *
+ * @remarks
+ * designed to be used in shallow spread operator merges, so undefined values don't override
+ * already defined properties (aka doesn't set the value of a key to `undefined`)
+ *
+ */
+export declare function ignoreUndefineds<T extends Record<string | number, unknown> = Record<string | number, unknown>>(target: T): T;

package/dist/types/utils/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+export * from './buildUrl.ts';
+export * from './merge.ts';
+export * from './equality.ts';
+export * from './getSearchParam.ts';
+export * from './pause.ts';
+export * from './ignoreUndefineds.ts';
+export * from './toRelativeUrl.ts';
+export * from './hashObject.ts';
+export * from './validators.ts';

package/dist/types/utils/merge.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @module
+ * @mergeModuleWith Core
+ */
+/**
+ * Merges `n` number of {@link !URLSearchParams} instances
+ *
+ * @group Utils
+ */
+export declare function mergeURLSearchParameters(target: URLSearchParams, ...source: (URLSearchParams | Record<string, string | undefined>)[]): URLSearchParams;
+/**
+ * Merges `n` number of {@link !Headers} instances
+ *
+ * @group Utils
+ */
+export declare function mergeHeaders(target: Headers, ...source: (Headers | Record<string, string | undefined>)[]): Headers;

package/dist/types/utils/pause.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module
+ * @mergeModuleWith Core
+ */
+/**
+ * Returns a {@link !Promise} which resolves after a short delay (milliseconds)
+ *
+ * @remarks
+ * Wraps {@link !setTimeout} in a {@link !Promise}
+ *
+ * @param ms - length of delay in milliseconds
+ *
+ * @group Utils
+ */
+export declare function pause(ms: number): Promise<unknown>;