@lenne.tech/nuxt-extensions 1.0.0 → 1.1.0

package/dist/runtime/locales/de.json

@@ -11,6 +11,10 @@
       "registerOptionsError": "Konnte Registrierungsoptionen nicht laden",
       "sessionExpired": "Sitzung abgelaufen"
     },
+    "error": {
+      "title": "Fehler",
+      "loadFailed": "Fehlerübersetzungen konnten nicht geladen werden"
+    },
     "share": {
       "copied": "Link kopiert",
       "copiedDescription": "Der Link wurde in die Zwischenablage kopiert."

package/dist/runtime/locales/en.json

@@ -11,6 +11,10 @@
       "registerOptionsError": "Could not load registration options",
       "sessionExpired": "Session expired"
     },
+    "error": {
+      "title": "Error",
+      "loadFailed": "Failed to load error translations"
+    },
     "share": {
       "copied": "Link copied",
       "copiedDescription": "The link has been copied to clipboard."

package/dist/runtime/plugins/auth-interceptor.client.d.ts

@@ -9,6 +9,6 @@
  * Note: This is a client-only plugin (.client.ts) since auth state
  * management only makes sense in the browser context.
  */
-import type { NuxtApp } from '#app';
+import type { NuxtApp } from "#app";
 declare const _default: (nuxtApp: NuxtApp) => void;
 export default _default;

package/dist/runtime/plugins/auth-interceptor.client.js

@@ -6,11 +6,18 @@ export default (nuxtApp) => {
   const loginPath = runtimeConfig.loginPath || "/auth/login";
   const configuredPublicPaths = runtimeConfig.interceptor?.publicPaths || [];
   let isHandling401 = false;
-  const defaultPublicPaths = ["/auth/login", "/auth/register", "/auth/forgot-password", "/auth/reset-password", "/auth/2fa"];
+  const defaultPublicPaths = [
+    "/auth/login",
+    "/auth/register",
+    "/auth/forgot-password",
+    "/auth/reset-password",
+    "/auth/2fa"
+  ];
   const publicAuthPaths = [.../* @__PURE__ */ new Set([...defaultPublicPaths, ...configuredPublicPaths])];
   function isPublicAuthRoute() {
-    const route = nuxtApp.$router?.currentRoute?.value;
-    if (!route) return false;
+    const router = nuxtApp.$router;
+    const route = router?.currentRoute?.value;
+    if (!route?.path) return false;
     return publicAuthPaths.some((path) => route.path.startsWith(path));
   }
   function isAuthEndpoint(url) {
@@ -50,7 +57,8 @@ export default (nuxtApp) => {
       if (isAuthenticated.value) {
         console.debug("[LtAuth Interceptor] Session expired, logging out...");
         clearUser();
-        const currentPath = nuxtApp.$router?.currentRoute?.value?.fullPath;
+        const router = nuxtApp.$router;
+        const currentPath = router?.currentRoute?.value?.fullPath;
         const redirectQuery = currentPath && currentPath !== loginPath ? `?redirect=${encodeURIComponent(currentPath)}` : "";
         window.location.href = loginPath + redirectQuery;
       }

package/dist/runtime/plugins/error-translation.client.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Error Translation Plugin
+ *
+ * Automatically loads error translations on app start.
+ * Provides global helper methods: $ltTranslateError, $ltShowErrorToast
+ */
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/error-translation.client.js

@@ -0,0 +1,17 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#imports";
+import { useLtErrorTranslation } from "../composables/use-lt-error-translation.js";
+export default defineNuxtPlugin(async (nuxtApp) => {
+  const runtimeConfig = useRuntimeConfig();
+  const config = runtimeConfig.public?.ltExtensions?.errorTranslation;
+  if (config?.enabled === false) {
+    return;
+  }
+  const { loadTranslations, translateError, showErrorToast } = useLtErrorTranslation();
+  try {
+    await loadTranslations();
+  } catch (error) {
+    console.warn("[LtErrorTranslation] Initial load failed:", error);
+  }
+  nuxtApp.provide("ltTranslateError", translateError);
+  nuxtApp.provide("ltShowErrorToast", showErrorToast);
+});

package/dist/runtime/server/tsconfig.json

@@ -1,3 +1,3 @@
 {
-  "extends": "../../../.nuxt/tsconfig.server.json",
+  "extends": "../../../.nuxt/tsconfig.server.json"
 }

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

@@ -0,0 +1,21 @@
+/**
+ * Testing Utilities for @lenne.tech/nuxt-extensions
+ *
+ * This module exports Playwright test helpers for E2E testing
+ * of Nuxt applications using @lenne.tech/nuxt-extensions.
+ *
+ * @example
+ * ```typescript
+ * // In your test file
+ * import {
+ *   waitForHydration,
+ *   gotoAndWaitForHydration,
+ *   fillInput,
+ *   generateTestUser,
+ *   generateTOTP,
+ * } from '@lenne.tech/nuxt-extensions/testing';
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { waitForHydration, gotoAndWaitForHydration, waitForURLAndHydration, DEFAULT_HYDRATION_TIMEOUT, fillInput, fillInputs, generateTestUser, generateRandomString, generateTOTP, extractTOTPSecret, parseTOTPUrl, waitForElement, waitForNetworkIdle, hasText, getAllText, type TestUser, } from "./playwright-helpers.js";

package/dist/runtime/testing/index.js

@@ -0,0 +1,17 @@
+export {
+  waitForHydration,
+  gotoAndWaitForHydration,
+  waitForURLAndHydration,
+  DEFAULT_HYDRATION_TIMEOUT,
+  fillInput,
+  fillInputs,
+  generateTestUser,
+  generateRandomString,
+  generateTOTP,
+  extractTOTPSecret,
+  parseTOTPUrl,
+  waitForElement,
+  waitForNetworkIdle,
+  hasText,
+  getAllText
+} from "./playwright-helpers.js";

package/dist/runtime/testing/playwright-helpers.d.ts

@@ -0,0 +1,296 @@
+/**
+ * Playwright Test Helpers for Nuxt Applications
+ *
+ * This module provides reusable test utilities for E2E testing
+ * with Playwright in Nuxt projects using @lenne.tech/nuxt-extensions.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   waitForHydration,
+ *   gotoAndWaitForHydration,
+ *   fillInput,
+ *   generateTestUser,
+ *   generateTOTP,
+ * } from '@lenne.tech/nuxt-extensions/testing';
+ *
+ * test('my test', async ({ page }) => {
+ *   await gotoAndWaitForHydration(page, '/auth/login');
+ *   await fillInput(page, 'input[name="email"]', 'test@example.com');
+ * });
+ * ```
+ */
+import type { Page } from "@playwright/test";
+/**
+ * Default timeout for hydration waiting (in milliseconds)
+ */
+export declare const DEFAULT_HYDRATION_TIMEOUT = 15000;
+/**
+ * Wait for Nuxt hydration to complete
+ *
+ * This is essential for Nuxt SSR applications where Vue components
+ * need to be hydrated before they can respond to interactions.
+ *
+ * @param page - Playwright page object
+ * @param options - Configuration options
+ * @param options.timeout - Maximum time to wait (default: 15000ms)
+ *
+ * @example
+ * ```typescript
+ * await waitForHydration(page);
+ * await page.click('button'); // Now safe to interact
+ * ```
+ */
+export declare function waitForHydration(page: Page, options?: {
+    timeout?: number;
+}): Promise<void>;
+/**
+ * Navigate to URL and wait for Nuxt hydration to complete
+ *
+ * Combines page.goto() with hydration waiting. Use this instead of
+ * page.goto() when you need to interact with Vue components immediately.
+ *
+ * @param page - Playwright page object
+ * @param url - URL to navigate to (relative or absolute)
+ * @param options - Configuration options
+ * @param options.timeout - Maximum time to wait for hydration (default: 15000ms)
+ *
+ * @example
+ * ```typescript
+ * await gotoAndWaitForHydration(page, '/auth/login');
+ * // Page is now hydrated and ready for interaction
+ * ```
+ */
+export declare function gotoAndWaitForHydration(page: Page, url: string, options?: {
+    timeout?: number;
+}): Promise<void>;
+/**
+ * Wait for URL navigation and then Nuxt hydration
+ *
+ * Use after form submissions or actions that trigger navigation.
+ * Ensures both the navigation completes AND the new page is hydrated.
+ *
+ * @param page - Playwright page object
+ * @param url - URL pattern to wait for (string or RegExp)
+ * @param options - Configuration options
+ * @param options.timeout - Maximum time to wait for URL (default: 30000ms)
+ * @param options.hydrationTimeout - Maximum time to wait for hydration (default: 15000ms)
+ *
+ * @example
+ * ```typescript
+ * await page.click('button[type="submit"]');
+ * await waitForURLAndHydration(page, /\/dashboard/);
+ * ```
+ */
+export declare function waitForURLAndHydration(page: Page, url: string | RegExp, options?: {
+    timeout?: number;
+    hydrationTimeout?: number;
+}): Promise<void>;
+/**
+ * Fill an input field with proper Vue 3 reactivity support
+ *
+ * Uses keyboard typing instead of Playwright's fill() to properly
+ * trigger Vue's v-model updates. This is necessary because fill()
+ * sets the value directly without firing input events in some cases.
+ *
+ * @param page - Playwright page object
+ * @param selector - CSS selector for the input element
+ * @param value - Value to type into the input
+ * @param options - Configuration options
+ * @param options.delay - Delay between keystrokes in ms (default: 5)
+ * @param options.clear - Whether to clear existing content (default: true)
+ *
+ * @example
+ * ```typescript
+ * await fillInput(page, 'input[name="email"]', 'test@example.com');
+ * await fillInput(page, '#password', 'secret', { delay: 10 });
+ * ```
+ */
+export declare function fillInput(page: Page, selector: string, value: string, options?: {
+    delay?: number;
+    clear?: boolean;
+}): Promise<void>;
+/**
+ * Fill multiple input fields at once
+ *
+ * Convenience function for filling multiple form fields.
+ *
+ * @param page - Playwright page object
+ * @param fields - Object mapping selectors to values
+ * @param options - Configuration options passed to fillInput
+ *
+ * @example
+ * ```typescript
+ * await fillInputs(page, {
+ *   'input[name="email"]': 'test@example.com',
+ *   'input[name="password"]': 'secret123',
+ * });
+ * ```
+ */
+export declare function fillInputs(page: Page, fields: Record<string, string>, options?: {
+    delay?: number;
+    clear?: boolean;
+}): Promise<void>;
+/**
+ * Test user credentials interface
+ */
+export interface TestUser {
+    email: string;
+    password: string;
+    name: string;
+}
+/**
+ * Generate unique test user credentials
+ *
+ * Creates unique email, password, and name for test isolation.
+ * Each call generates different credentials to avoid test conflicts.
+ *
+ * @param prefix - Prefix for the email address (default: 'e2e')
+ * @returns Object with email, password, and name
+ *
+ * @example
+ * ```typescript
+ * const user = generateTestUser('auth-test');
+ * // { email: 'auth-test-abc123@test.com', password: 'TestPassabc123!', name: 'E2E Test User auth-test' }
+ * ```
+ */
+export declare function generateTestUser(prefix?: string): TestUser;
+/**
+ * Generate a random string for test data
+ *
+ * @param length - Length of the string (default: 8)
+ * @param charset - Characters to use (default: alphanumeric)
+ *
+ * @example
+ * ```typescript
+ * const id = generateRandomString(12);
+ * const code = generateRandomString(6, '0123456789');
+ * ```
+ */
+export declare function generateRandomString(length?: number, charset?: string): string;
+/**
+ * Generate a TOTP code from a secret (RFC 6238)
+ *
+ * Implements the Time-based One-Time Password algorithm for testing
+ * 2FA functionality. Compatible with Google Authenticator and similar apps.
+ *
+ * @param secret - Base32-encoded TOTP secret
+ * @param options - Configuration options
+ * @param options.digits - Number of digits in the code (default: 6)
+ * @param options.period - Time period in seconds (default: 30)
+ * @param options.algorithm - Hash algorithm (default: 'sha1')
+ * @returns 6-digit TOTP code as string
+ *
+ * @example
+ * ```typescript
+ * const secret = 'JBSWY3DPEHPK3PXP';
+ * const code = generateTOTP(secret);
+ * await page.fill('input[name="code"]', code);
+ * ```
+ */
+export declare function generateTOTP(secret: string, options?: {
+    digits?: number;
+    period?: number;
+    algorithm?: "sha1" | "sha256" | "sha512";
+}): string;
+/**
+ * Extract TOTP secret from otpauth:// URL
+ *
+ * Parses the secret parameter from a TOTP QR code URL.
+ *
+ * @param otpauthUrl - The otpauth:// URL (or data URL containing it)
+ * @returns The extracted secret, or null if not found
+ *
+ * @example
+ * ```typescript
+ * const qrSrc = await page.locator('img[alt="QR Code"]').getAttribute('src');
+ * const secret = extractTOTPSecret(qrSrc);
+ * const code = generateTOTP(secret);
+ * ```
+ */
+export declare function extractTOTPSecret(otpauthUrl: string): string | null;
+/**
+ * Extract all parameters from otpauth:// URL
+ *
+ * @param otpauthUrl - The otpauth:// URL
+ * @returns Object with issuer, account, secret, algorithm, digits, period
+ *
+ * @example
+ * ```typescript
+ * const params = parseTOTPUrl(otpauthUrl);
+ * console.log(params.issuer, params.secret);
+ * ```
+ */
+export declare function parseTOTPUrl(otpauthUrl: string): {
+    issuer: string | null;
+    account: string | null;
+    secret: string | null;
+    algorithm: string;
+    digits: number;
+    period: number;
+};
+/**
+ * Wait for an element to be visible and stable
+ *
+ * Useful for waiting for animations to complete or elements to settle.
+ *
+ * @param page - Playwright page object
+ * @param selector - CSS selector for the element
+ * @param options - Configuration options
+ * @param options.timeout - Maximum time to wait (default: 10000ms)
+ * @param options.stable - Wait for element to be stable (default: true)
+ *
+ * @example
+ * ```typescript
+ * await waitForElement(page, '.modal-content');
+ * ```
+ */
+export declare function waitForElement(page: Page, selector: string, options?: {
+    timeout?: number;
+    stable?: boolean;
+}): Promise<void>;
+/**
+ * Wait for network to be idle
+ *
+ * Useful for waiting for all API calls to complete.
+ *
+ * @param page - Playwright page object
+ * @param options - Configuration options
+ * @param options.timeout - Maximum time to wait (default: 30000ms)
+ *
+ * @example
+ * ```typescript
+ * await page.click('button[type="submit"]');
+ * await waitForNetworkIdle(page);
+ * ```
+ */
+export declare function waitForNetworkIdle(page: Page, options?: {
+    timeout?: number;
+}): Promise<void>;
+/**
+ * Check if an element contains specific text
+ *
+ * @param page - Playwright page object
+ * @param selector - CSS selector for the element
+ * @param text - Text to search for
+ * @returns true if text is found
+ *
+ * @example
+ * ```typescript
+ * const hasError = await hasText(page, '.error', 'Invalid email');
+ * ```
+ */
+export declare function hasText(page: Page, selector: string, text: string): Promise<boolean>;
+/**
+ * Get all text content from matching elements
+ *
+ * @param page - Playwright page object
+ * @param selector - CSS selector for the elements
+ * @returns Array of text content
+ *
+ * @example
+ * ```typescript
+ * const errors = await getAllText(page, '.error-message');
+ * ```
+ */
+export declare function getAllText(page: Page, selector: string): Promise<string[]>;

package/dist/runtime/testing/playwright-helpers.js

@@ -0,0 +1,127 @@
+import * as crypto from "crypto";
+export const DEFAULT_HYDRATION_TIMEOUT = 15e3;
+export async function waitForHydration(page, options = {}) {
+  const timeout = options.timeout ?? DEFAULT_HYDRATION_TIMEOUT;
+  await page.waitForFunction(() => window.useNuxtApp?.()?.isHydrating === false, {
+    timeout
+  });
+}
+export async function gotoAndWaitForHydration(page, url, options = {}) {
+  await page.goto(url);
+  await waitForHydration(page, options);
+}
+export async function waitForURLAndHydration(page, url, options = {}) {
+  const { timeout = 3e4, hydrationTimeout } = options;
+  await page.waitForURL(url, { timeout });
+  await waitForHydration(page, { timeout: hydrationTimeout });
+}
+export async function fillInput(page, selector, value, options = {}) {
+  const { delay = 5, clear = true } = options;
+  const locator = page.locator(selector);
+  await locator.click();
+  if (clear) {
+    await page.keyboard.press("Control+a");
+    await page.keyboard.press("Backspace");
+  }
+  await page.keyboard.type(value, { delay });
+}
+export async function fillInputs(page, fields, options = {}) {
+  for (const [selector, value] of Object.entries(fields)) {
+    await fillInput(page, selector, value, options);
+  }
+}
+export function generateTestUser(prefix = "e2e") {
+  const testId = Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+  return {
+    email: `${prefix}-${testId}@test.com`,
+    password: `TestPass${testId}!`,
+    name: `E2E Test User ${prefix}`
+  };
+}
+export function generateRandomString(length = 8, charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789") {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += charset.charAt(Math.floor(Math.random() * charset.length));
+  }
+  return result;
+}
+export function generateTOTP(secret, options = {}) {
+  const { digits = 6, period = 30, algorithm = "sha1" } = options;
+  const base32Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+  let bits = "";
+  for (const char of secret.toUpperCase().replace(/=/g, "")) {
+    const val = base32Chars.indexOf(char);
+    if (val === -1) continue;
+    bits += val.toString(2).padStart(5, "0");
+  }
+  const keyBytes = Buffer.alloc(Math.floor(bits.length / 8));
+  for (let i = 0; i < keyBytes.length; i++) {
+    keyBytes[i] = parseInt(bits.slice(i * 8, (i + 1) * 8), 2);
+  }
+  const counter = Math.floor(Date.now() / 1e3 / period);
+  const counterBuffer = Buffer.alloc(8);
+  counterBuffer.writeBigUInt64BE(BigInt(counter));
+  const hmac = crypto.createHmac(algorithm, keyBytes);
+  hmac.update(counterBuffer);
+  const hash = hmac.digest();
+  const offset = (hash[hash.length - 1] ?? 0) & 15;
+  const code = ((hash[offset] ?? 0) & 127) << 24 | ((hash[offset + 1] ?? 0) & 255) << 16 | ((hash[offset + 2] ?? 0) & 255) << 8 | (hash[offset + 3] ?? 0) & 255;
+  const mod = Math.pow(10, digits);
+  return (code % mod).toString().padStart(digits, "0");
+}
+export function extractTOTPSecret(otpauthUrl) {
+  const decoded = decodeURIComponent(otpauthUrl);
+  const match = decoded.match(/secret=([A-Z2-7]+)/i);
+  return match?.[1]?.toUpperCase() ?? null;
+}
+export function parseTOTPUrl(otpauthUrl) {
+  const decoded = decodeURIComponent(otpauthUrl);
+  const pathMatch = decoded.match(/otpauth:\/\/totp\/(?:([^:]+):)?([^?]+)/);
+  const getParam = (name) => {
+    const match = decoded.match(new RegExp(`${name}=([^&]+)`, "i"));
+    return match?.[1] ?? null;
+  };
+  return {
+    issuer: getParam("issuer") ?? pathMatch?.[1] ?? null,
+    account: pathMatch?.[2] ?? null,
+    secret: getParam("secret")?.toUpperCase() ?? null,
+    algorithm: getParam("algorithm") || "SHA1",
+    digits: parseInt(getParam("digits") || "6", 10),
+    period: parseInt(getParam("period") || "30", 10)
+  };
+}
+export async function waitForElement(page, selector, options = {}) {
+  const { timeout = 1e4, stable = true } = options;
+  const locator = page.locator(selector);
+  await locator.waitFor({ state: "visible", timeout });
+  if (stable) {
+    await locator.evaluate((el) => {
+      return new Promise((resolve) => {
+        if (!el.getAnimations || el.getAnimations().length === 0) {
+          resolve();
+          return;
+        }
+        Promise.all(el.getAnimations().map((a) => a.finished)).then(() => resolve());
+      });
+    });
+  }
+}
+export async function waitForNetworkIdle(page, options = {}) {
+  const { timeout = 3e4 } = options;
+  await page.waitForLoadState("networkidle", { timeout });
+}
+export async function hasText(page, selector, text) {
+  const locator = page.locator(selector);
+  const content = await locator.textContent();
+  return content?.includes(text) ?? false;
+}
+export async function getAllText(page, selector) {
+  const locators = page.locator(selector);
+  const count = await locators.count();
+  const texts = [];
+  for (let i = 0; i < count; i++) {
+    const text = await locators.nth(i).textContent();
+    if (text) texts.push(text.trim());
+  }
+  return texts;
+}

package/dist/runtime/types/auth.d.ts

@@ -1,4 +1,4 @@
-import type { ComputedRef, Ref } from 'vue';
+import type { ComputedRef, Ref } from "vue";
 /**
  * User type for Better Auth session
  * Compatible with @lenne.tech/nest-server IAM module
@@ -20,7 +20,7 @@ export interface LtUser {
  * - 'cookie': Primary mode using HttpOnly session cookies (more secure)
  * - 'jwt': Fallback mode using JWT tokens in Authorization header
  */
-export type LtAuthMode = 'cookie' | 'jwt';
+export type LtAuthMode = "cookie" | "jwt";
 /**
  * Stored auth state (persisted in cookie for SSR compatibility)
  */

package/dist/runtime/types/error.d.ts

@@ -0,0 +1,48 @@
+import type { ComputedRef, Ref } from "vue";
+/**
+ * Backend error translation response format
+ * Matches the response from GET /api/i18n/errors/:locale
+ */
+export interface LtErrorTranslationResponse {
+    errors: Record<string, string>;
+}
+/**
+ * Parsed error from backend
+ * Contains both the original and translated messages
+ */
+export interface LtParsedError {
+    /** Raw error code (e.g., LTNS_0100) or null if no code found */
+    code: string | null;
+    /** Original developer message from the backend */
+    developerMessage: string;
+    /** Translated user-friendly message */
+    translatedMessage: string;
+}
+/**
+ * Error translation module options
+ */
+export interface LtErrorTranslationModuleOptions {
+    /** Enable error translation feature (default: true) */
+    enabled?: boolean;
+    /** Default locale if not detected (default: 'de') */
+    defaultLocale?: string;
+}
+/**
+ * Return type for useLtErrorTranslation composable
+ */
+export interface UseLtErrorTranslationReturn {
+    /** Translate an error message or code to user-friendly message */
+    translateError: (errorOrMessage: unknown) => string;
+    /** Parse a backend error to extract code and messages */
+    parseError: (errorOrMessage: unknown) => LtParsedError;
+    /** Show translated error as toast notification */
+    showErrorToast: (errorOrMessage: unknown, title?: string) => void;
+    /** Manually load translations for a locale */
+    loadTranslations: (locale?: string) => Promise<void>;
+    /** Check if translations are loaded for current locale */
+    isLoaded: ComputedRef<boolean>;
+    /** Check if translations are currently loading */
+    isLoading: Ref<boolean>;
+    /** Current detected locale */
+    currentLocale: ComputedRef<string>;
+}

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

@@ -1,3 +1,4 @@
-export type { LtAuthClientConfig, LtAuthMode, LtAuthResponse, LtAuthState, LtPasskeyAuthResult, LtPasskeyRegisterResult, LtUser, UseLtAuthReturn, } from './auth.js';
-export type { LtFileInfo, LtUploadItem, LtUploadOptions, LtUploadProgress, LtUploadStatus, UseLtFileReturn, UseLtTusUploadReturn, } from './upload.js';
-export type { LtAuthModuleOptions, LtExtensionsModuleOptions, LtExtensionsPublicRuntimeConfig, LtI18nModuleOptions, LtTusModuleOptions, } from './module.js';
+export type { LtAuthClientConfig, LtAuthMode, LtAuthResponse, LtAuthState, LtPasskeyAuthResult, LtPasskeyRegisterResult, LtUser, UseLtAuthReturn, } from "./auth.js";
+export type { LtFileInfo, LtUploadItem, LtUploadOptions, LtUploadProgress, LtUploadStatus, UseLtFileReturn, UseLtTusUploadReturn, } from "./upload.js";
+export type { LtAuthModuleOptions, LtErrorTranslationModuleOptions, LtExtensionsModuleOptions, LtExtensionsPublicRuntimeConfig, LtI18nModuleOptions, LtTusModuleOptions, } from "./module.js";
+export type { LtErrorTranslationResponse, LtParsedError, UseLtErrorTranslationReturn, } from "./error.js";