@lenne.tech/nuxt-extensions 1.0.0

package/dist/runtime/components/transition/LtTransitionFadeScale.vue.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Fade with scale transition component
+ *
+ * Provides a combined fade and scale animation.
+ * Elements fade in while scaling up from 95% to 100%,
+ * and fade out while scaling down to 95%.
+ *
+ * Great for modal dialogs, dropdown menus, and pop-ups.
+ *
+ * @example
+ * ```vue
+ * <LtTransitionFadeScale>
+ *   <div v-if="show">Content fades and scales</div>
+ * </LtTransitionFadeScale>
+ *
+ * <LtTransitionFadeScale :start-duration="200" :leave-duration="150">
+ *   <div v-if="show">Custom timing</div>
+ * </LtTransitionFadeScale>
+ * ```
+ */
+type __VLS_Props = {
+    /** Duration in ms for the leave animation (default: 100) */
+    leaveDuration?: `${number}` | number;
+    /** Duration in ms for the enter animation (default: 100) */
+    startDuration?: `${number}` | number;
+};
+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, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    leaveDuration: `${number}` | number;
+    startDuration: `${number}` | number;
+}, {}, {}, {}, 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/runtime/components/transition/LtTransitionSlide.d.vue.ts

@@ -0,0 +1,13 @@
+declare var __VLS_7: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => 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/runtime/components/transition/LtTransitionSlide.vue

@@ -0,0 +1,16 @@
+<script setup>
+
+</script>
+
+<template>
+  <Transition
+    enter-active-class="transition ease-out duration-500"
+    enter-from-class="transform translate-x-full"
+    enter-to-class="transform translate-x-0"
+    leave-active-class="transition ease-in duration-500"
+    leave-from-class="transform translate-x-0"
+    leave-to-class="transform translate-x-full"
+  >
+    <slot></slot>
+  </Transition>
+</template>

package/dist/runtime/components/transition/LtTransitionSlide.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_7: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => 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/runtime/components/transition/LtTransitionSlideBottom.d.vue.ts

@@ -0,0 +1,13 @@
+declare var __VLS_7: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => 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/runtime/components/transition/LtTransitionSlideBottom.vue

@@ -0,0 +1,16 @@
+<script setup>
+
+</script>
+
+<template>
+  <Transition
+    enter-active-class="transition ease-out duration-500"
+    enter-from-class="transform translate-y-full"
+    enter-to-class="transform translate-y-0"
+    leave-active-class="transition ease-in duration-500"
+    leave-from-class="transform translate-y-0"
+    leave-to-class="transform translate-y-full"
+  >
+    <slot></slot>
+  </Transition>
+</template>

package/dist/runtime/components/transition/LtTransitionSlideBottom.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_7: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => 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/runtime/components/transition/LtTransitionSlideRevert.d.vue.ts

@@ -0,0 +1,13 @@
+declare var __VLS_7: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => 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/runtime/components/transition/LtTransitionSlideRevert.vue

@@ -0,0 +1,16 @@
+<script setup>
+
+</script>
+
+<template>
+  <Transition
+    enter-active-class="transition ease-out duration-500"
+    enter-from-class="transform translate-x-[-100%]"
+    enter-to-class="transform translate-x-0"
+    leave-active-class="transition ease-in duration-500"
+    leave-from-class="transform translate-x-0"
+    leave-to-class="transform translate-x-[-100%]"
+  >
+    <slot></slot>
+  </Transition>
+</template>

package/dist/runtime/components/transition/LtTransitionSlideRevert.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_7: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => 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/runtime/composables/auth/use-lt-auth.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Better Auth composable with client-side state management
+ *
+ * This composable manages auth state using:
+ * 1. Primary: Session cookies (more secure, HttpOnly)
+ * 2. Fallback: JWT tokens (when cookies are not available/working)
+ *
+ * The auth mode is automatically detected:
+ * - If session cookie works -> use cookies
+ * - If cookies fail (401) -> switch to JWT mode
+ */
+import type { UseLtAuthReturn } from '../../types/index.js';
+/**
+ * Better Auth composable with Cookie/JWT dual-mode authentication
+ *
+ * @example
+ * ```typescript
+ * const { user, isAuthenticated, signIn, signOut } = useLtAuth();
+ *
+ * // Login
+ * await signIn.email({ email, password });
+ *
+ * // Check auth status
+ * if (isAuthenticated.value) {
+ *   console.log('Logged in as:', user.value?.name);
+ * }
+ *
+ * // Logout
+ * await signOut();
+ * ```
+ */
+export declare function useLtAuth(): UseLtAuthReturn;

