@useparagon/connect 1.0.24-experimental.12 → 1.0.24-experimental.13

package/dist/src/src/types/sdk.d.ts

@@ -0,0 +1,391 @@
+import ConnectSDK from '../ConnectSDK';
+import { IConnectCredential } from '../entities/connectCredential.interface';
+import { IConnectCredentialConfig } from '../entities/connectCredentialConfig.interface';
+import { OauthCallbackResponse } from '../entities/credential.interface';
+import { IConnectIntegrationWithCredentialInfo, IIntegrationMetadata } from '../entities/integration.interface';
+import { PersonaMeta } from '../entities/persona.interface';
+import { IConnectUserContext } from '../helpers/ConnectUserContext';
+import { ConnectSdkEnvironments } from '../server.types';
+import { AuthenticatedConnectUser, DisableWorkflowOptions, DynamicMappingField, DynamicMappingOptions, GetIntegrationAccountOptions, IntegrationWorkflowState, UninstallOptions } from '../types/connect';
+import { Props as ConnectModalProps } from './connectModal';
+export type ConnectUser = {
+    authenticated: false;
+} | AuthenticatedConnectUser;
+export type FunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? K : never;
+}[keyof T];
+type NonFunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+export type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
+export type UnwrapPromise<T> = T extends PromiseLike<infer U> ? U : T;
+export type NonNullUndefinedField<T> = {
+    [P in keyof T]-?: NonNullUndefinedField<NonNullable<T[P]>>;
+};
+export type UIUpdateMessage = {
+    messageType: 'UI_UPDATE';
+    nextContext: NonFunctionProperties<IConnectUserContext>;
+    nextModalState: NonFunctionProperties<ConnectModalProps>;
+};
+export type SDKFunctionInvocationMessage<T extends FunctionPropertyNames<ConnectSDK> = never> = {
+    messageType: 'SDK_FUNCTION_INVOCATION';
+    type: T;
+    parameters: Parameters<ConnectSDK[T]>;
+    id: string;
+};
+export type SDKFunctionResponseMessage<T extends FunctionPropertyNames<ConnectSDK> = never> = {
+    messageType: 'SDK_FUNCTION_RESPONSE';
+    type: T;
+    result: UnwrapPromise<ReturnType<ConnectSDK[T]>>;
+    id: string;
+};
+export type SDKFunctionErrorMessage = {
+    messageType: 'SDK_FUNCTION_ERROR';
+    error: true;
+    message: string;
+    id: string;
+};
+export type SDKReceivedMessage = SDKFunctionInvocationMessage;
+export type InstallIntegrationOptions = Partial<Omit<InstallOptions, 'isApiInstallation'> & Omit<CallbackMap, 'onOpen' | 'onClose'>>;
+export type CompleteInstallOptions = {
+    authorizationCode: string;
+    showPortalAfterInstall?: boolean;
+    redirectUrl?: string;
+    integrationOptions?: {
+        installOptions?: InstallOptions & {
+            [key in string]: unknown;
+        };
+    };
+};
+export type LoadCustomDropdownOptionsResult = Promise<{
+    options: {
+        label: string;
+        value: string;
+    }[];
+    nextPageCursor: string | null;
+}>;
+export interface IConnectSDK {
+    authenticate(projectId: string, token: string, options?: AuthenticateOptions): Promise<void>;
+    connect(action: string, options: ConnectParams): void;
+    getUser(): ConnectUser;
+    /**
+     * **Do not call this function directly.**
+     *
+     * Invoked by the OAuth popup after finishing the credential exchange.
+     * @private
+     */
+    _oauthCallback(credential: OauthCallbackResponse, credentialId?: string): Promise<void>;
+    /**
+     * **Do not call this function directly.**
+     *
+     * Invoked by the OAuth popup on an error encountered during the credential exchange.
+     * @private
+     */
+    _oauthErrorCallback(errorMessage: string, event?: MessageEvent): Promise<void>;
+    /**
+     * TODO(UI/UX): Document this
+     * TODO(UI/UX): Create type
+     * Destroys an existing configuration using the provided instance ID.
+     *
+     * @param {string} cursor - An object containing the necessary parameters.
+     * @returns {Promise<void>} - A promise that resolves when the configuration is successfully destroyed.
+     */
+    _loadCustomDropdownOptions(key: string, cursor?: string | undefined, search?: string | undefined): LoadCustomDropdownOptionsResult;
+    /**
+     * installs an integration without the need to click on enable button from portal
+     * Install Options:
+     * `{showPortalAfterInstall: boolean}` decides wether to show portal with configuration view after the installation is completed
+     */
+    installIntegration(name: string, options: InstallIntegrationOptions): Promise<void | IntegrationInstallEvent>;
+    /**
+     * uninstalls an integration for connected user.
+     */
+    uninstallIntegration(name: string, options: UninstallOptions): Promise<void>;
+    /**
+     * disables a workflow for the connected user and unsubscribes all the workflows in hermes
+     */
+    disableWorkflow(workflowId: string, options: DisableWorkflowOptions): Promise<void>;
+    /**
+     * enables a workflow for the connected user and subscribe the workflows in hermes
+     */
+    enableWorkflow(workflowId: string, options: CredentialConfigOptions): Promise<void>;
+    setUserMetadata(meta: PersonaMeta): Promise<AuthenticatedConnectUser>;
+    /**
+     * sets the base url for different services used in connect sdk
+     */
+    configureGlobal(options: {
+        host: string;
+    }, overrideEnvs?: Partial<ConnectSdkEnvironments>): void;
+    /**
+     * returns metadata for given integration
+     * @param integrationName integration name
+     */
+    getIntegrationMetadata(): IIntegrationMetadata[];
+    getIntegrationMetadata(integrationKey: string): IIntegrationMetadata;
+    getIntegrationMetadata(integrationKey?: string): IIntegrationMetadata | IIntegrationMetadata[];
+    /**
+     * triggers all workflows for event
+     * @param name eventName
+     * @param payload event payload object
+     */
+    event(name: string, payload: Record<string, unknown>, options?: CredentialConfigOptions): Promise<void>;
+    /**
+     * makes an connect proxy action request
+     * @param action actionName
+     * @param path request path
+     * @param init request initialization options {method: httpMethod, body:RequestBody, header}
+     */
+    request<TResponse>(action: string, path: string, init: {
+        method: RequestInit['method'];
+        body: RequestInit['body'] | object;
+        headers: RequestInit['headers'];
+    }): Promise<TResponse | undefined>;
+    /**
+     * listen on connect sdk events
+     * @param eventName SDKEVENTS
+     * @param listener
+     */
+    subscribe(eventName: SDK_EVENT, listener: ListenerFunction): () => boolean;
+    /**
+     * remove listeners on connect sdk events
+     * @param eventName SDKEVENTS
+     * @param listener
+     */
+    unsubscribe(eventName: SDK_EVENT, listener: ListenerFunction): boolean;
+    /**
+     * trigger connect endpoint trigger workflow
+     * @param workflowId
+     * @param triggerWorkflowRequest
+     */
+    workflow(workflowId: string, triggerWorkflowRequest: TriggerWorkflowRequest): Promise<object | undefined>;
+    /**
+     * completes installation using authorizationCode of actions e.g. "pipedrive"
+     * @param action
+     * @param options
+     */
+    completeInstall(action: string, options: CompleteInstallOptions): Promise<void>;
+    /**
+     * Get account details by integration type. To get accountAuth, includeAccountAuth should be true in options.
+     * Note that accountAuth is allowed for only some of the integrations.
+     * @param integrationType
+     * @param options
+     */
+    getIntegrationAccount(integrationType: string, options: GetIntegrationAccountOptions): Promise<IConnectIntegrationWithCredentialInfo>;
+    /**
+     * Connects to a resource using the provided credentials payload.
+     * @param resourceSlug
+     * @param payload
+     */
+    connectAction(resourceName: string, payload: Record<string, unknown>): Promise<IConnectCredential>;
+    /**
+     * Closing the portal by invoking this method
+     */
+    closePortal(): void;
+    /**
+     * Creates a new configuration using the provided credentials.
+     *
+     * @param {CreateConfigurationOptions} params - An object containing the necessary parameters.
+     * @param {string} params.credentialId - The ID of the credential to create the configuration for.
+     * @param {string} params.externalId - (Optional) An external identifier associated with the configuration.
+     * @returns {Promise<ICreateConfiguration>} - A promise that resolves to the created configuration object.
+     */
+    createConfiguration(params: CreateConfigurationOptions): Promise<IConnectCredentialConfig>;
+    /**
+     * Destroys an existing configuration using the provided instance ID.
+     *
+     * @param {DestroyConfigurationParams} params - An object containing the necessary parameters.
+     * @param {string} params.id - The ID of the configuration to be destroyed.
+     * @returns {Promise<void>} - A promise that resolves when the configuration is successfully destroyed.
+     */
+    destroyConfiguration(params: {
+        id: string;
+    }): Promise<void>;
+    updateConfiguration(dto: UpdateConfigurationOptions): Promise<IConnectCredentialConfig>;
+}
+/**
+ * sdk install options
+ */
+export type InstallOptions = {
+    /**
+     * api only install or ui install
+     */
+    isApiInstallation?: boolean;
+    /**
+     * if true show portal when install with api install option
+     */
+    showPortalAfterInstall?: boolean;
+    /**
+     * not show post oauth promt if this is true
+     */
+    bypassPostOAuthPrompt?: boolean;
+    /**
+     * skips account type selection
+     */
+    accountType?: string;
+    allowMultipleCredentials?: boolean;
+    /**
+     * used to override redirect url passed in getAuthUrl instead of our passport url
+     */
+    overrideRedirectUrl?: string;
+};
+export type CredentialConfigOptions = {
+    selectedCredentialId?: string;
+    selectedConfigurationId?: string;
+};
+export type CreateConfigurationOptions = {
+    credentialId: string;
+    externalId?: string;
+};
+export type DeleteConfigurationOptions = {
+    id: string;
+    credentialId: string;
+};
+export type UpdateConfigurationOptions = {
+    id: string;
+    credentialId: string;
+    meta: Record<string, unknown>;
+};
+export type AuthenticateOptions = {
+    metadata?: PersonaMeta;
+};
+/**
+ * Connect Modal Tabs
+ */
+export declare enum ModalView {
+    OVERVIEW = "overview",
+    CONFIGURATION = "configuration"
+}
+export type IntegrationInstallEvent = {
+    integrationId: string;
+    integrationType: string;
+    credentialId?: string;
+    credential?: IConnectCredential | undefined;
+};
+export type IntegrationUninstallEvent = IntegrationInstallEvent;
+export type WorkflowStateChangeEvent = {
+    integrationId: string;
+    workflowId: string;
+    workflowStateChange: Partial<IntegrationWorkflowState>;
+};
+export type PortalOpenEvent = {
+    integrationId: string;
+    integrationType: string;
+};
+export type PortalCloseEvent = PortalOpenEvent;
+export type CallbackMap = {
+    onSuccess?: (event: IntegrationInstallEvent, user: AuthenticatedConnectUser) => void;
+    onInstall?: (event: IntegrationInstallEvent, user: AuthenticatedConnectUser) => void;
+    onError?: (err: Error) => void;
+    onUninstall?: (event: IntegrationUninstallEvent, user: AuthenticatedConnectUser) => void;
+    onWorkflowChange?: (event: WorkflowStateChangeEvent, user: AuthenticatedConnectUser) => void;
+    onOpen?: (event: PortalOpenEvent, user: AuthenticatedConnectUser) => void;
+    onClose?: (event: PortalCloseEvent, user: AuthenticatedConnectUser) => void;
+};
+export type UserProvidedIntegrationConfig = {
+    /**
+     * used to override redirect url passed in getAuthUrl instead of our passport url
+     */
+    overrideRedirectUrl?: string;
+    /**
+     * This will allow users to provide dynamic fields options for object mapping inputs
+     */
+    mapObjectFields?: {
+        [objectName: string]: DynamicMappingField[] | DynamicMappingOptions;
+    };
+};
+export type ConnectParams = CallbackMap & UserProvidedIntegrationConfig & InstallOptions & CredentialConfigOptions;
+export type EventInfo = {
+    type: SDK_EVENT;
+    integrationId: string;
+    integrationType: string;
+    workflowId?: string;
+    workflowStateChange?: Partial<IntegrationWorkflowState>;
+};
+export declare enum SDK_EVENT {
+    ON_INTEGRATION_INSTALL = "onIntegrationInstall",
+    ON_INTEGRATION_UNINSTALL = "onIntegrationUninstall",
+    ON_WORKFLOW_CHANGE = "onWorkflowChange",
+    ON_PORTAL_OPEN = "onPortalOpen",
+    ON_PORTAL_CLOSE = "onPortalClose"
+}
+export type SDKEventListenerMap = {
+    [SDK_EVENT.ON_INTEGRATION_INSTALL]: Array<(event: IntegrationInstallEvent, user: AuthenticatedConnectUser) => void>;
+    [SDK_EVENT.ON_INTEGRATION_UNINSTALL]: Array<(event: IntegrationUninstallEvent, user: AuthenticatedConnectUser) => void>;
+    [SDK_EVENT.ON_PORTAL_CLOSE]: Array<(event: PortalCloseEvent, user: AuthenticatedConnectUser) => void>;
+    [SDK_EVENT.ON_PORTAL_OPEN]: Array<(event: PortalOpenEvent, user: AuthenticatedConnectUser) => void>;
+    [SDK_EVENT.ON_WORKFLOW_CHANGE]: Array<(event: WorkflowStateChangeEvent, user: AuthenticatedConnectUser) => void>;
+};
+export type ListenerFunction = SDKEventListenerMap[keyof SDKEventListenerMap][number];
+export declare enum DocumentLoadingState {
+    LOADING = "loading",
+    INTERACTIVE = "interactive",
+    COMPLETE = "complete"
+}
+export type TriggerWorkflowRequest = CredentialConfigOptions & {
+    body?: RequestInit['body'] | object;
+    headers?: RequestInit['headers'];
+    query?: Record<string, string>;
+};
+export interface IFilePicker {
+    /**
+     * opens file picker of integrations e.g. googledrive
+     */
+    open(): boolean;
+    /**
+     * initiates addition of file picker dependency
+     */
+    init(options: FilePickerInitOptions): Promise<boolean>;
+    /**
+     * returns instance of the integration based on how file picker opens
+     */
+    getInstance(): unknown;
+}
+export type FilePickerOptions = {
+    allowedTypes?: string[];
+    allowMultiSelect?: boolean;
+    allowFolderSelect?: boolean;
+    onOpen?: () => void;
+    onClose?: () => void;
+    onFileSelect?: (files: unknown) => void;
+    onCancel?: () => void;
+};
+export type FilePickerInitOptions = {
+    developerKey?: string;
+    DocsViewMode?: string;
+    appId?: string;
+    clientId?: string;
+};
+export declare enum FilePickerStatus {
+    LOADING = "loading",
+    FAILED = "failed",
+    LOADED = "loaded"
+}
+export interface ExternalFilePickerConstruct {
+    new (action: string, options: FilePickerOptions): IFilePicker;
+    (action: string, options: FilePickerOptions): IFilePicker;
+}
+export declare enum DocsViewMode {
+    GRID = "grid",
+    LIST = "list"
+}
+export declare const supportedModesForDocsViewMode: string[];
+export interface OpenOptions {
+    clientId: string;
+    action: 'share' | 'download' | 'upload' | string;
+    advanced?: {
+        queryParameters?: string;
+        accessToken?: string;
+    };
+    multiSelect?: boolean;
+    openInNewWindow: boolean;
+    success?: (files: File[]) => void;
+    cancel?: () => void;
+    error?: (error: Error) => void;
+}
+export interface File {
+    id: string;
+    name: string;
+    size: number;
+    link: string;
+}
+export {};

