@providame/vue 0.0.1-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Avanest
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# @providame/vue
+
+Vue 3 bindings for Providame — headless composables (build your own UI) and prebuilt components (drop-in), both over the same `@providame/core` engine.
+
+## Install
+
+```bash
+npm install @providame/vue vue
+```
+
+## Usage
+
+Install the plugin once, then import the CSS for the prebuilt components:
+
+```ts
+import { createApp } from 'vue'
+import { ProvidamePlugin } from '@providame/vue'
+import '@providame/vue/style.css'
+
+createApp(App).use(ProvidamePlugin, {
+  publishableKey: 'pk_test_...',
+})
+```
+
+### Prebuilt components
+
+```vue
+<script setup>
+import { SignIn } from '@providame/vue'
+</script>
+
+<template>
+  <SignIn sign-up-url="/sign-up" @complete="onComplete" />
+</template>
+```
+
+### Headless
+
+```ts
+import { useSignIn } from '@providame/vue'
+
+const signIn = useSignIn()
+await signIn.signInWithPassword('user@example.com', 'password')
+```
+
+## Build
+
+```bash
+npm run build
+```

package/dist/components/Protect.vue.d.ts

@@ -0,0 +1,18 @@
+type __VLS_Props = {
+    role?: string;
+};
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    fallback?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/RedirectToSignIn.vue.d.ts

