@quiltt/vue 5.1.2

package/dist/composables/index.d.ts

@@ -0,0 +1,191 @@
+import * as vue from 'vue';
+import { MaybeRefOrGetter, ComputedRef } from 'vue';
+import { ConnectorSDKCallbacks, PasscodePayload, UnprocessableData, UsernamePayload, Maybe, QuilttJWT } from '@quiltt/core';
+
+/**
+ * Quiltt Connector Composable
+ *
+ * Provides connector management functionality for Vue 3 applications.
+ * Loads the Quiltt Connector SDK and manages connector state.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useQuilttConnector } from '@quiltt/vue'
+ *
+ * const { open } = useQuilttConnector('conn_xxx', {
+ *   onExitSuccess: (metadata) => {
+ *     console.log('Connected:', metadata.connectionId)
+ *   }
+ * })
+ * </script>
+ *
+ * <template>
+ *   <button @click="open">Connect Bank Account</button>
+ * </template>
+ * ```
+ */
+
+interface UseQuilttConnectorOptions extends ConnectorSDKCallbacks {
+    connectionId?: MaybeRefOrGetter<string | undefined>;
+    institution?: MaybeRefOrGetter<string | undefined>;
+    appLauncherUrl?: MaybeRefOrGetter<string | undefined>;
+    /**
+     * @deprecated Use `appLauncherUrl` instead. This property will be removed in a future version.
+     * The OAuth redirect URL for mobile or embedded webview flows.
+     */
+    oauthRedirectUrl?: MaybeRefOrGetter<string | undefined>;
+    nonce?: string;
+}
+interface UseQuilttConnectorReturn {
+    /** Open the connector modal */
+    open: () => void;
+}
+/**
+ * Composable for managing Quiltt Connector
+ *
+ * Loads the Quiltt SDK script and provides methods to open/manage connectors.
+ * This composable can run without QuilttPlugin session context; when unavailable,
+ * it logs a warning and continues without authenticated session state.
+ */
+declare const useQuilttConnector: (connectorId?: MaybeRefOrGetter<string | undefined>, options?: UseQuilttConnectorOptions) => UseQuilttConnectorReturn;
+
+/**
+ * Search institutions for a connector.
+ * Requires QuilttPlugin session context and throws when used without it.
+ */
+declare const useQuilttInstitutions: (connectorId: string, onErrorCallback?: (msg: string) => void) => {
+    searchTerm: vue.ComputedRef<string>;
+    searchResults: vue.ComputedRef<{
+        name: string;
+        logoUrl: string;
+    }[]>;
+    isSearching: vue.ComputedRef<boolean>;
+    setSearchTerm: (term: string) => void;
+};
+
+type ProviderId = {
+    plaid?: string;
+    mock?: string;
+    mx?: string;
+    finicity?: string;
+    akoya?: string;
+};
+/**
+ * Check whether a provider link is resolvable for a connector.
+ * Requires QuilttPlugin session context and throws when used without it.
+ */
+declare const useQuilttResolvable: (connectorId: string, onErrorCallback?: (msg: string) => void) => {
+    checkResolvable: (providerId: ProviderId) => Promise<boolean | null>;
+    isLoading: vue.ComputedRef<boolean>;
+    isResolvable: vue.ComputedRef<boolean | null>;
+    error: vue.ComputedRef<string | null>;
+};
+
+/**
+ * Quiltt Session Composable
+ *
+ * Provides session management functionality for Vue 3 applications.
+ * Must be used within a component tree where QuilttPlugin is installed.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useQuilttSession } from '@quiltt/vue'
+ *
+ * const { session, importSession, revokeSession } = useQuilttSession()
+ *
+ * // Import a session token
+ * await importSession('<SESSION_TOKEN>')
+ *
+ * // Access session data
+ * console.log(session.value?.token)
+ *
+ * // Revoke the session
+ * await revokeSession()
+ * </script>
+ * ```
+ */
+
+/**
+ * Callbacks for identify session operation
+ */
+interface IdentifySessionCallbacks {
+    onSuccess?: () => unknown;
+    onChallenged?: () => unknown;
+    onError?: (errors: UnprocessableData) => unknown;
+    onForbidden?: () => unknown;
+}
+/**
+ * Callbacks for authenticate session operation
+ */
+interface AuthenticateSessionCallbacks {
+    onSuccess?: () => unknown;
+    onFailure?: () => unknown;
+    onError?: (errors: UnprocessableData) => unknown;
+}
+type ImportSession = (token: string, environmentId?: string) => Promise<boolean>;
+type IdentifySession = (payload: UsernamePayload, callbacks: IdentifySessionCallbacks) => Promise<unknown>;
+type AuthenticateSession = (payload: PasscodePayload, callbacks: AuthenticateSessionCallbacks) => Promise<unknown>;
+type RevokeSession = () => Promise<void>;
+type ForgetSession = (token?: string) => void;
+interface UseQuilttSessionReturn {
+    /** Current session (reactive) */
+    session: ComputedRef<Maybe<QuilttJWT> | undefined>;
+    /** Import an existing session token */
+    importSession: ImportSession;
+    /** Start authentication flow with username/email/phone */
+    identifySession: IdentifySession;
+    /** Complete authentication with passcode */
+    authenticateSession: AuthenticateSession;
+    /** Revoke the current session (invalidates token on server) */
+    revokeSession: RevokeSession;
+    /** Forget the current session locally (without server call) */
+    forgetSession: ForgetSession;
+}
+/**
+ * Composable for managing Quiltt session state
+ *
+ * Provides methods for importing, creating, and revoking sessions.
+ * Session state is automatically synchronized across components.
+ * Requires QuilttPlugin provider context and throws when used without it.
+ */
+declare const useQuilttSession: () => UseQuilttSessionReturn;
+
+/**
+ * Read plugin-provided Quiltt settings.
+ * When used without QuilttPlugin context, values are undefined.
+ */
+declare const useQuilttSettings: () => {
+    clientId: vue.ComputedRef<string | undefined>;
+};
+
+declare const useSession: (storageKey?: string) => {
+    session: vue.ComputedRef<{
+        token: string;
+        claims: {
+            iss: string;
+            sub: string;
+            aud: string;
+            exp: number;
+            nbf: number;
+            iat: number;
+            jti: string;
+            oid: string;
+            eid: string;
+            cid: string;
+            aid: string;
+            ver: number;
+            rol: "basic" | "core" | "manager" | "super-admin";
+        };
+    } | null | undefined>;
+    setSession: (nextState: Maybe<string> | undefined | ((prev: Maybe<string> | undefined) => Maybe<string> | undefined)) => void;
+};
+
+declare const useStorage: <T>(key: string, initialState?: Maybe<T>) => {
+    storage: vue.ComputedRef<any>;
+    setStorage: (nextState: Maybe<T> | undefined | ((prev: Maybe<T> | undefined) => Maybe<T> | undefined)) => void;
+};
+
+export { useQuilttConnector, useQuilttInstitutions, useQuilttResolvable, useQuilttSession, useQuilttSettings, useSession, useStorage };
+export type { AuthenticateSession, AuthenticateSessionCallbacks, ForgetSession, IdentifySession, IdentifySessionCallbacks, ImportSession, RevokeSession, UseQuilttConnectorOptions, UseQuilttConnectorReturn, UseQuilttSessionReturn };