package/dist/src/src/types/stripe.d.ts

@@ -0,0 +1,23 @@
+export declare enum BillingPlan {
+    ClassicFree = "free",
+    ClassicStarter = "starter",
+    ClassicBusiness = "business",
+    ClassicPremium = "premium",
+    ClassicEnterprise = "enterprise",
+    ConnectTrial = "connect_trial",
+    ConnectBasic = "basic",
+    ConnectPro = "pro",
+    ConnectEnterprise = "connect_enterprise"
+}
+export declare enum ConnectAddOn {
+    CustomIntegrationBuilder = "byo",
+    DynamicFieldMapper = "dfm",
+    HeadlessConnectPortal = "headless-cp",
+    TaskHistoryAPI = "th-api",
+    Monitoring = "monitoring",
+    RoleBasedAccessControl = "rbac",
+    UserMetadata = "user-metadata",
+    WhiteLabeling = "whitelabel",
+    WorkflowPermission = "workflow-permissions"
+}
+export type ConnectNonTrialBillingPlan = BillingPlan.ConnectBasic | BillingPlan.ConnectPro | BillingPlan.ConnectEnterprise;

package/dist/src/src/utils/connect.d.ts

@@ -0,0 +1,19 @@
+import { NODE_ENV, PLATFORM_ENV } from '../types/environment';
+/**
+ * get asset url i.e. cdn public url or dashboard public url
+ * @param env
+ * @returns
+ */
+export declare const getAssetUrl: ({ CDN_PUBLIC_URL: cdnHost, DASHBOARD_PUBLIC_URL: dashboardPublicURL, VERSION: version, PLATFORM_ENV: platformEnv, NODE_ENV: nodeEnv, }: {
+    CDN_PUBLIC_URL: string;
+    DASHBOARD_PUBLIC_URL: string;
+    NODE_ENV: string;
+    PLATFORM_ENV: string;
+    VERSION: string;
+}) => string;
+/**
+ *
+ * @param externalId
+ * @returns
+ */
+export declare function sanitizeExternalConfigId(externalId: string): string;