@@ -0,0 +1,6 @@
+type __VLS_Props = {
+    signInUrl: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/ResetPassword.vue.d.ts

@@ -0,0 +1,23 @@
+import "../styles.css";
+import { type Appearance } from "@providame/core";
+type __VLS_Props = {
+    /** Heading shown above the form. */
+    title?: string;
+    /** Subtitle shown under the title. */
+    subtitle?: string;
+    /** Logo image URL, rendered centered above the title. */
+    logo?: string;
+    /** Link target for the "back to sign in" prompt. */
+    signInUrl?: string;
+    appearance?: Appearance;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    complete: (session: import("@providame/core").Session) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onComplete?: ((session: import("@providame/core").Session) => any) | undefined;
+}>, {
+    title: string;
+    signInUrl: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/SignIn.vue.d.ts

@@ -0,0 +1,23 @@
+import "../styles.css";
+import { type Appearance } from "@providame/core";
+type __VLS_Props = {
+    /** Heading shown above the form. */
+    title?: string;
+    /** Subtitle shown under the title. */
+    subtitle?: string;
+    /** Logo image URL, rendered centered above the title. */
+    logo?: string;
+    /** Link target for the "create account" prompt. */
+    signUpUrl?: string;
+    appearance?: Appearance;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    complete: (session: import("@providame/core").Session) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onComplete?: ((session: import("@providame/core").Session) => any) | undefined;
+}>, {
+    title: string;
+    signUpUrl: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/SignInButton.vue.d.ts

@@ -0,0 +1,25 @@
+type __VLS_Props = {
+    mode?: "modal" | "redirect";
+    signInUrl?: string;
+    signUpUrl?: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    complete: (session: unknown) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onComplete?: ((session: unknown) => any) | undefined;
+}>, {
+    signInUrl: string;
+    mode: "modal" | "redirect";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/SignOutButton.vue.d.ts

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    redirectUrl?: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/SignUp.vue.d.ts

@@ -0,0 +1,29 @@
+import "../styles.css";
+import { type Appearance } from "@providame/core";
+type __VLS_Props = {
+    title?: string;
+    /** Subtitle shown under the title. */
+    subtitle?: string;
+    /** Logo image URL, rendered centered above the title. */
+    logo?: string;
+    signInUrl?: string;
+    /** Collect first/last name fields. */
+    collectName?: boolean;
+    /** Invite code for an invite_only signup-policy environment — threaded
+     * to CreateSignUpParams.inviteToken. Read this from your own app's URL
+     * (e.g. an invite-accept page's query param) or wherever your invite
+     * flow surfaces it. */
+    inviteToken?: string;
+    appearance?: Appearance;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    complete: (session: import("@providame/core").Session) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onComplete?: ((session: import("@providame/core").Session) => any) | undefined;
+}>, {
+    title: string;
+    signInUrl: string;
+    collectName: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/SignUpButton.vue.d.ts

@@ -0,0 +1,25 @@
+type __VLS_Props = {
+    mode?: "modal" | "redirect";
+    signUpUrl?: string;
+    signInUrl?: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    complete: (session: unknown) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onComplete?: ((session: unknown) => any) | undefined;
+}>, {
+    signUpUrl: string;
+    mode: "modal" | "redirect";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/SignedIn.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/SignedOut.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/UserButton.vue.d.ts

@@ -0,0 +1,12 @@
+import "../styles.css";
+import { type Appearance } from "@providame/core";
+type __VLS_Props = {
+    appearance?: Appearance;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    signOut: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSignOut?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/UserProfile.vue.d.ts

@@ -0,0 +1,12 @@
+import "../styles.css";
+import { type Appearance } from "@providame/core";
+type __VLS_Props = {
+    appearance?: Appearance;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/internal/EmailSection.vue.d.ts

@@ -0,0 +1,7 @@
+import type { UseUser } from "../../composables/useUser.js";
+type __VLS_Props = {
+    user: UseUser;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/internal/Overlay.vue.d.ts

@@ -0,0 +1,34 @@
+import "../../styles.css";
+type __VLS_Props = {
+    open: boolean;
+    closeOnEscape?: boolean;
+    closeOnBackdrop?: boolean;
+    /** Accessible name for the dialog — required since role="dialog" alone
+     * gives assistive tech nothing to announce. */
+    ariaLabel?: string;
+    /** Explicit element to restore focus to on close, overriding the
+     * auto-captured document.activeElement below. Needed when the element
+     * that triggered the open (e.g. a dropdown menu item) is itself removed
+     * from the DOM as a side effect of opening (closing the menu) — restoring
+     * focus to a now-detached node is a silent no-op, so a caller in that
+     * situation (see UserButton.vue) should pass its own stable trigger
+     * element instead. */
+    restoreFocusTo?: HTMLElement | null;
+};
+declare var __VLS_7: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/internal/PhoneSection.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/internal/ProfileSection.vue.d.ts

@@ -0,0 +1,7 @@
+import type { UseUser } from "../../composables/useUser.js";
+type __VLS_Props = {
+    user: UseUser;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/internal/SecuritySection.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/internal/TurnstileWidget.vue.d.ts

@@ -0,0 +1,10 @@
+type __VLS_Props = {
+    siteKey: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    token: (token: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToken?: ((token: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/composables/useAuth.d.ts

@@ -0,0 +1,12 @@
+import { type Ref } from "vue";
+export interface UseAuth {
+    isLoaded: Ref<boolean>;
+    isSignedIn: Ref<boolean>;
+    userId: Ref<string | null>;
+    /** Decoded access-token claims (display/gating only — never verified client-side). */
+    sessionClaims: Ref<Record<string, unknown> | null>;
+    getToken(): Promise<string | null>;
+    signOut(): Promise<void>;
+}
+/** Clerk-shaped auth-state hook, built on the existing useSession()/client. */
+export declare function useAuth(): UseAuth;

package/dist/composables/useBranding.d.ts

@@ -0,0 +1,14 @@
+import type { Branding } from "@providame/core";
+import { type Ref } from "vue";
+/**
+ * Fetches this environment's Branding settings (colors/logo) and applies
+ * the colors as global CSS custom properties — every prebuilt component
+ * calls this on mount so a page with only one of them (e.g. just
+ * <UserButton>) still picks up branding; the underlying fetch is memoized
+ * on the Providame client (see Providame.branding()), so mounting several
+ * components on one page costs a single request, not one per component.
+ * Returns the fetched Branding so <SignIn>/<SignUp>/<ResetPassword> can
+ * default their `logo` prop to `branding.value.logoUrl` when no explicit
+ * logo was passed.
+ */
+export declare function useBranding(): Ref<Branding>;

package/dist/composables/usePasskeyRegistrationLink.d.ts

@@ -0,0 +1,24 @@
+export interface UsePasskeyRegistrationLink {
+    registerWithCode(identifier: string, codeId: string, code: string, domain: string): Promise<{
+        passkeyId: string;
+        creationOptions: Record<string, unknown>;
+    }>;
+    verifyWithCode(passkeyId: string, identifier: string, credential: Record<string, unknown>, name: string): Promise<void>;
+}
+/**
+ * Thin wrapper around the admin-initiated passkey registration-link flow
+ * (`PasskeysApi.registerWithCode`/`verifyWithCode` in `@providame/core`) —
+ * the code-based flow a user who isn't currently signed in completes from
+ * the landing page an admin-emailed registration link points at. See
+ * `PasskeysApi.registerWithCode`'s doc comment in `@providame/core` for the
+ * full flow (driving `navigator.credentials.create()` between the two
+ * calls) and its error-handling note.
+ *
+ * Unlike `useAuth()`/`useUser()`, this is stateless — there's no signed-in
+ * session to track between calls — so it's a plain passthrough to the
+ * already-injected `Providame` client, exposed as a composable purely for
+ * discoverability/consistency with this package's other `use*` exports.
+ * `useProvidame().user.passkeys.registerWithCode`/`verifyWithCode` work
+ * identically without this composable.
+ */
+export declare function usePasskeyRegistrationLink(): UsePasskeyRegistrationLink;

package/dist/composables/useResetPassword.d.ts

@@ -0,0 +1,34 @@
+import { ProvidameError, type EnrollTotpResponse, type ResetPasswordAttemptParams, type SecondFactorParams, type Session, type StartResetPasswordParams } from "@providame/core";
+import { type Ref } from "vue";
+export interface UseResetPassword {
+    /** Current flow status; "idle" before create(). */
+    status: Ref<string>;
+    /** True while a request is in flight. */
+    loading: Ref<boolean>;
+    /** Last error, or null. */
+    error: Ref<ProvidameError | null>;
+    /** The session, once complete. */
+    session: Ref<Session | null>;
+    /** True once the new password has been set and the user signed in. */
+    isComplete: Ref<boolean>;
+    /** Secret + otpauth URI for a pending mid-flow TOTP enrollment. */
+    enrollment: Ref<EnrollTotpResponse | null>;
+    /** One-time backup codes, populated right after a mid-flow TOTP enrollment. */
+    recoveryCodes: Ref<string[] | null>;
+    create(params: StartResetPasswordParams): Promise<void>;
+    attempt(params: ResetPasswordAttemptParams): Promise<void>;
+    /** Submits the second factor (TOTP or a backup code) for an MFA-protected account. */
+    attemptSecondFactor(params: SecondFactorParams): Promise<void>;
+    /** Begins TOTP enrollment when status is "needs_mfa_enrollment". */
+    enrollTotp(): Promise<void>;
+    /** Confirms an authenticator code, activating TOTP and completing the flow. */
+    verifyTotpEnrollment(code: string): Promise<void>;
+    resend(): Promise<void>;
+    reset(): void;
+}
+/**
+ * useResetPassword wraps the headless ResetPasswordFlow in reactive Vue state,
+ * symmetric to useSignIn/useSignUp. The prebuilt <ResetPassword> component
+ * consumes this composable.
+ */
+export declare function useResetPassword(): UseResetPassword;

package/dist/composables/useSession.d.ts

@@ -0,0 +1,23 @@
+import type { MeUser } from "@providame/core";
+import { type Ref } from "vue";
+export interface UseSession {
+    /** Whether an end-user session is active. */
+    isSignedIn: Ref<boolean>;
+    /** True while the initial check is running. */
+    loading: Ref<boolean>;
+    /** The raw access token, if present (decode client-side; verify on backend). */
+    accessToken: Ref<string | null>;
+    /** The signed-in end-user's own profile (best-effort — see Providame.session()),
+     * or null if not signed in or the enrichment failed. Powers prebuilt
+     * components like <UserButton>. */
+    user: Ref<MeUser | null>;
+    /** Re-checks the session against the server. */
+    refresh(): Promise<void>;
+    /** Signs out and clears local state. */
+    signOut(): Promise<void>;
+}
+/**
+ * useSession exposes the current end-user session and hydrates it on mount. Use
+ * it to gate UI ("show dashboard vs. sign-in") in a fully custom app.
+ */
+export declare function useSession(): UseSession;

package/dist/composables/useSignIn.d.ts

@@ -0,0 +1,57 @@
+import { ProvidameError, type EnrollTotpResponse, type FactorKind, type FirstFactorParams, type SecondFactorParams, type Session } from "@providame/core";
+import { type Ref } from "vue";
+export interface UseSignIn {
+    /** Current flow status; "idle" before create(). */
+    status: Ref<string>;
+    /** True while a request is in flight. */
+    loading: Ref<boolean>;
+    /** Last error, or null. */
+    error: Ref<ProvidameError | null>;
+    /** First factors the backend will accept next. */
+    firstFactors: Ref<FactorKind[]>;
+    /** Second factors required, if any. */
+    secondFactors: Ref<FactorKind[]>;
+    /** The session, once complete. */
+    session: Ref<Session | null>;
+    /** True once authentication is complete. */
+    isComplete: Ref<boolean>;
+    /** Secret + otpauth URI for a pending mid-flow TOTP enrollment. */
+    enrollment: Ref<EnrollTotpResponse | null>;
+    /** One-time backup codes, populated right after a mid-flow TOTP enrollment. */
+    recoveryCodes: Ref<string[] | null>;
+    create(identifier: string): Promise<void>;
+    /** Combined identifier+password sign-in for a single-screen UI: calls
+     * create() then immediately attemptFirstFactor({strategy: "password"}) in
+     * one guarded call. On failure at either step, the flow resets back to
+     * idle so the same combined form can be resubmitted, rather than leaving
+     * status at "needs_first_factor" (a failed attemptFirstFactor's status)
+     * with no identifier field left to fix it from. */
+    signInWithPassword(identifier: string, password: string): Promise<void>;
+    /** Opens the flow with a passkey and immediately prompts the user via
+     * navigator.credentials.get() — one call, unlike create()+attemptFirstFactor(). */
+    signInWithPasskey(identifier: string, domain: string): Promise<void>;
+    /** Opens the flow by emailing a one-time code; call attemptFirstFactor({strategy: "otp_email", code}) once the end-user has it. */
+    signInWithOTPEmail(identifier: string): Promise<void>;
+    /** Re-sends the code for a flow opened via signInWithOTPEmail(). */
+    resendOTPEmail(): Promise<void>;
+    /** Opens the flow by texting a one-time code to the phone on file; call attemptFirstFactor({strategy: "otp_sms", code}) once the end-user has it. */
+    signInWithOTPSMS(identifier: string): Promise<void>;
+    /** Re-sends the code for a flow opened via signInWithOTPSMS(). */
+    resendOTPSMS(): Promise<void>;
+    /** Opens the flow by emailing a passwordless "click to sign in" link to returnUrl. */
+    signInWithMagicLink(identifier: string, returnUrl: string): Promise<void>;
+    attemptFirstFactor(params: FirstFactorParams): Promise<void>;
+    attemptSecondFactor(params: SecondFactorParams): Promise<void>;
+    /** Begins TOTP enrollment when status is "needs_mfa_enrollment". */
+    enrollTotp(): Promise<void>;
+    /** Confirms an authenticator code, activating TOTP and completing the flow. */
+    verifyTotpEnrollment(code: string): Promise<void>;
+    reset(): void;
+}
+/**
+ * useSignIn wraps the headless SignInFlow in reactive Vue state. This is the
+ * binding a developer uses to build a completely custom sign-in UI — they read
+ * `status`/`firstFactors`/`error` and render whatever they want. The prebuilt
+ * <SignIn> component consumes this very composable.
+ */
+export declare function useSignIn(): UseSignIn;

package/dist/composables/useSignInIdp.d.ts

@@ -0,0 +1,23 @@
+import { ProvidameError, type EnabledIdp } from "@providame/core";
+import { type Ref } from "vue";
+export interface UseSignInIdp {
+    /** Providers enabled for this environment, fetched on mount. Empty until
+     * loaded, and stays empty (silently) if that background fetch fails —
+     * providers are decorative, not something to block sign-in over. */
+    providers: Ref<EnabledIdp[]>;
+    /** True while a signIn() call's start request is in flight. Stays true on
+     * success — there is no in-page "done" state, the browser navigates away. */
+    loading: Ref<boolean>;
+    /** Populated by a failed signIn() start request, or by a post-redirect
+     * social-login-error event. */
+    error: Ref<ProvidameError | null>;
+    signIn(provider: string, returnUrl?: string): Promise<void>;
+}
+/**
+ * useSignInIdp wraps the redirect-based social-login flow: it fetches which
+ * providers are enabled for this environment, exposes a signIn() action, and
+ * surfaces a post-redirect failure (from returning after the external IdP
+ * round-trip) in the same `error` ref as a pre-redirect request failure. The
+ * prebuilt <SignIn> component consumes this composable directly.
+ */
+export declare function useSignInIdp(): UseSignInIdp;

package/dist/composables/useSignUp.d.ts

@@ -0,0 +1,30 @@
+import { ProvidameError, type CreateSignUpParams, type EnrollTotpResponse, type FactorKind, type SecondFactorParams, type Session, type VerificationParams } from "@providame/core";
+import { type Ref } from "vue";
+export interface UseSignUp {
+    status: Ref<string>;
+    loading: Ref<boolean>;
+    error: Ref<ProvidameError | null>;
+    secondFactors: Ref<FactorKind[]>;
+    session: Ref<Session | null>;
+    isComplete: Ref<boolean>;
+    needsVerification: Ref<boolean>;
+    /** True once a completed verification lands the account on a waitlist —
+     * see FlowStatus's own doc comment. No session is issued in this case. */
+    isWaitlisted: Ref<boolean>;
+    /** Secret + otpauth URI for a pending post-registration TOTP enrollment. */
+    enrollment: Ref<EnrollTotpResponse | null>;
+    /** One-time backup codes, populated right after a post-registration TOTP enrollment. */
+    recoveryCodes: Ref<string[] | null>;
+    create(params: CreateSignUpParams): Promise<void>;
+    attemptVerification(params: VerificationParams): Promise<void>;
+    attemptSecondFactor(params: SecondFactorParams): Promise<void>;
+    /** Begins TOTP enrollment when status is "needs_mfa_enrollment". */
+    enrollTotp(): Promise<void>;
+    /** Confirms an authenticator code, activating TOTP and completing the flow. */
+    verifyTotpEnrollment(code: string): Promise<void>;
+    reset(): void;
+}
+/**
+ * useSignUp is the reactive headless sign-up binding, symmetric to useSignIn.
+ */
+export declare function useSignUp(): UseSignUp;

package/dist/composables/useUser.d.ts

@@ -0,0 +1,10 @@
+import type { MeUser } from "@providame/core";
+import { type Ref } from "vue";
+export interface UseUser {
+    isLoaded: Ref<boolean>;
+    isSignedIn: Ref<boolean>;
+    user: Ref<MeUser | null>;
+    reload(): Promise<void>;
+}
+/** Clerk-shaped current-user hook, thinner than useSession (no accessToken/signOut). */
+export declare function useUser(): UseUser;