nuxt-directus-sdk 6.0.0-beta.0 → 6.0.0-beta.1

package/README.md

@@ -2,22 +2,30 @@
 
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![CI][ci-src]][ci-href]
+[![Install size][install-size-src]][install-size-href]
 [![License][license-src]][license-href]
 [![Nuxt][nuxt-src]][nuxt-href]
 
-> A Nuxt 4 Directus module that uses the Directus SDK to enhance your Nuxt application
+> A Nuxt module for Directus with built-in authentication, realtime, file management, type generation, and visual editor support.
 
-- [✨  Release Notes](/CHANGELOG.md)
+- [✨  Release Notes](https://github.com/rolleyio/nuxt-directus-sdk/releases)
 - [📚  Documentation](https://nuxt-directus-sdk.rolley.io)
 
 ## Features
 
 - 🔒  **Session-based authentication** with cross-domain support
-- ⛰  Authentication out of the box
-- 🚠  Type generation based on Directus collections
-- 🔥  Typesafe Client Websockets enabled
-- 🌉  Automatically configures Nuxt Image for directus
-- 🗂️  Directus Admin panel added to Devtools
+- ⚡  **Realtime** via typed WebSocket subscriptions
+- 📁  **File management** with `@nuxt/image` integration
+- ✏️  **Visual editor** support for `@directus/visual-editing`
+- 🧩  **Auto-generated types** from your Directus schema, plus a standalone CLI
+- 📐  **Rules DSL** for defining and syncing permissions in code
+- 🗂️  Directus admin panel embedded in Nuxt Devtools
+
+## Requirements
+
+- **Nuxt 4.0+**
+- **Directus v11.16.0+** (required by the bundled `@directus/visual-editing` v2 and `@directus/sdk` v21)
 
 ## Quick Setup
 
@@ -39,19 +47,12 @@ bun install --save-dev nuxt-directus-sdk
 
 2. Add `nuxt-directus-sdk` to the `modules` section of `nuxt.config.ts`
 
-```js
+```ts
 export default defineNuxtConfig({
-  modules: [
-    'nuxt-directus-sdk'
-  ],
+  modules: ['nuxt-directus-sdk'],
   directus: {
-    // Optional: customize authentication (defaults shown)
-    auth: {
-      autoRefresh: true,
-      credentials: 'include', // Required for cross-domain
-      realtimeAuthMode: 'public',
-    }
-  }
+    url: process.env.DIRECTUS_URL,
+  },
 })
 ```
 
@@ -59,47 +60,68 @@ export default defineNuxtConfig({
 
 ```dotenv
 DIRECTUS_URL=https://your-directus-url.com
-DIRECTUS_ADMIN_TOKEN=your_admin_token # Optional: for type generation
+DIRECTUS_ADMIN_TOKEN=your_admin_token # Optional: required for type generation
 ```
 
-4. **Configure your Directus backend** for cross-domain authentication (see [Authentication Guide](https://nuxt-directus-sdk.rolley.io/guide/authentication.html))
+4. **Configure your Directus backend** for cross-domain authentication (see the [Authentication Guide](https://nuxt-directus-sdk.rolley.io/guide/authentication.html))
 
 That's it! You can now use Directus within your Nuxt app ✨
 
-For cross-domain setups (e.g., `app.example.com` ↔ `api.example.com`), see the [Authentication Guide](https://nuxt-directus-sdk.rolley.io/guide/authentication.html).
+For cross-domain setups (e.g. `app.example.com` and `api.example.com`), see the [Authentication Guide](https://nuxt-directus-sdk.rolley.io/guide/authentication.html).
+
+## CLI
+
+The module ships with a CLI for type generation and permissions/rules sync that doesn't require a running Nuxt instance. Useful in CI, pre-commit hooks, or quick regeneration during development.
+
+```bash
+# Generate TypeScript types from a Directus schema
+npx nuxt-directus-sdk generate-types --prefix App -o types/directus.d.ts
+
+# Pull permissions/rules to a JSON file
+npx nuxt-directus-sdk rules:pull -o rules.json
+
+# See all commands
+npx nuxt-directus-sdk --help
+```
+
+See the [CLI documentation](https://nuxt-directus-sdk.rolley.io/api/configuration/module#types) for flags and examples.
 
 ## Development
 
-> [!IMPORTANT] The playground uses [directus-template-cli](https://github.com/directus-labs/directus-template-cli?tab=readme-ov-file#applying-a-template) `cms` template.
+> [!IMPORTANT] The playground uses the [directus-template-cli](https://github.com/directus-labs/directus-template-cli?tab=readme-ov-file#applying-a-template) `cms` template.
 > Apply the template with `npx directus-template-cli@latest apply` and follow the interactive prompts.
 
 ```bash
 # Install dependencies
-bun install
+pnpm install
 
 # Add DIRECTUS_ADMIN_TOKEN to playground .env (don't forget to update your token)
 cp ./playground/.env.example ./playground/.env
 
 # Generate type stubs
-bun run dev:prepare
+pnpm run dev:prepare
 
 # Develop with the playground
-bun run dev
+pnpm run dev
 
 # Build the playground
-bun run dev:build
+pnpm run dev:build
 
 # Run ESLint
-bun run lint
+pnpm run lint
 
 # Run Vitest
-bun run test
-bun run test:watch
+pnpm run test
+pnpm run test:watch
 
-# Release new version
-bun run release
+# Release new version (see RELEASING.md)
+pnpm run release
 ```
 
+## Contributing
+
+Contributions are welcome. Please target the `next` branch for new features and fixes; `main` is reserved for stable releases and hotfixes. See [RELEASING.md](./RELEASING.md) for the release process.
+
 <!-- Badges -->
 [npm-version-src]: https://img.shields.io/npm/v/nuxt-directus-sdk/latest.svg?style=flat&colorA=18181B&colorB=28CF8D
 [npm-version-href]: https://npmjs.com/package/nuxt-directus-sdk
@@ -107,6 +129,12 @@ bun run release
 [npm-downloads-src]: https://img.shields.io/npm/dm/nuxt-directus-sdk.svg?style=flat&colorA=18181B&colorB=28CF8D
 [npm-downloads-href]: https://npmjs.com/package/nuxt-directus-sdk
 
+[ci-src]: https://github.com/rolleyio/nuxt-directus-sdk/actions/workflows/ci.yml/badge.svg?branch=main
+[ci-href]: https://github.com/rolleyio/nuxt-directus-sdk/actions/workflows/ci.yml
+
+[install-size-src]: https://packagephobia.com/badge?p=nuxt-directus-sdk
+[install-size-href]: https://packagephobia.com/result?p=nuxt-directus-sdk
+
 [license-src]: https://img.shields.io/npm/l/nuxt-directus-sdk.svg?style=flat&colorA=18181B&colorB=28CF8D
 [license-href]: https://npmjs.com/package/nuxt-directus-sdk
 

package/dist/cli/index.mjs

@@ -1,9 +1,23 @@
 #!/usr/bin/env node
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
 import { parseArgs } from 'node:util';
 import { createDirectus, staticToken, rest } from '@directus/sdk';
 import { d as diffRemoteRules, e as formatDiff, c as compareRulesPayloads, f as fetchRemoteRules, k as loadRulesFromPayload, o as pushRules, g as formatPushResult, b as fetchRemoteRulesAsJson } from '../shared/nuxt-directus-sdk.1qEbZAZ_.mjs';
+import { generateTypesFromDirectus } from '../../dist/runtime/types/generate.js';
+
+function parseCsv(raw) {
+  if (!raw)
+    return [];
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function resolveNegatableBoolean(positive, negative, fallback) {
+  if (negative)
+    return false;
+  if (positive !== void 0)
+    return positive;
+  return fallback;
+}
 
 function loadEnv() {
   const envPath = resolve(process.cwd(), ".env");
@@ -28,12 +42,14 @@ function getConnectionConfig(urlFlag, tokenFlag, label) {
   const token = tokenFlag ?? process.env.DIRECTUS_ADMIN_TOKEN;
   if (!url) {
     console.error(`Error: ${label} URL is required`);
-    console.error(`Provide --${label.toLowerCase()}-url or set DIRECTUS_URL in your .env file`);
+    const flagHint = label === "Source" ? "--url (or --source-url)" : `--${label.toLowerCase()}-url`;
+    console.error(`Provide ${flagHint} or set DIRECTUS_URL in your .env file`);
     process.exit(1);
   }
   if (!token) {
     console.error(`Error: ${label} token is required`);
-    console.error(`Provide --${label.toLowerCase()}-token or set DIRECTUS_ADMIN_TOKEN in your .env file`);
+    const flagHint = label === "Source" ? "--token (or --source-token)" : `--${label.toLowerCase()}-token`;
+    console.error(`Provide ${flagHint} or set DIRECTUS_ADMIN_TOKEN in your .env file`);
     process.exit(1);
   }
   return { url, token };
@@ -43,7 +59,7 @@ function createClient(url, token) {
 }
 function printHelp() {
   console.log(`
-Directus Rules CLI
+nuxt-directus-sdk CLI
 
 Usage:
   npx nuxt-directus-sdk <command> [options]
@@ -54,24 +70,40 @@ Commands:
   rules:diff <file>         Compare local JSON file with remote Directus
   rules:diff-files <a> <b>  Compare two local JSON files
   rules:diff-remote         Compare two remote Directus instances
+  generate-types            Generate TypeScript types from a Directus schema
 
 Options:
   -h, --help                Show this help message
-  -o, --output <file>       Output file path (default: rules.json)
+  -o, --output <file>       Output file path (default: stdout for generate-types, rules.json for rules:pull)
   --compact                 Output compact JSON (no pretty-print)
   --dry-run                 Show what would be changed without making changes (rules:push)
   --add-only                Only add new items, don't modify or delete existing (rules:push)
   --skip-deletes            Skip deleting items that exist remotely but not locally (rules:push)
+  --prefix <prefix>         Prefix for custom collection type names (generate-types)
+  --include <names>         Comma-separated collection names to include (generate-types).
+                            When set, only these collections (plus any they reference
+                            via --expand-references, default on) are emitted.
+                            Takes precedence over --exclude if both are set.
+  --no-expand-references    When --include is set, do NOT follow references to other
+                            collections. Strict include mode \u2014 references to collections
+                            not in the list collapse to \`string\`. (generate-types)
+  --exclude <names>         Comma-separated collection names to exclude (generate-types).
+                            References to excluded types are rewritten to \`string\`.
+  --verbose                 Show per-target warnings listing every field whose reference
+                            was collapsed to \`string\` (generate-types).
+  --no-declare-global       Emit types without the \`declare global\` wrapper (generate-types)
 
   Connection options (override DIRECTUS_URL / DIRECTUS_ADMIN_TOKEN):
+  --url <url>               Directus URL (alias of --source-url)
+  --token <token>           Admin token (alias of --source-token)
   --source-url <url>        Source Directus URL
   --source-token <token>    Source admin token
   --target-url <url>        Target Directus URL (for rules:diff-remote)
   --target-token <token>    Target admin token (for rules:diff-remote)
 
 Environment Variables:
-  DIRECTUS_URL              Default Directus URL (used if --source-url not provided)
-  DIRECTUS_ADMIN_TOKEN      Default admin token (used if --source-token not provided)
+  DIRECTUS_URL              Default Directus URL (used if --url / --source-url not provided)
+  DIRECTUS_ADMIN_TOKEN      Default admin token (used if --token / --source-token not provided)
 
 Examples:
   # Pull rules from Directus (uses env vars)
@@ -99,6 +131,27 @@ Examples:
   npx nuxt-directus-sdk rules:diff-remote \\
     --source-url https://staging.example.com --source-token staging-token \\
     --target-url https://production.example.com --target-token production-token
+
+  # Generate TypeScript types, pipe to a file
+  npx nuxt-directus-sdk generate-types > types/directus.d.ts
+
+  # Generate types with a prefix, write directly to a file
+  npx nuxt-directus-sdk generate-types --prefix App -o types/directus.d.ts
+
+  # Generate types from a specific instance
+  npx nuxt-directus-sdk generate-types --url https://my-directus.com --token my-token
+
+  # Exclude specific collections \u2014 references to them become \`string\`
+  npx nuxt-directus-sdk generate-types --exclude directus_activity,directus_revisions
+
+  # Include only specific collections (referenced collections auto-included)
+  npx nuxt-directus-sdk generate-types --include posts
+
+  # Strict include \u2014 only the listed collections, references collapse to \`string\`
+  npx nuxt-directus-sdk generate-types --include posts --no-expand-references
+
+  # Verbose \u2014 show every field whose reference was collapsed, grouped by target
+  npx nuxt-directus-sdk generate-types --exclude directus_users --verbose
 `);
 }
 function loadJsonFile(filePath) {
@@ -191,17 +244,67 @@ async function commandPush(localFile, connection, options) {
     process.exit(1);
   }
 }