package/dist/src/src/utils/crypto.d.ts

@@ -0,0 +1,7 @@
+/**
+ * hashes a string
+ *
+ * @param {string} value
+ * @returns {string} 10 digit hash
+ */
+export declare function hash(value: string): string;

package/dist/src/src/utils/generic.d.ts

@@ -0,0 +1,41 @@
+/**
+ * a helper class for creating deferred promises
+ * @tutorial https://gist.github.com/GFoley83/5877f6c09fbcfd62569c51dc91444cf0
+ */
+export declare class DeferredPromise<T> implements Promise<T> {
+    [Symbol.toStringTag]: 'Promise';
+    private _promise;
+    private _resolve;
+    private _reject;
+    private _state;
+    get state(): 'pending' | 'fulfilled' | 'rejected';
+    constructor();
+    then<TResult1, TResult2>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>;
+    catch<TResult>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>;
+    resolve(value?: T | PromiseLike<T>): void;
+    reject(reason?: any): void;
+    finally(onfinally?: () => void): Promise<T>;
+}
+/**
+ * given a type definition of a record and possible values for each key,
+ * it generates an array of every permutation
+ *
+ * @template T
+ * @param {{ [k in keyof T]: T[k][] }} input
+ * @returns {T[]}
+ */
+export declare function generateMatrix<T extends Record<string, any>>(input: {
+    [k in keyof T]: T[k][];
+}, limit?: number): T[];
+export declare function sleep(milliseconds: number): Promise<void>;
+export declare const uuidPattern: RegExp;
+export declare function isUUID(value: string | unknown): boolean;
+/**
+ * keeps attempting to execute a method until a desired result is achieved
+ *
+ * @param {() => Promise<T>} method
+ * @param {((result: T, attempt: number) => Promise<boolean> | boolean)} shouldRetry
+ * @param {(number | ((attempt: number) => number))} backoff
+ * @returns {Promise<T>}
+ */
+export declare function tryUntil<T = any>(method: () => Promise<T> | T, shouldRetry: (result: T | null, error?: Error | null, attempt?: number) => Promise<boolean> | boolean, backoff: number | ((attempt: number) => number)): Promise<T>;

