@lenne.tech/nuxt-extensions 1.6.0 → 1.7.1

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

@@ -0,0 +1,521 @@
+import type { ComputedRef, DeepReadonly, Ref } from 'vue';
+/** Execution mode for a prompt. `auto` = reactive agent loop, `plan` = validate-all-then-execute. */
+export type LtAiMode = 'auto' | 'plan';
+/**
+ * Input for a single AI run — sent to `POST /ai/prompt` | `POST /ai/stream`.
+ *
+ * Distinct from {@link LtAiPromptInput} (CRUD input for the user-facing
+ * `LtAiPrompt` entity). Pre-1.7.0 release builds called this type
+ * `LtAiPromptInput`; renamed to avoid a silent declaration merge with the
+ * CRUD input introduced for `useLtAiPrompts()`.
+ */
+export interface LtAiPromptRunInput {
+    /** Confirm execution of actions that required confirmation in a previous turn. */
+    confirm?: boolean;
+    /** Id of the connection to use (omit to let the backend resolution chain decide). */
+    connectionId?: string;
+    /** Conversation id for multi-turn continuation. */
+    conversationId?: string;
+    /** Structured context the assistant should consider. */
+    context?: Record<string, unknown>;
+    /** Untrusted client metadata (current URL, navigation, console logs) for enrichment. */
+    metadata?: Record<string, unknown>;
+    /** Execution mode (defaults to the backend's `ai.defaultMode`). */
+    mode?: LtAiMode;
+    /** The user's prompt text. */
+    prompt: string;
+    /** Override the admin default for requiring confirmation of mutating actions. */
+    requireConfirmation?: boolean;
+}
+/** A tool action executed (or planned/pending) during a run. */
+export interface LtAiAction {
+    arguments?: Record<string, any>;
+    name: string;
+    result?: any;
+    success?: boolean;
+}
+/** Token usage of a single run (best effort). */
+export interface LtAiUsage {
+    completionTokens?: number;
+    promptTokens?: number;
+    totalTokens?: number;
+}
+/** Compact token-budget summary attached to every response. */
+export interface LtAiBudgetSummary {
+    /** Effective limit (user → tenant → LLM context window → null). Null = no limit. */
+    maxTokens?: number;
+    promptTokens?: number;
+    remainingTokens?: number;
+    resetAt?: string;
+    /** Which scope yielded maxTokens: 'user', 'tenant' or 'llm'. */
+    scope?: 'llm' | 'tenant' | 'user';
+    usedTokens?: number;
+}
+/** Structured response of a prompt run (`CoreAiResponse`). */
+export interface LtAiResponse {
+    actions?: LtAiAction[];
+    budget?: LtAiBudgetSummary;
+    connectionId?: string;
+    /** Context-window utilization at the end of the run (used/total tokens). */
+    contextWindow?: {
+        total: number;
+        used: number;
+    };
+    conversationId?: string;
+    data?: any;
+    denied?: boolean;
+    deniedActions?: LtAiAction[];
+    iterations?: number;
+    pendingActions?: LtAiAction[];
+    pendingQuestion?: {
+        options?: {
+            label: string;
+            value: string;
+        }[];
+        question: string;
+    };
+    plan?: LtAiAction[];
+    requiresConfirmation?: boolean;
+    text: string;
+    usage?: LtAiUsage;
+}
+/** Server-sent event emitted by `POST /ai/stream`. */
+export type LtAiStreamEvent = {
+    action: LtAiAction;
+    type: 'action';
+} | {
+    message: string;
+    type: 'error';
+} | {
+    response: LtAiResponse;
+    type: 'final';
+} | {
+    token: string;
+    type: 'token';
+};
+/** Callbacks for {@link UseLtAiReturn.promptStream}. */
+export interface LtAiStreamHandlers {
+    onAction?: (action: LtAiAction) => void;
+    onError?: (message: string) => void;
+    onEvent?: (event: LtAiStreamEvent) => void;
+    onFinal?: (response: LtAiResponse) => void;
+    onToken?: (token: string) => void;
+}
+/** A single chat message in {@link UseLtAiChatReturn}. */
+export interface LtAiMessage {
+    actions?: LtAiAction[];
+    budget?: LtAiBudgetSummary;
+    content: string;
+    createdAt?: string;
+    denied?: boolean;
+    error?: boolean;
+    /** Pending actions awaiting confirmation (assistant turns only). */
+    pendingActions?: LtAiAction[];
+    /** Whether this assistant turn is still streaming. */
+    pending?: boolean;
+    /** Whether this assistant turn awaits a confirmation to proceed. */
+    requiresConfirmation?: boolean;
+    role: 'assistant' | 'user';
+}
+/** A non-sensitive connection the current user/tenant may use. */
+export interface LtAiAvailableConnection {
+    id: string;
+    isDefault?: boolean;
+    locked?: boolean;
+    model?: string;
+    name?: string;
+    selected?: boolean;
+}
+/** Usage for a single scope (user or tenant). */
+export interface LtAiUsageScope {
+    maxPrompts?: number;
+    maxTokens?: number;
+    period: string;
+    refId?: string;
+    remainingPrompts?: number;
+    remainingTokens?: number;
+    resetAt?: string;
+    scope: string;
+    usedPrompts: number;
+    usedTokens: number;
+}
+/** Full usage info (`GET /ai/usage`). */
+export interface LtAiUsageInfo {
+    tenant?: LtAiUsageScope;
+    user?: LtAiUsageScope;
+}
+/** Admin view of a connection (`apiKey` is never returned — only `hasApiKey`). */
+export interface LtAiConnection {
+    apiKeyEnv?: string;
+    baseUrl?: string;
+    capabilities?: string[];
+    defaultMaxTokens?: number;
+    defaultTemperature?: number;
+    description?: string;
+    enabled?: boolean;
+    enforced?: boolean;
+    enforcedTenantIds?: string[];
+    hasApiKey?: boolean;
+    id: string;
+    isDefault?: boolean;
+    model?: string;
+    name?: string;
+    providerType?: string;
+    supportsJsonResponse?: boolean;
+    supportsNativeTools?: boolean;
+    supportsVision?: boolean;
+    tenantIds?: string[];
+}
+/** Input to create/update a connection (`apiKey`: value sets, '' clears, omit leaves). */
+export interface LtAiConnectionInput {
+    apiKey?: string;
+    apiKeyEnv?: string;
+    baseUrl?: string;
+    defaultMaxTokens?: number;
+    defaultTemperature?: number;
+    description?: string;
+    enabled?: boolean;
+    enforced?: boolean;
+    enforcedTenantIds?: string[];
+    isDefault?: boolean;
+    model?: string;
+    name?: string;
+    providerType?: string;
+    supportsJsonResponse?: boolean;
+    supportsNativeTools?: boolean;
+    supportsVision?: boolean;
+    tenantIds?: string[];
+}
+/** A tenant/user connection preference. */
+export interface LtAiConnectionPreference {
+    connectionId: string;
+    enforced?: boolean;
+    id?: string;
+    refId: string;
+    scope: 'tenant' | 'user';
+}
+/** A per-user/per-tenant budget-limit override. */
+export interface LtAiBudgetLimit {
+    id?: string;
+    maxPrompts?: number;
+    maxTokens?: number;
+    period?: 'day' | 'month' | 'none';
+    refId: string;
+    scope: 'tenant' | 'user';
+}
+/** An AI interaction audit record. */
+export interface LtAiInteraction {
+    actions?: {
+        name: string;
+        success: boolean;
+    }[];
+    completionTokens?: number;
+    connectionId?: string;
+    createdAt?: string;
+    id: string;
+    iterations?: number;
+    prompt?: string;
+    promptTokens?: number;
+    responseText?: string;
+    tenantId?: string;
+    totalTokens?: number;
+    userId?: string;
+}
+/**
+ * An admin-editable AI slot — a logical building block of the SYSTEM prompt
+ * (e.g. `base`, `permissions`, `anti_hallucination`, `tool_catalog`).
+ * The backend ships built-in defaults for every key; a row here OVERRIDES the
+ * default for its `key` (optionally scoped by `locale`/`capability`).
+ * When multi-tenancy is active, slots are tenant-scoped.
+ */
+export interface LtAiSlot {
+    /** Capability scope: 'all', 'native' or 'emulated'. */
+    capability?: string;
+    /** Slot text (supports {{placeholders}}). */
+    content: string;
+    createdAt?: string;
+    /** Admin-facing description of the slot. */
+    description?: string;
+    /** Whether the slot is included in the prompt. */
+    enabled?: boolean;
+    id: string;
+    /** Logical prompt slot key (e.g. 'base', 'permissions', 'anti_hallucination'). */
+    key: string;
+    /** Locale (e.g. 'en', 'de'); empty = all languages. */
+    locale?: string;
+    /** Assembly order (ascending). */
+    order?: number;
+    /** Tenant id the slot applies to (auto-set; undefined = system-wide). */
+    tenantId?: string;
+    updatedAt?: string;
+}
+/** Input to create/update an admin AI slot. */
+export interface LtAiSlotInput {
+    capability?: string;
+    content?: string;
+    description?: string;
+    enabled?: boolean;
+    key?: string;
+    locale?: string;
+    order?: number;
+}
+/**
+ * Effective slot for the admin UI — framework defaults + tenant overrides +
+ * tenant customs in one list. The `isSystem` / `isOverride` flags drive which
+ * actions the UI renders:
+ *  - `isSystem: true`  → virtual default row (no `id`). Action: "Bearbeiten" → POST creates an override.
+ *  - `isOverride: true` → tenant row that overrides a system default. Action: "Zurücksetzen" → reset.
+ *  - else               → custom tenant slot. Action: "Löschen" → real delete (no restore).
+ */
+export interface LtAiEffectiveSlot {
+    capability?: string;
+    content: string;
+    description?: string;
+    enabled: boolean;
+    id?: string;
+    /** True when a tenant row overrides a framework default. */
+    isOverride: boolean;
+    /** True for built-in framework defaults (no DB row). */
+    isSystem: boolean;
+    key: string;
+    locale?: string;
+    order: number;
+    scope?: string;
+    /** System-default key this row overrides (only on overrides). */
+    systemKey?: string;
+    tenantId?: string;
+}
+/**
+ * Public metadata of a registered placeholder — returned by the placeholders
+ * endpoint. Used by the slot / prompt editors to render a "what can I insert"
+ * hint sidebar dynamically (no hard-coded list in the frontend).
+ */
+export interface LtAiPlaceholder {
+    /** One-sentence description shown in the helper sidebar. */
+    description: string;
+    /** Optional example value (tooltip). */
+    example?: string;
+    /** Token name without curly braces (e.g. `'roles'` matches `{{roles}}`). */
+    name: string;
+}
+/**
+ * A learned prompt hint from the governed self-improvement loop. Only `approved`
+ * + enabled hints reach the prompt; hints only ever ADD guidance and can never
+ * relax the backend-enforced security core.
+ */
+export interface LtAiPromptHint {
+    /** Guidance text added to the prompt when approved. */
+    content: string;
+    createdAt?: string;
+    /** Whether the hint is active. */
+    enabled?: boolean;
+    id: string;
+    /** Number of times the failure pattern was observed. */
+    occurrences?: number;
+    /** Scope the hint applies to (e.g. a tool name); empty = global. */
+    scope?: string;
+    /** Governance status: 'suggested', 'approved' or 'rejected'. */
+    status?: string;
+    /** Failure-pattern identifier that produced the hint. */
+    trigger?: string;
+    updatedAt?: string;
+}
+/** Input to create/update a learned prompt hint (typically approve/reject or edit). */
+export interface LtAiPromptHintInput {
+    content?: string;
+    enabled?: boolean;
+    occurrences?: number;
+    scope?: string;
+    status?: string;
+    trigger?: string;
+}
+/**
+ * A user-facing prompt ("Vorlage") — a short, named piece of text the user
+ * can insert into the chat input with one click. Different from
+ * {@link LtAiSlot}, which is the admin-only system-prompt building block.
+ *
+ * Visibility scopes:
+ *  - `user`   — only the owner sees it ("private", default).
+ *  - `tenant` — all members of the owner's tenant see it ("public").
+ */
+export interface LtAiPrompt {
+    /** The prompt text inserted into the chat input (may contain placeholders). */
+    content: string;
+    createdAt?: string;
+    /** Optional description. */
+    description?: string;
+    /** Whether the prompt is active (disabled prompts are hidden). */
+    enabled?: boolean;
+    /** Optional icon hint (lucide name or single emoji). */
+    icon?: string;
+    id: string;
+    /** Display label shown in the picker. */
+    name: string;
+    /** Owner user id (set automatically by the server). */
+    ownerId?: string;
+    /** Sort order in the picker (ascending). */
+    order?: number;
+    /** Visibility scope (`'user'` | `'tenant'` | `'global'`). */
+    scope: string;
+    /** Tenant id when `scope === 'tenant'` (set automatically by the server). */
+    tenantId?: string;
+    updatedAt?: string;
+}
+/**
+ * Input to create/update a {@link LtAiPrompt} (user-facing "Vorlage").
+ *
+ * Distinct from {@link LtAiPromptRunInput} (the payload for `useLtAi.prompt()`).
+ * Used by `useLtAiPrompts().create()` / `.update()`.
+ */
+export interface LtAiPromptInput {
+    content?: string;
+    description?: string;
+    enabled?: boolean;
+    icon?: string;
+    name?: string;
+    order?: number;
+    scope?: string;
+}
+export interface UseLtAiReturn {
+    error: DeepReadonly<Ref<null | string>>;
+    loading: DeepReadonly<Ref<boolean>>;
+    prompt: (input: LtAiPromptRunInput) => Promise<LtAiResponse>;
+    promptStream: (input: LtAiPromptRunInput, handlers?: LtAiStreamHandlers, options?: {
+        signal?: AbortSignal;
+    }) => Promise<LtAiResponse | undefined>;
+    streaming: DeepReadonly<Ref<boolean>>;
+}
+export interface UseLtAiChatOptions {
+    /** Fixed connection id (or a ref) to use for every turn. */
+    connectionId?: Ref<string | undefined> | string;
+    /** Existing conversation id to continue. */
+    conversationId?: string;
+    /**
+     * Cap the local `messages` array. When the cap is exceeded after a new push,
+     * the oldest entries are removed. Use this for long-running chats to prevent
+     * unbounded memory growth. Server-side conversation history is unaffected.
+     */
+    maxMessages?: number;
+    /** Producer for per-turn client metadata (e.g. current URL). */
+    metadata?: () => Record<string, unknown>;
+    /** Execution mode for every turn. */
+    mode?: LtAiMode;
+    /** Whether to stream responses (default true). */
+    stream?: boolean;
+}
+export interface UseLtAiChatReturn {
+    budget: DeepReadonly<Ref<LtAiBudgetSummary | null>>;
+    clear: () => void;
+    confirm: () => Promise<void>;
+    /** Context-window utilization of the latest assistant turn (used/total tokens). */
+    contextWindow: DeepReadonly<Ref<{
+        total: number;
+        used: number;
+    } | null>>;
+    conversationId: DeepReadonly<Ref<string | undefined>>;
+    error: DeepReadonly<Ref<null | string>>;
+    messages: Readonly<Ref<LtAiMessage[]>>;
+    requiresConfirmation: ComputedRef<boolean>;
+    send: (content: string) => Promise<void>;
+    stop: () => void;
+    streaming: DeepReadonly<Ref<boolean>>;
+}
+export interface UseLtAiConnectionsReturn {
+    connections: DeepReadonly<Ref<LtAiAvailableConnection[]>>;
+    error: DeepReadonly<Ref<null | string>>;
+    loading: DeepReadonly<Ref<boolean>>;
+    load: () => Promise<void>;
+    locked: ComputedRef<boolean>;
+    select: (connectionId: string) => Promise<void>;
+    selected: ComputedRef<LtAiAvailableConnection | undefined>;
+}
+export interface UseLtAiUsageReturn {
+    error: DeepReadonly<Ref<null | string>>;
+    loading: DeepReadonly<Ref<boolean>>;
+    load: () => Promise<void>;
+    usage: DeepReadonly<Ref<LtAiUsageInfo | null>>;
+}
+/**
+ * User-facing prompt composable. Lets any signed-in user manage their own
+ * prompts ("Vorlagen") and use the visible ones (own private + tenant public)
+ * in a chat.
+ */
+export interface UseLtAiPromptsReturn {
+    create: (input: LtAiPromptInput) => Promise<LtAiPrompt>;
+    error: DeepReadonly<Ref<null | string>>;
+    load: () => Promise<void>;
+    loading: DeepReadonly<Ref<boolean>>;
+    prompts: DeepReadonly<Ref<LtAiPrompt[]>>;
+    remove: (id: string) => Promise<LtAiPrompt>;
+    update: (id: string, input: LtAiPromptInput) => Promise<LtAiPrompt>;
+}
+/**
+ * Admin AI composable surface — headless on purpose: every method returns the
+ * raw backend response. No shared `loading` / `error` refs because admin
+ * screens typically need per-row spinners and per-action toasts that a single
+ * shared ref cannot model. Wire each call to your UI layer's loading/error
+ * scheme.
+ *
+ * All endpoints are server-side `@Restricted(ADMIN)`; the composable itself
+ * does not enforce role. Render admin UI behind a frontend route guard for UX,
+ * but trust the backend for authorization.
+ */
+export interface UseLtAiAdminReturn {
+    /** Create a per-user/per-tenant budget limit override (POST /ai/budget-limits). */
+    createBudgetLimit: (input: LtAiBudgetLimit) => Promise<LtAiBudgetLimit>;
+    /** Create a connection. `input.apiKey` is write-only; the response never echoes it. */
+    createConnection: (input: LtAiConnectionInput) => Promise<LtAiConnection>;
+    /** Create a learned prompt hint (typically used to manually approve/reject). */
+    createPromptHint: (input: LtAiPromptHintInput) => Promise<LtAiPromptHint>;
+    /** Create a tenant-scoped system-prompt slot row (overrides framework default for `key`). */
+    createSlot: (input: LtAiSlotInput) => Promise<LtAiSlot>;
+    deleteBudgetLimit: (id: string) => Promise<LtAiBudgetLimit>;
+    deleteConnection: (id: string) => Promise<LtAiConnection>;
+    /** Delete a connection preference by its preference id (NOT the user/tenant id). */
+    deletePreference: (id: string) => Promise<LtAiConnectionPreference>;
+    deletePromptHint: (id: string) => Promise<LtAiPromptHint>;
+    deleteSlot: (id: string) => Promise<LtAiSlot>;
+    /**
+     * Re-detect a connection's `capabilities` / `supportsNativeTools` / `supportsVision`
+     * by probing the provider. Mutates the persisted connection row.
+     */
+    detectCapabilities: (id: string) => Promise<LtAiConnection>;
+    /** Returns the connection WITHOUT the `apiKey` (only `hasApiKey: boolean`). */
+    getConnection: (id: string) => Promise<LtAiConnection>;
+    listBudgetLimits: () => Promise<LtAiBudgetLimit[]>;
+    listConnections: () => Promise<LtAiConnection[]>;
+    /** Effective slots view — framework defaults overlaid by tenant overrides + tenant customs. */
+    listEffectiveSlots: () => Promise<LtAiEffectiveSlot[]>;
+    /** Recent AI interactions (audit log, ADMIN-only). */
+    listInteractions: () => Promise<LtAiInteraction[]>;
+    listPreferences: () => Promise<LtAiConnectionPreference[]>;
+    listPromptHints: () => Promise<LtAiPromptHint[]>;
+    /** List ONLY tenant overrides + customs (not the framework defaults — use `listEffectiveSlots` for that). */
+    listSlots: () => Promise<LtAiSlot[]>;
+    /** Reset a tenant override → framework default applies again. */
+    resetSlot: (id: string) => Promise<boolean>;
+    /**
+     * Upsert a connection preference for the given `refId` (user or tenant) +
+     * `scope`. Replaces the existing row for that scope if present.
+     */
+    setPreference: (input: LtAiConnectionPreference) => Promise<LtAiConnectionPreference>;
+    updateBudgetLimit: (id: string, input: LtAiBudgetLimit) => Promise<LtAiBudgetLimit>;
+    /**
+     * Update a connection. `input.apiKey`: pass the new value to set, an empty
+     * string `''` to clear, omit to leave the stored key unchanged.
+     */
+    updateConnection: (id: string, input: LtAiConnectionInput) => Promise<LtAiConnection>;
+    updatePromptHint: (id: string, input: LtAiPromptHintInput) => Promise<LtAiPromptHint>;
+    updateSlot: (id: string, input: LtAiSlotInput) => Promise<LtAiSlot>;
+}
+/**
+ * Placeholder list composable. Loads the runtime placeholder registry from
+ * the backend (`GET /ai/placeholders`) so slot / prompt editors can render
+ * a dynamic helper sidebar without hard-coding any names in the frontend.
+ */
+export interface UseLtAiPlaceholdersReturn {
+    error: DeepReadonly<Ref<null | string>>;
+    load: () => Promise<void>;
+    loading: DeepReadonly<Ref<boolean>>;
+    placeholders: DeepReadonly<Ref<LtAiPlaceholder[]>>;
+}

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