package/dist/runtime/composables/auth/use-lt-auth.js

@@ -0,0 +1,411 @@
+import { useNuxtApp, useRuntimeConfig, useCookie, ref, computed, watch } from "#imports";
+import { ltArrayBufferToBase64Url, ltBase64UrlToUint8Array } from "../../utils/crypto.js";
+import { createLtAuthClient } from "../../lib/auth-client.js";
+let _authClient = null;
+function getAuthClient() {
+  if (!_authClient) {
+    _authClient = createLtAuthClient();
+  }
+  return _authClient;
+}
+function useTranslation() {
+  const nuxtApp = useNuxtApp();
+  const i18n = nuxtApp.$i18n;
+  return (key, germanFallback) => {
+    if (!i18n?.t) {
+      return germanFallback;
+    }
+    return i18n.t(key);
+  };
+}
+export function useLtAuth() {
+  const authClient = getAuthClient();
+  const t = useTranslation();
+  const authState = useCookie("lt-auth-state", {
+    maxAge: 60 * 60 * 24 * 7,
+    // 7 days
+    sameSite: "lax"
+  });
+  if (import.meta.client) {
+    try {
+      const cookieStr = document.cookie.split("; ").find((row) => row.startsWith("lt-auth-state="));
+      if (cookieStr) {
+        const parts = cookieStr.split("=");
+        const value = parts.length > 1 ? decodeURIComponent(parts.slice(1).join("=")) : "";
+        if (value) {
+          const parsed = JSON.parse(value);
+          if (parsed?.user && !authState.value?.user) {
+            authState.value = parsed;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (import.meta.server && (authState.value === null || authState.value === void 0)) {
+    authState.value = { user: null, authMode: "cookie" };
+  }
+  const jwtToken = useCookie("lt-jwt-token", {
+    maxAge: 60 * 60 * 24 * 7,
+    // 7 days
+    sameSite: "lax"
+  });
+  const isLoading = ref(false);
+  const authMode = computed(() => authState.value?.authMode || "cookie");
+  const isJwtMode = computed(() => authMode.value === "jwt");
+  const user = computed(() => authState.value?.user ?? null);
+  const isAuthenticated = computed(() => !!user.value);
+  const isAdmin = computed(() => user.value?.role === "admin");
+  const is2FAEnabled = computed(() => user.value?.twoFactorEnabled ?? false);
+  function getApiBase() {
+    const isDev = import.meta.dev;
+    const runtimeConfig = useRuntimeConfig();
+    const config = runtimeConfig.public.ltExtensions?.auth;
+    const baseURL = config?.baseURL || "http://localhost:3000";
+    const basePath = config?.basePath || "/iam";
+    return isDev ? `/api${basePath}` : `${baseURL}${basePath}`;
+  }
+  function setUser(userData, mode = "cookie") {
+    const newState = { user: userData, authMode: mode };
+    authState.value = newState;
+    if (import.meta.client) {
+      const maxAge = 60 * 60 * 24 * 7;
+      document.cookie = `lt-auth-state=${encodeURIComponent(JSON.stringify(newState))}; path=/; max-age=${maxAge}; samesite=lax`;
+    }
+  }
+  function clearUser() {
+    const clearedState = { user: null, authMode: "cookie" };
+    authState.value = clearedState;
+    jwtToken.value = null;
+    if (import.meta.client) {
+      const maxAge = 60 * 60 * 24 * 7;
+      document.cookie = `lt-auth-state=${encodeURIComponent(JSON.stringify(clearedState))}; path=/; max-age=${maxAge}; samesite=lax`;
+      document.cookie = `lt-jwt-token=; path=/; max-age=0`;
+      const sessionCookieNames = ["better-auth.session_token", "better-auth.session", "__Secure-better-auth.session_token", "session_token", "session"];
+      for (const name of sessionCookieNames) {
+        document.cookie = `${name}=; path=/; max-age=0`;
+        document.cookie = `${name}=; path=/api; max-age=0`;
+        document.cookie = `${name}=; path=/api/iam; max-age=0`;
+        document.cookie = `${name}=; path=/iam; max-age=0`;
+      }
+    }
+  }
+  async function switchToJwtMode() {
+    try {
+      const apiBase = getApiBase();
+      const response = await fetch(`${apiBase}/token`, {
+        method: "GET",
+        credentials: "include"
+      });
+      if (response.ok) {
+        const data = await response.json();
+        if (data.token) {
+          jwtToken.value = data.token;
+          if (authState.value) {
+            authState.value = { ...authState.value, authMode: "jwt" };
+          }
+          console.debug("[LtAuth] Switched to JWT mode");
+          return true;
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  async function refreshJwtToken() {
+    if (!isJwtMode.value || !jwtToken.value) return false;
+    return switchToJwtMode();
+  }
+  async function fetchWithAuth(url, options = {}) {
+    const headers = new Headers(options.headers);
+    if (isJwtMode.value && jwtToken.value) {
+      headers.set("Authorization", `Bearer ${jwtToken.value}`);
+    }
+    const response = await fetch(url, {
+      ...options,
+      headers,
+      // Only include credentials in cookie mode
+      credentials: isJwtMode.value ? "omit" : "include"
+    });
+    if (response.status === 401 && !isJwtMode.value && isAuthenticated.value) {
+      console.debug("[LtAuth] Cookie auth failed, attempting JWT fallback...");
+      const switched = await switchToJwtMode();
+      if (switched) {
+        headers.set("Authorization", `Bearer ${jwtToken.value}`);
+        return fetch(url, {
+          ...options,
+          headers,
+          credentials: "omit"
+        });
+      }
+    }
+    return response;
+  }
+  async function validateSession() {
+    try {
+      const session = authClient.useSession();
+      if (session.value.isPending) {
+        await new Promise((resolve) => {
+          const unwatch = watch(
+            () => session.value.isPending,
+            (isPending) => {
+              if (!isPending) {
+                unwatch();
+                resolve(true);
+              }
+            },
+            { immediate: true }
+          );
+        });
+      }
+      if (session.value.data?.user) {
+        setUser(session.value.data.user, "cookie");
+        switchToJwtMode().catch(() => {
+        });
+        return true;
+      }
+      if (authState.value?.user) {
+        switchToJwtMode().catch(() => {
+        });
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.debug("Session validation failed:", error);
+      return !!authState.value?.user;
+    }
+  }
+  const signIn = {
+    ...authClient.signIn,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    email: async (params, options) => {
+      isLoading.value = true;
+      try {
+        const result = await authClient.signIn.email(params, options);
+        const resultAny = result;
+        const token = resultAny?.token || resultAny?.data?.token;
+        const userData = resultAny?.user || resultAny?.data?.user;
+        if (token) {
+          jwtToken.value = token;
+          if (userData) {
+            setUser(userData, "jwt");
+          }
+          console.debug("[LtAuth] JWT token received from login response");
+        } else if (userData) {
+          setUser(userData, "cookie");
+          switchToJwtMode().catch(() => {
+          });
+        }
+        return result;
+      } finally {
+        isLoading.value = false;
+      }
+    }
+  };
+  const signUp = {
+    ...authClient.signUp,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    email: async (params, options) => {
+      isLoading.value = true;
+      try {
+        const result = await authClient.signUp.email(params, options);
+        const resultAny = result;
+        const token = resultAny?.token || resultAny?.data?.token;
+        const userData = resultAny?.user || resultAny?.data?.user;
+        if (token) {
+          jwtToken.value = token;
+          if (userData) {
+            setUser(userData, "jwt");
+          }
+          console.debug("[LtAuth] JWT token received from signup response");
+        } else if (userData) {
+          setUser(userData, "cookie");
+          switchToJwtMode().catch(() => {
+          });
+        }
+        return result;
+      } finally {
+        isLoading.value = false;
+      }
+    }
+  };
+  const signOut = async (options) => {
+    isLoading.value = true;
+    try {
+      const result = await authClient.signOut(options);
+      clearUser();
+      return result;
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  async function authenticateWithPasskey() {
+    isLoading.value = true;
+    try {
+      const apiBase = getApiBase();
+      const optionsResponse = await fetchWithAuth(`${apiBase}/passkey/generate-authenticate-options`, {
+        method: "GET"
+      });
+      if (!optionsResponse.ok) {
+        return { success: false, error: t("lt.auth.passkeyError", "Konnte Passkey-Optionen nicht laden") };
+      }
+      const options = await optionsResponse.json();
+      const challengeBuffer = ltBase64UrlToUint8Array(options.challenge).buffer;
+      const credential = await navigator.credentials.get({
+        publicKey: {
+          challenge: challengeBuffer,
+          rpId: options.rpId,
+          allowCredentials: options.allowCredentials || [],
+          userVerification: options.userVerification,
+          timeout: options.timeout
+        }
+      });
+      if (!credential) {
+        return { success: false, error: t("lt.auth.noPasskeySelected", "Kein Passkey ausgew\xE4hlt") };
+      }
+      const response = credential.response;
+      const credentialBody = {
+        id: credential.id,
+        rawId: ltArrayBufferToBase64Url(credential.rawId),
+        type: credential.type,
+        response: {
+          authenticatorData: ltArrayBufferToBase64Url(response.authenticatorData),
+          clientDataJSON: ltArrayBufferToBase64Url(response.clientDataJSON),
+          signature: ltArrayBufferToBase64Url(response.signature),
+          userHandle: response.userHandle ? ltArrayBufferToBase64Url(response.userHandle) : null
+        },
+        clientExtensionResults: credential.getClientExtensionResults?.() || {}
+      };
+      const authResponse = await fetchWithAuth(`${apiBase}/passkey/verify-authentication`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ challengeId: options.challengeId, response: credentialBody })
+      });
+      const result = await authResponse.json();
+      if (!authResponse.ok) {
+        return { success: false, error: result.message || t("lt.auth.passkeyFailed", "Passkey-Anmeldung fehlgeschlagen") };
+      }
+      if (result.user) {
+        setUser(result.user, "cookie");
+        switchToJwtMode().catch(() => {
+        });
+      } else if (result.session?.token) {
+        jwtToken.value = result.session.token;
+        if (authState.value) {
+          authState.value = { ...authState.value, authMode: "jwt" };
+        }
+        console.debug("[LtAuth] Passkey: Stored session token as JWT");
+      }
+      return { success: true, user: result.user, session: result.session };
+    } catch (err) {
+      if (err instanceof Error && err.name === "NotAllowedError") {
+        return { success: false, error: t("lt.auth.passkeyAborted", "Passkey-Authentifizierung wurde abgebrochen") };
+      }
+      return { success: false, error: err instanceof Error ? err.message : t("lt.auth.passkeyFailed", "Passkey-Anmeldung fehlgeschlagen") };
+    } finally {
+      isLoading.value = false;
+    }
+  }
+  async function registerPasskey(name) {
+    isLoading.value = true;
+    try {
+      const apiBase = getApiBase();
+      const optionsResponse = await fetchWithAuth(`${apiBase}/passkey/generate-register-options`, {
+        method: "GET"
+      });
+      if (!optionsResponse.ok) {
+        const error = await optionsResponse.json().catch(() => ({}));
+        return { success: false, error: error.message || t("lt.auth.registerOptionsError", "Konnte Registrierungsoptionen nicht laden") };
+      }
+      const options = await optionsResponse.json();
+      const challengeBuffer = ltBase64UrlToUint8Array(options.challenge).buffer;
+      const userIdBuffer = ltBase64UrlToUint8Array(options.user.id).buffer;
+      const credential = await navigator.credentials.create({
+        publicKey: {
+          challenge: challengeBuffer,
+          rp: options.rp,
+          user: {
+            ...options.user,
+            id: userIdBuffer
+          },
+          pubKeyCredParams: options.pubKeyCredParams,
+          timeout: options.timeout,
+          attestation: options.attestation,
+          authenticatorSelection: options.authenticatorSelection,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          excludeCredentials: (options.excludeCredentials || []).map((cred) => ({
+            ...cred,
+            id: ltBase64UrlToUint8Array(cred.id).buffer
+          }))
+        }
+      });
+      if (!credential) {
+        return { success: false, error: t("lt.auth.passkeyCreationAborted", "Passkey-Erstellung abgebrochen") };
+      }
+      const attestationResponse = credential.response;
+      const credentialBody = {
+        name,
+        // Include challengeId for JWT mode (database challenge storage)
+        challengeId: options.challengeId,
+        response: {
+          id: credential.id,
+          rawId: ltArrayBufferToBase64Url(credential.rawId),
+          type: credential.type,
+          response: {
+            attestationObject: ltArrayBufferToBase64Url(attestationResponse.attestationObject),
+            clientDataJSON: ltArrayBufferToBase64Url(attestationResponse.clientDataJSON),
+            transports: attestationResponse.getTransports?.() || []
+          },
+          clientExtensionResults: credential.getClientExtensionResults?.() || {}
+        }
+      };
+      const registerResponse = await fetchWithAuth(`${apiBase}/passkey/verify-registration`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(credentialBody)
+      });
+      const result = await registerResponse.json();
+      if (!registerResponse.ok) {
+        return { success: false, error: result.message || t("lt.auth.passkeyRegisterFailed", "Passkey-Registrierung fehlgeschlagen") };
+      }
+      return { success: true, passkey: result };
+    } catch (err) {
+      if (err instanceof Error && err.name === "NotAllowedError") {
+        return { success: false, error: t("lt.auth.passkeyCreationAborted", "Passkey-Erstellung wurde abgebrochen") };
+      }
+      return { success: false, error: err instanceof Error ? err.message : t("lt.auth.passkeyRegisterFailed", "Passkey-Registrierung fehlgeschlagen") };
+    } finally {
+      isLoading.value = false;
+    }
+  }
+  return {
+    // Auth state
+    authMode,
+    isAuthenticated,
+    isJwtMode,
+    isLoading: computed(() => isLoading.value),
+    user,
+    // User properties
+    is2FAEnabled,
+    isAdmin,
+    // Auth actions
+    authenticateWithPasskey,
+    changePassword: authClient.changePassword,
+    clearUser,
+    registerPasskey,
+    setUser,
+    signIn,
+    signOut,
+    signUp,
+    validateSession,
+    // JWT management
+    fetchWithAuth,
+    jwtToken,
+    refreshJwtToken,
+    switchToJwtMode,
+    // Better Auth client passthrough
+    passkey: authClient.passkey,
+    twoFactor: authClient.twoFactor
+  };
+}

package/dist/runtime/composables/index.d.ts

@@ -0,0 +1,5 @@
+export { useLtAuth } from './auth/use-lt-auth.js';
+export { useLtAuthClient, ltAuthClient } from './use-lt-auth-client.js';
+export { useLtTusUpload } from './use-lt-tus-upload.js';
+export { useLtFile } from './use-lt-file.js';
+export { useLtShare, type UseLtShareReturn } from './use-lt-share.js';

package/dist/runtime/composables/index.js

@@ -0,0 +1,5 @@
+export { useLtAuth } from "./auth/use-lt-auth.js";
+export { useLtAuthClient, ltAuthClient } from "./use-lt-auth-client.js";
+export { useLtTusUpload } from "./use-lt-tus-upload.js";
+export { useLtFile } from "./use-lt-file.js";
+export { useLtShare } from "./use-lt-share.js";

package/dist/runtime/composables/use-lt-auth-client.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Auth Client Composable
+ *
+ * Provides access to the Better-Auth client singleton.
+ * Use this when you need direct access to the auth client API
+ * (e.g., for 2FA management, passkey operations).
+ *
+ * @example
+ * ```typescript
+ * const authClient = useLtAuthClient();
+ *
+ * // Access 2FA methods
+ * await authClient.twoFactor.enable({ password: 'test' });
+ *
+ * // Access passkey methods
+ * await authClient.passkey.listUserPasskeys();
+ * ```
+ */
+import { type LtAuthClient } from '../lib/auth-client.js';
+/**
+ * Returns the Better-Auth client singleton
+ *
+ * The client is created once and reused across all calls.
+ * Configuration is read from RuntimeConfig on first call.
+ */
+export declare function useLtAuthClient(): LtAuthClient;
+export declare const ltAuthClient: {
+    readonly instance: LtAuthClient;
+};