package/dist/src/src/utils/http.d.ts

@@ -0,0 +1,57 @@
+/**
+ * check if url is valid or not
+ * @param url
+ * @returns
+ */
+export declare const isValidUrl: (url: string) => boolean;
+/**
+ * it will add https protocol if protocol is not added in utl
+ * @param url
+ * @returns
+ */
+export declare function sanitizeUrl(url: string): string;
+export declare function getServiceUrl(service: string, domain: string): string;
+/**
+ * Validation error description.
+ * @see https://github.com/typestack/class-validator
+ *
+ * class-validator@0.13.0
+ *
+ * @publicApi
+ */
+export interface ValidationError {
+    /**
+     * Constraints that failed validation with error messages.
+     */
+    constraints?: {
+        [type: string]: string;
+    };
+    /**
+     * Contains all nested validation errors of the property.
+     */
+    children?: ValidationError[];
+}
+export type MessageWithErrorBody = {
+    message: string;
+    response: Record<string, unknown>;
+};
+/**
+ * extract error message from response object
+ * @param response
+ * @returns
+ */
+export declare function getErrorMessage(response: Response): Promise<string>;
+export declare function getErrorMessage(response: Response, isProxyRequestFailure: true): Promise<MessageWithErrorBody>;
+export declare function getErrorMessage(response: Response, isProxyRequestFailure: false): Promise<string>;
+export declare class ProxyRequestError extends Error {
+    response: Record<string, unknown>;
+    constructor(message: string, response: any);
+}
+export declare const isIntegrationError: (error: unknown) => boolean;
+/**
+ * Parses an error message and determines if it represents an integration error.
+ *
+ * @param {string | Error} err - The error message or Error object to parse.
+ * @returns {boolean} - True if the error represents an integration error, false otherwise.
+ */
+export declare function errorMessageParser(err: string | Error): boolean;