@@ -1,4 +1,5 @@
 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 { LtAuthCookieNamesOptions, LtAuthModuleOptions, LtErrorTranslationModuleOptions, LtExtensionsModuleOptions, LtExtensionsPublicRuntimeConfig, LtI18nModuleOptions, LtSystemSetupModuleOptions, LtTusModuleOptions, } from './module.js';
+export type { LtAiModuleOptions, LtAuthCookieNamesOptions, LtAuthModuleOptions, LtErrorTranslationModuleOptions, LtExtensionsModuleOptions, LtExtensionsPublicRuntimeConfig, LtI18nModuleOptions, LtSystemSetupModuleOptions, LtTusModuleOptions, } from './module.js';
 export type { LtErrorTranslationResponse, LtParsedError, UseLtErrorTranslationReturn } from './error.js';
+export type { LtAiAction, LtAiAvailableConnection, LtAiBudgetLimit, LtAiBudgetSummary, LtAiConnection, LtAiConnectionInput, LtAiConnectionPreference, LtAiEffectiveSlot, LtAiInteraction, LtAiMessage, LtAiMode, LtAiPlaceholder, LtAiPrompt, LtAiPromptHint, LtAiPromptHintInput, LtAiPromptInput, LtAiPromptRunInput, LtAiResponse, LtAiSlot, LtAiSlotInput, LtAiStreamEvent, LtAiStreamHandlers, LtAiUsage, LtAiUsageInfo, LtAiUsageScope, UseLtAiAdminReturn, UseLtAiChatOptions, UseLtAiChatReturn, UseLtAiConnectionsReturn, UseLtAiPlaceholdersReturn, UseLtAiPromptsReturn, UseLtAiReturn, UseLtAiUsageReturn, } from './ai.js';

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