+async function commandGenerateTypes(connection, options) {
+  console.error(`Generating types from ${connection.url}...`);
+  if (options.include.length > 0) {
+    console.error(`Including collections: ${options.include.join(", ")}`);
+  }
+  if (options.exclude.length > 0) {
+    console.error(`Excluding collections: ${options.exclude.join(", ")}`);
+  }
+  const { typeString, logs } = await generateTypesFromDirectus(
+    connection.url,
+    connection.token,
+    options.prefix,
+    {
+      include: options.include,
+      exclude: options.exclude,
+      expandReferences: options.expandReferences,
+      verbose: options.verbose
+    }
+  );
+  for (const line of logs) {
+    console.error(line);
+  }
+  if (!typeString) {
+    console.error("Error: Type generation returned empty output.");
+    process.exit(1);
+  }
+  const output = options.declareGlobal ? typeString : typeString.replace(/^declare global \{\n\n/, "").replace(/\n\}\n\nexport \{\};?\n?$/, "\n");
+  if (options.output) {
+    const outputPath = resolve(process.cwd(), options.output);
+    mkdirSync(dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, output, "utf-8");
+    console.error(`Types written to ${outputPath}`);
+  } else {
+    process.stdout.write(output);
+  }
+}
 async function main() {
   loadEnv();
   const { values, positionals } = parseArgs({
     allowPositionals: true,
     options: {
       "help": { type: "boolean", short: "h" },
-      "output": { type: "string", short: "o", default: "rules.json" },
+      // `output` has no default here — each command applies its own fallback
+      // (rules:pull defaults to rules.json, generate-types defaults to stdout).
+      "output": { type: "string", short: "o" },
       "compact": { type: "boolean", default: false },
       "dry-run": { type: "boolean", default: false },
       "add-only": { type: "boolean", default: false },
       "skip-deletes": { type: "boolean", default: false },
+      "prefix": { type: "string", default: "" },
+      "include": { type: "string" },
+      "exclude": { type: "string" },
+      // Node's parseArgs doesn't support `--no-X` syntax natively, so we
+      // register both forms. Negation wins if both are passed.
+      "expand-references": { type: "boolean", default: true },
+      "no-expand-references": { type: "boolean" },
+      "verbose": { type: "boolean", default: false },
+      "declare-global": { type: "boolean", default: true },
+      "no-declare-global": { type: "boolean" },
+      "url": { type: "string" },
+      "token": { type: "string" },
       "source-url": { type: "string" },
       "source-token": { type: "string" },
       "target-url": { type: "string" },
@@ -217,12 +320,12 @@ async function main() {
     switch (command) {
       case "rules:pull": {
         const connection = getConnectionConfig(
-          values["source-url"],
-          values["source-token"],
+          values["source-url"] ?? values.url,
+          values["source-token"] ?? values.token,
           "Source"
         );
         await commandPull({
-          output: values.output,
+          output: values.output ?? "rules.json",
           compact: values.compact
         }, connection);
         break;
@@ -234,8 +337,8 @@ async function main() {
           process.exit(1);
         }
         const connection = getConnectionConfig(
-          values["source-url"],
-          values["source-token"],
+          values["source-url"] ?? values.url,
+          values["source-token"] ?? values.token,
           "Source"
         );
         await commandPush(positionals[1], connection, {
@@ -252,8 +355,8 @@ async function main() {
           process.exit(1);
         }
         const connection = getConnectionConfig(
-          values["source-url"],
-          values["source-token"],
+          values["source-url"] ?? values.url,
+          values["source-token"] ?? values.token,
           "Source"
         );
         await commandDiff(positionals[1], connection);
@@ -269,8 +372,8 @@ async function main() {
         break;
       case "rules:diff-remote": {
         const source = getConnectionConfig(
-          values["source-url"],
-          values["source-token"],
+          values["source-url"] ?? values.url,
+          values["source-token"] ?? values.token,
           "Source"
         );
         const target = getConnectionConfig(
@@ -281,6 +384,23 @@ async function main() {
         await commandDiffRemote(source, target);
         break;
       }
+      case "generate-types": {
+        const connection = getConnectionConfig(
+          values.url ?? values["source-url"],
+          values.token ?? values["source-token"],
+          "Source"
+        );
+        await commandGenerateTypes(connection, {
+          prefix: values.prefix ?? "",
+          output: values.output,
+          declareGlobal: resolveNegatableBoolean(values["declare-global"], values["no-declare-global"], true),
+          include: parseCsv(values.include),
+          exclude: parseCsv(values.exclude),
+          expandReferences: resolveNegatableBoolean(values["expand-references"], values["no-expand-references"], true),
+          verbose: values.verbose
+        });
+        break;
+      }
       default:
         console.error(`Unknown command: ${command}`);
         printHelp();

package/dist/module.d.mts

@@ -153,6 +153,41 @@ interface ModuleOptions {
          * @default ''
          */
         prefix?: string;
+        /**
+         * Collection names to include in the generated types. When non-empty,
+         * only these collections (plus any they reference — see
+         * `expandReferences`) are emitted. References to collections not in
+         * the resolved set collapse to `string` (M2O) or `string[]` (O2M).
+         *
+         * Takes precedence over `exclude` if both are set.
+         * @type string[]
+         * @default []
+         */
+        include?: string[];
+        /**
+         * When `include` is set, also pull in any collections referenced by
+         * the included collections (transitively). Follows M2O, O2M, and M2A.
+         * No-op when `include` is empty.
+         * @type boolean
+         * @default true
+         */
+        expandReferences?: boolean;
+        /**
+         * Collection names to exclude from generated types.
+         * References to excluded collections are rewritten to `string` (M2O) or
+         * `string[]` (O2M) so the generated types stay resolvable.
+         * @type string[]
+         * @default []
+         */
+        exclude?: string[];
+        /**
+         * When true, emit per-target warnings listing every field whose
+         * reference was collapsed to `string`/`string[]`. Field lists are
+         * capped at 5 per collection.
+         * @type boolean
+         * @default false
+         */
+        verbose?: boolean;
     };
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;

package/dist/module.d.ts

@@ -153,6 +153,41 @@ interface ModuleOptions {
          * @default ''
          */
         prefix?: string;
+        /**
+         * Collection names to include in the generated types. When non-empty,
+         * only these collections (plus any they reference — see
+         * `expandReferences`) are emitted. References to collections not in
+         * the resolved set collapse to `string` (M2O) or `string[]` (O2M).
+         *
+         * Takes precedence over `exclude` if both are set.
+         * @type string[]
+         * @default []
+         */
+        include?: string[];
+        /**
+         * When `include` is set, also pull in any collections referenced by
+         * the included collections (transitively). Follows M2O, O2M, and M2A.
+         * No-op when `include` is empty.
+         * @type boolean
+         * @default true
+         */
+        expandReferences?: boolean;
+        /**
+         * Collection names to exclude from generated types.
+         * References to excluded collections are rewritten to `string` (M2O) or
+         * `string[]` (O2M) so the generated types stay resolvable.
+         * @type string[]
+         * @default []
+         */
+        exclude?: string[];
+        /**
+         * When true, emit per-target warnings listing every field whose
+         * reference was collapsed to `string`/`string[]`. Field lists are
+         * capped at 5 per collection.
+         * @type boolean
+         * @default false
+         */
+        verbose?: boolean;
     };
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-directus-sdk",
-  "version": "6.0.0-beta.0",
+  "version": "6.0.0-beta.1",
   "configKey": "directus",
   "compatibility": {
     "nuxt": "^4.0.0"

package/dist/module.mjs

@@ -6,7 +6,7 @@ import { generateTypesFromDirectus } from '../dist/runtime/types/index.js';
 import { useUrl } from '../dist/runtime/utils/index.js';
 
 const name = "nuxt-directus-sdk";
-const version = "6.0.0-beta.0";
+const version = "6.0.0-beta.1";
 
 const configKey = "directus";
 const logger = useLogger("nuxt-directus-sdk");
@@ -248,7 +248,7 @@ const module$1 = defineNuxtModule({
         imports: [
           "getDirectusSessionToken",
           "useAdminDirectus",
-          "useServerDirectus",
+          "useSessionDirectus",
           "useDirectusUrl",
           "useTokenDirectus"
         ]
@@ -270,13 +270,22 @@ const module$1 = defineNuxtModule({
     }
     const typesEnabled = typeof options.types === "boolean" && options.types || options.types && options.types.enabled === true;
     const typesPrefix = typeof options.types === "object" ? options.types.prefix ?? "" : "";
+    const typesInclude = typeof options.types === "object" ? options.types.include ?? [] : [];
+    const typesExpandReferences = typeof options.types === "object" ? options.types.expandReferences ?? true : true;
+    const typesExclude = typeof options.types === "object" ? options.types.exclude ?? [] : [];
+    const typesVerbose = typeof options.types === "object" ? options.types.verbose ?? false : false;
     if (typesEnabled) {
       loggerMessage.push("\u{1F4CB} Directus Type Generator Enabled");
       if (!options.adminToken) {
         loggerMessage.push(`  ${colors.bgRedBright(`${colors.red("\u2691 ERROR:")} Unable to generate Types`)}`, `   Fix: Set adminToken in config or DIRECTUS_ADMIN_TOKEN in .env`);
       } else {
         try {
-          const { typeString, logs } = await generateTypesFromDirectus(directusUrl, options.adminToken, typesPrefix);
+          const { typeString, logs } = await generateTypesFromDirectus(directusUrl, options.adminToken, typesPrefix, {
+            include: typesInclude,
+            expandReferences: typesExpandReferences,
+            exclude: typesExclude,
+            verbose: typesVerbose
+          });
           loggerMessage.push(...logs);
           addTypeTemplate({
             filename: `types/${configKey}.d.ts`,

package/dist/runtime/composables/files.js

@@ -13,7 +13,7 @@ export async function uploadDirectusFiles(files, query) {
         formData.set(key, value);
       });
     }
-    formData.set("file", file);
+    formData.append("file", file);
   });
   return directus.request(uploadFiles(formData, query));
 }

package/dist/runtime/server/services/directus.d.ts

@@ -2,5 +2,5 @@ import type { H3Event } from 'h3';
 export declare function getDirectusSessionToken(event: H3Event): string | undefined;
 export declare function useDirectusUrl(path?: string): string;
 export declare function useTokenDirectus(token?: string): import("@directus/sdk").DirectusClient<DirectusSchema> & import("@directus/sdk").AuthenticationClient<DirectusSchema> & import("@directus/sdk").RestClient<DirectusSchema>;
-export declare function useServerDirectus(event: H3Event): import("@directus/sdk").DirectusClient<DirectusSchema> & import("@directus/sdk").AuthenticationClient<DirectusSchema> & import("@directus/sdk").RestClient<DirectusSchema>;
+export declare function useSessionDirectus(event: H3Event): import("@directus/sdk").DirectusClient<DirectusSchema> & import("@directus/sdk").AuthenticationClient<DirectusSchema> & import("@directus/sdk").RestClient<DirectusSchema>;
 export declare function useAdminDirectus(): import("@directus/sdk").DirectusClient<DirectusSchema> & import("@directus/sdk").AuthenticationClient<DirectusSchema> & import("@directus/sdk").RestClient<DirectusSchema>;

package/dist/runtime/server/services/directus.js

@@ -18,7 +18,7 @@ export function useTokenDirectus(token) {
     directus.setToken(token);
   return directus;
 }
-export function useServerDirectus(event) {
+export function useSessionDirectus(event) {
   return useTokenDirectus(getDirectusSessionToken(event));
 }
 export function useAdminDirectus() {

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

@@ -1,6 +1,11 @@
 import type { SnapshotCollection, SnapshotField, SnapshotRelation } from '@directus/types';
 import type { TypegenExtension } from './extensions/index.js';
 export declare const FALLBACK_TYPE_STRING = "declare global {\n\ninterface DirectusFile {\n\tid: string;\n}\ninterface DirectusUser {\n\tid: string;\n}\ninterface DirectusSchema { }\n}\n\nexport {};";
+interface RewriteRecord {
+    fromCollection: string;
+    fromField: string;
+    target: string;
+}
 /**
  * Fetches collections, fields, and relations from a live Directus instance and
  * generates a TypeScript declaration string.
@@ -10,7 +15,39 @@ export declare const FALLBACK_TYPE_STRING = "declare global {\n\ninterface Direc
  * @param prefix - Prefix used when generating interface names.
  * @returns The generated TypeScript string and an array of log messages.
  */
-export declare function generateTypesFromDirectus(url: string, token: string, prefix: string): Promise<{
+export interface GenerateTypesOptions {
+    /**
+     * Collection names to include. When non-empty, only these collections
+     * (plus any collections they reference — see `expandReferences`) are
+     * emitted. References to collections not in the resolved set collapse
+     * to `string` / `string[]`.
+     */
+    include?: string[];
+    /**
+     * When `include` is set, also pull in any collections referenced by
+     * the included collections (transitively). Follows M2O, O2M, M2A, and
+     * translations relations. No-op when `include` is empty.
+     * @default true
+     */
+    expandReferences?: boolean;
+    /**
+     * Collection names to exclude from the generated types. References to
+     * excluded collections are rewritten to `string` (M2O), `string[]` (O2M),
+     * or a filtered union (M2A).
+     *
+     * When both `include` and `exclude` are set, `include` wins and `exclude`
+     * is ignored with a warning.
+     */
+    exclude?: string[];
+    /**
+     * When true, emit per-reference warnings for every field whose target
+     * collection was collapsed to `string` / `string[]`. Grouped by target
+     * collection to keep the output readable.
+     * @default false
+     */
+    verbose?: boolean;
+}
+export declare function generateTypesFromDirectus(url: string, token: string, prefix: string, options?: GenerateTypesOptions): Promise<{
     typeString: string;
     logs: string[];
 }>;
@@ -31,4 +68,12 @@ export declare function generateTypesFromDirectus(url: string, token: string, pr
  * @param extensions - Optional type generation extensions.
  * @returns A TypeScript declaration file as a string.
  */
-export declare function transformSnapshotToTypeString(collections: SnapshotCollection[], fields: SnapshotField[], relations: SnapshotRelation[], prefix: string, extensions?: TypegenExtension[]): string;
+export declare function transformSnapshotToTypeString(collections: SnapshotCollection[], fields: SnapshotField[], relations: SnapshotRelation[], prefix: string, extensions?: TypegenExtension[], filter?: {
+    include?: string[];
+    exclude?: string[];
+}): {
+    typeString: string;
+    rewrites: RewriteRecord[];
+    emittedCount: number;
+};
+export {};

package/dist/runtime/types/generate.js

@@ -1,7 +1,7 @@
 import { createDirectus, isDirectusError, readCollections, readFields, readRelations, rest, staticToken } from "@directus/sdk";
 import { typegenExtensions } from "./extensions/index.js";
 export const FALLBACK_TYPE_STRING = "declare global {\n\ninterface DirectusFile {\n	id: string;\n}\ninterface DirectusUser {\n	id: string;\n}\ninterface DirectusSchema { }\n}\n\nexport {};";
-export async function generateTypesFromDirectus(url, token, prefix) {
+export async function generateTypesFromDirectus(url, token, prefix, options = {}) {
   const logs = [];
   const client = createDirectus(url).with(rest()).with(staticToken(token));
   let result = null;
@@ -28,13 +28,69 @@ export async function generateTypesFromDirectus(url, token, prefix) {
     }
     return { typeString: FALLBACK_TYPE_STRING, logs };
   }
-  const typeString = transformSnapshotToTypeString(...result, prefix);
+  const resolvedOptions = {
+    include: options.include ?? [],
+    exclude: options.exclude ?? [],
+    verbose: options.verbose ?? false
+  };
+  if (resolvedOptions.include.length > 0 && resolvedOptions.exclude.length > 0) {
+    logs.push("  - Warning: both include and exclude were set; exclude is ignored because include takes precedence");
+    resolvedOptions.exclude = [];
+  }
+  const expandReferences = options.expandReferences ?? true;
+  if (expandReferences && resolvedOptions.include.length > 0) {
+    const originalSize = resolvedOptions.include.length;
+    const expanded = expandIncludeViaReferences(resolvedOptions.include, result[2]);
+    if (expanded.size > originalSize) {
+      resolvedOptions.include = Array.from(expanded);
+      const added = expanded.size - originalSize;
+      logs.push(`  - Expanded include from ${originalSize} \u2192 ${expanded.size} collection${expanded.size === 1 ? "" : "s"} (+${added} via references)`);
+    }
+  }
+  const { typeString, rewrites, emittedCount } = transformSnapshotToTypeString(...result, prefix, void 0, resolvedOptions);
+  const filterActive = resolvedOptions.include.length > 0 || resolvedOptions.exclude.length > 0;
+  if (filterActive) {
+    const fetchedCount = result[0].length;
+    const filteredOut = fetchedCount - emittedCount;
+    logs.push(`  - Emitting ${emittedCount} collection${emittedCount === 1 ? "" : "s"} (${filteredOut} filtered out)`);
+  }
+  if (rewrites.length > 0) {
+    const totalFields = rewrites.length;
+    const byTarget = /* @__PURE__ */ new Map();
+    for (const rec of rewrites) {
+      const list = byTarget.get(rec.target) ?? [];
+      list.push(rec);
+      byTarget.set(rec.target, list);
+    }
+    const reason = resolvedOptions.include.length > 0 ? "not in include list" : "excluded";
+    logs.push(`  - ${totalFields} field reference${totalFields === 1 ? "" : "s"} across ${byTarget.size} target${byTarget.size === 1 ? "" : "s"} collapsed to string (${reason})`);
+    if (resolvedOptions.verbose) {
+      for (const [target, recs] of byTarget) {
+        const collectionCount = new Set(recs.map((r) => r.fromCollection)).size;
+        logs.push(`    \xB7 ${target} (${reason}) \u2014 referenced by ${recs.length} field${recs.length === 1 ? "" : "s"} across ${collectionCount} collection${collectionCount === 1 ? "" : "s"}`);
+        const preview = recs.slice(0, 5).map((r) => `${r.fromCollection}.${r.fromField}`);
+        const suffix = recs.length > 5 ? `, \u2026and ${recs.length - 5} more` : "";
+        logs.push(`      ${preview.join(", ")}${suffix}`);
+      }
+    }
+  }
   return { typeString, logs };
 }
-export function transformSnapshotToTypeString(collections, fields, relations, prefix, extensions = typegenExtensions) {
+export function transformSnapshotToTypeString(collections, fields, relations, prefix, extensions = typegenExtensions, filter = {}) {
+  const includeList = filter.include ?? [];
+  const excludeList = filter.exclude ?? [];
+  const useInclude = includeList.length > 0;
+  const includeSet = new Set(includeList);
+  const excludeSet = new Set(excludeList);
+  const isCollectionAllowed = (name) => {
+    if (useInclude)
+      return includeSet.has(name);
+    return !excludeSet.has(name);
+  };
+  const rewrites = [];
   const relationMap = buildRelationMapFromSnapshot(relations);
   const collectionsWithDatabaseTables = collections.filter(
-    (c) => c.schema !== null
+    (c) => c.schema !== null && isCollectionAllowed(c.collection)
   );
   const customCollections = collectionsWithDatabaseTables.filter(
     (c) => !collectionIsDirectusSystem(c.collection)
@@ -48,7 +104,7 @@ export function transformSnapshotToTypeString(collections, fields, relations, pr
   const impliedSystemCollections = [
     ...new Set(
       relations.flatMap((r) => [r.collection, r.related_collection ?? ""]).filter(
-        (name) => collectionIsDirectusSystem(name) && !systemCollectionNamesAlreadyPresent.has(name)
+        (name) => collectionIsDirectusSystem(name) && !systemCollectionNamesAlreadyPresent.has(name) && isCollectionAllowed(name)
       )
     )
   ].map((name) => ({ collection: name, schema: { name }, meta: null }));
@@ -56,6 +112,8 @@ export function transformSnapshotToTypeString(collections, fields, relations, pr
     ...collectionsWithDatabaseTables,
     ...impliedSystemCollections
   ];
+  const allCollectionNamesInSchema = new Set(allCollectionsForSchema.map((c) => c.collection));
+  const isMissing = (name) => !allCollectionNamesInSchema.has(name);
   const singletonCollectionNames = new Set(
     allCollectionsForSchema.filter((c) => c.meta?.singleton === true).map((c) => c.collection)
   );
@@ -63,7 +121,7 @@ export function transformSnapshotToTypeString(collections, fields, relations, pr
     ...customCollections,
     ...systemCollectionsFromSnapshot
   ].map(
-    (collection) => generateInterfaceForCollection(collection, fields, relationMap, prefix, extensions, singletonCollectionNames)
+    (collection) => generateInterfaceForCollection(collection, fields, relationMap, prefix, extensions, singletonCollectionNames, isMissing, rewrites)
   );
   const seenExtensionOutputs = /* @__PURE__ */ new Set();
   const uniqueExtensionOutputs = generatedCollections.flatMap((g) => g.extensionOutputs).filter((output) => {
@@ -82,7 +140,7 @@ export function transformSnapshotToTypeString(collections, fields, relations, pr
     directusSchemaBlock,
     enumBlock
   ];
-  return [
+  const typeString = [
     "declare global {",
     "",
     bodyParts.join("\n\n"),
@@ -90,6 +148,7 @@ export function transformSnapshotToTypeString(collections, fields, relations, pr
     "",
     "export {};"
   ].join("\n");
+  return { typeString, rewrites, emittedCount: collectionsWithDatabaseTables.length };
 }
 function collectionIsDirectusSystem(collectionName) {
   return collectionName.startsWith("directus_");
@@ -111,6 +170,35 @@ function resolveExtensionForField(field, prefix, extensions) {
     output: match.output(prefix)
   };
 }
+function expandIncludeViaReferences(seeds, relations) {
+  const relationMap = buildRelationMapFromSnapshot(relations);
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [...seeds];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    const rels = relationMap.get(current);
+    if (!rels)
+      continue;
+    for (const { relatedCollection } of rels.m2o.values()) {
+      if (!visited.has(relatedCollection))
+        queue.push(relatedCollection);
+    }
+    for (const { relatedCollection } of rels.o2m.values()) {
+      if (!visited.has(relatedCollection))
+        queue.push(relatedCollection);
+    }
+    for (const allowed of rels.m2a.values()) {
+      for (const name of allowed) {
+        if (!visited.has(name))
+          queue.push(name);
+      }
+    }
+  }
+  return visited;
+}
 function buildRelationMapFromSnapshot(relations) {
   const relationMap = /* @__PURE__ */ new Map();
   const getOrCreateCollectionRelations = (collection) => {
@@ -135,18 +223,33 @@ function buildRelationMapFromSnapshot(relations) {
   }
   return relationMap;
 }
-function resolveFieldTypeString(snapshotField, collectionRelations, prefix, extensions, singletons = /* @__PURE__ */ new Set()) {
+function resolveFieldTypeString(snapshotField, collectionRelations, prefix, extensions, singletons = /* @__PURE__ */ new Set(), isMissing = () => false, rewrites = []) {
   if (collectionRelations?.m2a.has(snapshotField.field)) {
     const allowedCollections = collectionRelations.m2a.get(snapshotField.field);
-    const unionTypes = allowedCollections.map((c) => collectionNameToInterfaceName(c, prefix, singletons)).join(" | ");
+    const included = allowedCollections.filter((c) => !isMissing(c));
+    for (const missing of allowedCollections.filter((c) => isMissing(c))) {
+      rewrites.push({ fromCollection: snapshotField.collection, fromField: snapshotField.field, target: missing });
+    }
+    if (included.length === 0) {
+      return { tsType: "string", extensionOutput: null };
+    }
+    const unionTypes = included.map((c) => collectionNameToInterfaceName(c, prefix, singletons)).join(" | ");
     return { tsType: `${unionTypes} | string`, extensionOutput: null };
   }
   if (collectionRelations?.m2o.has(snapshotField.field)) {
     const related = collectionRelations.m2o.get(snapshotField.field);
+    if (isMissing(related.relatedCollection)) {
+      rewrites.push({ fromCollection: snapshotField.collection, fromField: snapshotField.field, target: related.relatedCollection });
+      return { tsType: "string", extensionOutput: null };
+    }
     return { tsType: `${collectionNameToInterfaceName(related.relatedCollection, prefix, singletons)} | string`, extensionOutput: null };
   }
   if (collectionRelations?.o2m.has(snapshotField.field)) {
     const related = collectionRelations.o2m.get(snapshotField.field);
+    if (isMissing(related.relatedCollection)) {
+      rewrites.push({ fromCollection: snapshotField.collection, fromField: snapshotField.field, target: related.relatedCollection });
+      return { tsType: "string[]", extensionOutput: null };
+    }
     return { tsType: `${collectionNameToInterfaceName(related.relatedCollection, prefix, singletons)}[] | string[]`, extensionOutput: null };
   }
   const extensionMatch = resolveExtensionForField(snapshotField, prefix, extensions);
@@ -160,13 +263,13 @@ function fieldIsUiOnlyAlias(field) {
   const special = field.meta?.special ?? [];
   return field.type === "alias" && special.some((s) => ALIAS_SPECIAL_TYPES.has(s)) && !special.includes("o2m") && !special.includes("m2o") && !special.includes("m2a") && !special.includes("files") && !special.includes("file");
 }
-function buildInterfaceField(snapshotField, collectionRelations, prefix, extensions, singletons = /* @__PURE__ */ new Set()) {
+function buildInterfaceField(snapshotField, collectionRelations, prefix, extensions, singletons = /* @__PURE__ */ new Set(), isMissing = () => false, rewrites = []) {
   if (fieldIsUiOnlyAlias(snapshotField))
     return null;
   const isPrimaryKey = snapshotField.schema?.is_primary_key === true;
   const isRequired = snapshotField.meta?.required === true;
   const isNullable = snapshotField.schema?.is_nullable !== false;
-  const { tsType, extensionOutput } = resolveFieldTypeString(snapshotField, collectionRelations, prefix, extensions, singletons);
+  const { tsType, extensionOutput } = resolveFieldTypeString(snapshotField, collectionRelations, prefix, extensions, singletons, isMissing, rewrites);
   const shouldAppendNull = isNullable && !isRequired && !isPrimaryKey;
   const finalType = shouldAppendNull ? `${tsType} | null` : tsType;
   return {
@@ -180,11 +283,11 @@ function buildInterfaceField(snapshotField, collectionRelations, prefix, extensi
     extensionOutput
   };
 }
-function generateInterfaceForCollection(collection, allFields, relationMap, prefix, extensions, singletons = /* @__PURE__ */ new Set()) {
+function generateInterfaceForCollection(collection, allFields, relationMap, prefix, extensions, singletons = /* @__PURE__ */ new Set(), isMissing = () => false, rewrites = []) {
   const collectionName = collection.collection;
   const interfaceName = collectionNameToInterfaceName(collectionName, prefix, singletons);
   const collectionRelations = relationMap.get(collectionName);
-  const builtFields = allFields.filter((f) => f.collection === collectionName).map((f) => buildInterfaceField(f, collectionRelations, prefix, extensions, singletons)).filter((f) => f !== null).sort((a, b) => a.interfaceField.sortOrder - b.interfaceField.sortOrder);
+  const builtFields = allFields.filter((f) => f.collection === collectionName).map((f) => buildInterfaceField(f, collectionRelations, prefix, extensions, singletons, isMissing, rewrites)).filter((f) => f !== null).sort((a, b) => a.interfaceField.sortOrder - b.interfaceField.sortOrder);
   const extensionOutputs = builtFields.map((f) => f.extensionOutput).filter((o) => o !== null);
   const fieldLines = builtFields.map(({ interfaceField }) => {
     const jsDoc = generateJSDocComment(interfaceField.snapshotField);

package/package.json

@@ -1,15 +1,31 @@
 {
   "name": "nuxt-directus-sdk",
   "type": "module",
-  "version": "6.0.0-beta.0",
+  "version": "6.0.0-beta.1",
   "packageManager": "pnpm@10.32.1",
-  "description": "A Directus nuxt module that uses the Directus SDK",
+  "description": "A Nuxt module for Directus with built-in authentication, realtime, file management, type generation, and visual editor support.",
   "author": "Matthew Rollinson <matt@rolley.io>",
   "license": "MIT",
+  "homepage": "https://nuxt-directus-sdk.rolley.io",
   "repository": {
     "type": "git",
     "url": "https://github.com/rolleyio/nuxt-directus-sdk"
   },
+  "bugs": {
+    "url": "https://github.com/rolleyio/nuxt-directus-sdk/issues"
+  },
+  "keywords": [
+    "nuxt",
+    "nuxt-module",
+    "directus",
+    "cms",
+    "headless-cms",
+    "sdk",
+    "ssr",
+    "realtime",
+    "authentication",
+    "visual-editor"
+  ],
   "exports": {
     ".": {
       "types": "./dist/module.d.mts",

package/dist/runtime/components/directus-add-button.d.vue.ts

@@ -1,22 +0,0 @@
-import type { PrimaryKey } from '@directus/types';
-type __VLS_Props = {
-    /** The parent collection that contains the repeater field */
-    collection: string;
-    /** The parent item ID */
-    item: PrimaryKey;
-    /** The field name of the repeater on the parent (e.g., 'blocks') */
-    field: 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/runtime/components/directus-add-button.vue

@@ -1,64 +0,0 @@
-<script setup>
-import { computed, useRuntimeConfig } from "#imports";
-import { useDirectusOriginUrl, useDirectusVisualEditor } from "../composables/directus";
-const props = defineProps({
-  collection: { type: String, required: true },
-  item: { type: [String, Number], required: true },
-  field: { type: String, required: true }
-});
-const config = useRuntimeConfig();
-const directusVisualEditing = useDirectusVisualEditor();
-const showButton = computed(() => config.public.directus.visualEditor && directusVisualEditing.value);
-function triggerAdd() {
-  const directusUrl = useDirectusOriginUrl();
-  const editConfig = {
-    collection: props.collection,
-    item: props.item,
-    fields: [props.field],
-    mode: "drawer"
-  };
-  try {
-    window.parent.postMessage({
-      action: "edit",
-      data: {
-        key: crypto.randomUUID(),
-        editConfig,
-        rect: { top: 0, left: 0, width: 0, height: 0 }
-      }
-    }, directusUrl);
-  } catch (error) {
-    console.error("[DirectusAddButton] Error triggering add:", error);
-  }
-}
-</script>
-
-<template>
-  <button
-    v-if="showButton"
-    type="button"
-    class="directus-add-button"
-    title="Add new item"
-    @click="triggerAdd"
-  >
-    <slot>
-      <svg
-        xmlns="http://www.w3.org/2000/svg"
-        width="20"
-        height="20"
-        viewBox="0 0 24 24"
-        fill="none"
-        stroke="currentColor"
-        stroke-width="2"
-        stroke-linecap="round"
-        stroke-linejoin="round"
-      >
-        <line x1="12" y1="5" x2="12" y2="19" />
-        <line x1="5" y1="12" x2="19" y2="12" />
-      </svg>
-    </slot>
-  </button>
-</template>
-
-<style scoped>
-.directus-add-button{align-items:center;background:transparent;border:2px dashed #64f;border-radius:8px;color:#64f;cursor:pointer;display:flex;justify-content:center;margin:8px 0;opacity:.6;padding:8px;transition:background .2s,color .2s;width:100%}.directus-add-button:hover{background:rgba(102,68,255,.1);opacity:1}.directus-add-button:active{background:rgba(102,68,255,.2)}
-</style>

package/dist/runtime/components/directus-add-button.vue.d.ts

@@ -1,22 +0,0 @@
-import type { PrimaryKey } from '@directus/types';
-type __VLS_Props = {
-    /** The parent collection that contains the repeater field */
-    collection: string;
-    /** The parent item ID */
-    item: PrimaryKey;
-    /** The field name of the repeater on the parent (e.g., 'blocks') */
-    field: 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/runtime/components/directus-edit-button.d.vue.ts

@@ -1,25 +0,0 @@
-import type { PrimaryKey } from '@directus/types';
-declare const __VLS_export: <T extends keyof DirectusSchema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
-        collection: T;
-        item: PrimaryKey;
-        mode?: "drawer" | "modal" | "popover";
-    }> & (typeof globalThis extends {
-        __VLS_PROPS_FALLBACK: infer P;
-    } ? P : {});
-    expose: (exposed: {}) => void;
-    attrs: any;
-    slots: {
-        default?: (props: {}) => any;
-    };
-    emit: {};
-}>) => import("vue").VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
-};
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_PrettifyLocal<T> = (T extends any ? {
-    [K in keyof T]: T[K];
-} : {
-    [K in keyof T as K]: T[K];
-}) & {};

package/dist/runtime/components/directus-edit-button.vue

@@ -1,64 +0,0 @@
-<script setup>
-import { computed, useRuntimeConfig } from "#imports";
-import { useDirectusOriginUrl, useDirectusVisualEditor } from "../composables/directus";
-const props = defineProps({
-  collection: { type: null, required: true },
-  item: { type: [String, Number], required: true },
-  mode: { type: String, required: false }
-});
-const config = useRuntimeConfig();
-const directusVisualEditing = useDirectusVisualEditor();
-const showButton = computed(() => config.public.directus.visualEditor && directusVisualEditing.value);
-function triggerEdit() {
-  const directusUrl = useDirectusOriginUrl();
-  const editConfig = {
-    collection: props.collection,
-    item: props.item,
-    mode: props.mode ?? "drawer"
-  };
-  try {
-    window.parent.postMessage({
-      action: "edit",
-      data: {
-        key: crypto.randomUUID(),
-        editConfig,
-        rect: { top: 0, left: 0, width: 0, height: 0 }
-      }
-    }, directusUrl);
-  } catch (error) {
-    console.error("[DirectusEditButton] Error triggering edit:", error);
-  }
-}
-</script>
-
-<template>
-  <button
-    v-if="showButton"
-    type="button"
-    class="directus-edit-button"
-    title="Edit in Directus"
-    @click="triggerEdit"
-  >
-    <slot>
-      <svg
-        xmlns="http://www.w3.org/2000/svg"
-        width="24"
-        height="24"
-        viewBox="0 0 24 24"
-        fill="none"
-        stroke="currentColor"
-        stroke-width="2"
-        stroke-linecap="round"
-        stroke-linejoin="round"
-      >
-        <path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7" />
-        <path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z" />
-      </svg>
-      <span>Edit Page</span>
-    </slot>
-  </button>
-</template>
-
-<style scoped>
-.directus-edit-button{align-items:center;background:#64f;border:none;border-radius:8px;bottom:24px;box-shadow:0 4px 12px rgba(102,68,255,.4);color:#fff;cursor:pointer;display:inline-flex;font-size:16px;font-weight:500;gap:8px;padding:12px 20px;position:fixed;right:24px;transition:background .2s,transform .2s,box-shadow .2s;z-index:2147483647}.directus-edit-button:hover{background:#53d;box-shadow:0 6px 16px rgba(102,68,255,.5);transform:translateY(-2px)}.directus-edit-button:active{transform:translateY(0)}
-</style>

package/dist/runtime/components/directus-edit-button.vue.d.ts

@@ -1,25 +0,0 @@
-import type { PrimaryKey } from '@directus/types';
-declare const __VLS_export: <T extends keyof DirectusSchema>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
-        collection: T;
-        item: PrimaryKey;
-        mode?: "drawer" | "modal" | "popover";
-    }> & (typeof globalThis extends {
-        __VLS_PROPS_FALLBACK: infer P;
-    } ? P : {});
-    expose: (exposed: {}) => void;
-    attrs: any;
-    slots: {
-        default?: (props: {}) => any;
-    };
-    emit: {};
-}>) => import("vue").VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
-};
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_PrettifyLocal<T> = (T extends any ? {
-    [K in keyof T]: T[K];
-} : {
-    [K in keyof T as K]: T[K];
-}) & {};