package/dist/src/src/utils/throttle.d.ts

@@ -0,0 +1,118 @@
+/**
+ * whether to debounce or throttle cached items
+ * defaults to `Debounce` behavior
+ */
+export declare enum CacheMode {
+    Debounce = "debounce",
+    Throttle = "throttle"
+}
+/**
+ * configuration parameters for a CacheThrottle instance
+ */
+export type CacheThrottleConfig<T = any> = Partial<{
+    /**
+     * when enabled, this clears pending `del` calls from the queue when `get`, `set`, or `getOrSet` is called
+     * this can be used to prevent queued delete calls from deleting recently retrieved stateful values, like db connections
+     */
+    clearPendingDeletes: boolean;
+    /**
+     * whether to operate in Throttle or Debounce mode
+     */
+    mode: CacheMode;
+    /**
+     * an optional callback for handling items when they get deregistered from the cache
+     */
+    onDeregister: (value: T) => Promise<void> | void;
+    /**
+     * an optional callback for serializing keys
+     * in the case that keys are particularly long, this can be used to shorten them
+     */
+    serializeKey: (key: string) => string;
+    /**
+     * how long items should remain in the cache
+     * the ttl is reset every time a key is accessed
+     */
+    ttl: number;
+}>;
+/**
+ * A helper class for caching items in memory and throttling / debouncing function calls
+ * methods for getters, setters, and executors are queued to prevent race conditions between calls.
+ * It provides helper methods for handling deregistering of items.
+ * Useful for caching database connections or rate-limiting outgoing Sentry calls.
+ */
+export declare class CacheThrottle<T = any> {
+    #private;
+    constructor(config?: CacheThrottleConfig<T>);
+    /**
+     * attempts to retrieve a key from the cache
+     *
+     * @param {string} key
+     * @param {boolean} [asap] asap = as soon as possible. should this be queued or execute immediately
+     * @returns {(Promise<T | undefined>)}
+     * @memberof CacheThrottle
+     */
+    get(key: string, asap?: boolean): Promise<T | undefined>;
+    /**
+     * stores an item in the cache
+     *
+     * @param {string} key
+     * @param {T} value
+     * @param {number} [ttl=this.]
+     * @param {*} config
+     * @param {*} ttl
+     * @param {CacheMode} [mode]
+     * @param {boolean} [asap] asap = as soon as possible. should this be queued or execute immediately
+     * @returns {Promise<T>}
+     * @memberof CacheThrottle
+     */
+    set(key: string, value: T, ttl?: number, mode?: CacheMode, asap?: boolean): Promise<T>;
+    /**
+     * attempts to retrieve a value from the cache
+     * if it's not available, it sets the value using the provided generator method
+     */
+    getOrSet(key: string, generator: () => T | Promise<T>, ttl?: number, mode?: CacheMode, asap?: boolean): Promise<T>;
+    /**
+     * deletes an item from the cache
+     *
+     * @param {string} key
+     * @param {boolean} [isKeySerialized=false]
+     * @param {boolean} [asap] asap = as soon as possible. should this be queued or execute immediately
+     * @returns {(Promise<T | undefined>)}
+     * @memberof CacheThrottle
+     */
+    del(key: string, isKeySerialized?: boolean, asap?: boolean): Promise<T | undefined>;
+    /**
+     * returns the keys stored in the cache
+     */
+    keys(): string[];
+    /**
+     * executes a method. the `key` is used as a unique identifier for rate-limiting calls
+     */
+    do(key: string, method: () => T | Promise<T>, ttl?: number, mode?: CacheMode): Promise<T>;
+    /**
+     * removes all the items from the cache, clears timeouts, and calls deregister methods
+     */
+    close(): Promise<void>;
+    /**
+     * refreshes a set interval for clearing an item from the cache
+     * if an existing interval exists, it removes it
+     */
+    private refreshTimeout;
+    /**
+     * removes any pending delete calls on a key
+     * @param key
+     */
+    private clearPendingDeletesOnKey;
+    /**
+     * generates the key used for storing items in the cache
+     */
+    private serializeKey;
+    /**
+     * queues a method for processing
+     */
+    private enqueue;
+    /**
+     * calls the methods in the queue
+     */
+    private flush;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useparagon/connect",
-  "version": "1.0.24-experimental.12",
+  "version": "1.0.24-experimental.13",
   "description": "Embed integrations into your app with the Paragon SDK",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",