@@ -107,10 +107,22 @@ export interface LtErrorTranslationModuleOptions {
     /** Default locale if not detected (default: 'de') */
     defaultLocale?: string;
 }
+/**
+ * AI module configuration options (client side). Mirrors the nest-server AI
+ * module's REST base path so the composables hit the right endpoints.
+ */
+export interface LtAiModuleOptions {
+    /** AI API base path (default: '/ai' — must match the nest-server AI controller). */
+    basePath?: string;
+    /** Enable the AI composables/auto-imports (default: true). */
+    enabled?: boolean;
+}
 /**
  * Main module options for @lenne.tech/nuxt-extensions
  */
 export interface LtExtensionsModuleOptions {
+    /** AI module configuration */
+    ai?: LtAiModuleOptions;
     /** Auth module configuration */
     auth?: LtAuthModuleOptions;
     /** Error translation configuration */
@@ -125,6 +137,10 @@ export interface LtExtensionsModuleOptions {
  */
 export interface LtExtensionsPublicRuntimeConfig {
     ltExtensions: {
+        ai: {
+            basePath: string;
+            enabled: boolean;
+        };
         auth: {
             basePath: string;
             baseURL: string;

package/dist/types.d.mts

@@ -4,12 +4,6 @@ import type { default as Module } from './module.mjs'
 
 export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
 
-export { type LtAuthClientConfig, type LtAuthMode, type LtAuthResponse, type LtAuthState, type LtPasskeyAuthResult, type LtPasskeyRegisterResult, type LtUser, type UseLtAuthReturn } from '../dist/runtime/types/auth.js'
-
-export { type LtFileInfo, type LtUploadItem, type LtUploadOptions, type LtUploadProgress, type LtUploadStatus, type UseLtFileReturn, type UseLtTusUploadReturn } from '../dist/runtime/types/upload.js'
-
-export { type LtAuthCookieNamesOptions, type LtAuthModuleOptions, type LtErrorTranslationModuleOptions, type LtExtensionsModuleOptions, type LtExtensionsPublicRuntimeConfig, type LtI18nModuleOptions, type LtSystemSetupModuleOptions, type LtTusModuleOptions } from '../dist/runtime/types/module.js'
-
-export { type LtErrorTranslationResponse, type LtParsedError, type UseLtErrorTranslationReturn } from '../dist/runtime/types/error.js'
-
 export { type DEFAULT_LT_AUTH_STATE_COOKIE, type DEFAULT_LT_JWT_TOKEN_COOKIE, type configKey, default, type name, type version } from './module.mjs'
+
+export * from '../dist/runtime/types/index.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nuxt-extensions",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "description": "Reusable Nuxt 4 composables, components, and Better-Auth integration for lenne.tech projects",
   "repository": {
     "type": "git",
@@ -14,6 +14,7 @@
   "license": "MIT",
   "packageManager": "pnpm@10.33.0",
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/types.d.mts",
@@ -70,7 +71,7 @@
     "release": "pnpm format:check && pnpm lint && pnpm test:types && pnpm test && pnpm prepack"
   },
   "dependencies": {
-    "@nuxt/kit": "4.4.4"
+    "@nuxt/kit": "4.4.6"
   },
   "peerDependencies": {
     "@better-auth/passkey": ">=1.0.0",
@@ -94,28 +95,34 @@
     }
   },
   "devDependencies": {
-    "@better-auth/passkey": "1.6.10",
+    "@better-auth/passkey": "1.6.13",
     "@nuxt/devtools": "3.2.4",
     "@nuxt/module-builder": "1.0.2",
-    "@nuxt/schema": "4.4.4",
-    "@playwright/test": "1.59.1",
-    "@types/node": "25.6.2",
-    "@vitest/coverage-v8": "4.1.5",
-    "better-auth": "1.6.10",
+    "@nuxt/schema": "4.4.6",
+    "@playwright/test": "1.60.0",
+    "@types/node": "25.9.1",
+    "@vitest/coverage-v8": "4.1.7",
+    "better-auth": "1.6.13",
     "happy-dom": "20.9.0",
-    "nuxt": "4.4.4",
-    "oxfmt": "0.48.0",
-    "oxlint": "1.63.0",
+    "nuxt": "4.4.6",
+    "oxfmt": "0.52.0",
+    "oxlint": "1.67.0",
     "tus-js-client": "4.3.1",
     "typescript": "5.9.3",
-    "vitest": "4.1.5",
-    "vue-tsc": "3.2.8"
+    "vitest": "4.1.7",
+    "vue-tsc": "3.3.3"
   },
   "pnpm": {
     "onlyBuiltDependencies": [
       "@parcel/watcher",
       "esbuild"
-    ]
+    ],
+    "overrides": {
+      "brace-expansion@>=5.0.0 <5.0.6": "5.0.6",
+      "devalue@>=5.6.3 <=5.8.0": "5.8.1",
+      "kysely@>=0.26.0 <0.28.17": "0.28.17",
+      "ws@>=8.0.0 <8.20.1": "8.21.0"
+    }
   },
   "keywords": [
     "nuxt",