nuxt-feathers-zod 0.1.0

package/README.md

@@ -0,0 +1,283 @@
+# nuxt-feathers-zod
+
+Nuxt 4 module that embeds a **FeathersJS v5 (Dove)** server into **Nitro** and generates a **typed Feathers client** for your Nuxt app, with **Zod-first validation**.
+It's using and inspired from project **[https://github.com/GaborTorma/feathers-nitro-adapter.git]()**
+
+This repository ships a ready-to-run playground (`nuxi dev playground`) and a module you can install in your own Nuxt application.
+
+## Features
+
+- FeathersJS v5 server running inside Nitro (no separate server process required)
+- REST transport (Koa or Express) and optional Socket.io (websocket)
+- Zod schemas for data + query validation (server-side)
+- Optional client integration with Pinia stores (via `feathers-pinia`)
+- Generated types for services (`ServiceTypes`) and shared client service registrations (`*.shared.ts`)
+
+## Requirements
+
+- Node.js 18+ (or Bun)
+- Nuxt 4
+
+## Install
+
+In your Nuxt application:
+
+```bash
+# Bun
+bun add nuxt-feathers-zod feathers-pinia
+
+# npm
+npm i nuxt-feathers-zod feathers-pinia
+```
+
+Then enable the module:
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['nuxt-feathers-zod'],
+})
+```
+
+## Minimal configuration
+
+Below is a minimal configuration that:
+
+- exposes Feathers REST under `/feathers` (default)
+- enables websocket (`/socket.io`)
+- enables authentication (local + jwt)
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['nuxt-feathers-zod'],
+  feathers: {
+    servicesDirs: ['services'],
+    transports: {
+      rest: { path: '/feathers', framework: 'koa' },
+      websocket: { path: '/socket.io' },
+    },
+    database: {
+      mongo: {
+        url: process.env.MONGODB_URL || 'mongodb://127.0.0.1:27017/nuxt-feathers-zod',
+      },
+    },
+    client: {
+      pinia: {
+        // where Pinia stores will be generated/loaded from (if you use them)
+        storesDirs: ['stores'],
+        // default id field for services
+        idField: 'id',
+        // per-service overrides
+        services: {
+          mongos: { idField: '_id' },
+        },
+      },
+    },
+    auth: {
+      entity: 'user',
+      service: 'users',
+      authStrategies: ['local', 'jwt'],
+      local: { usernameField: 'userId', passwordField: 'password' },
+      // IMPORTANT: always set in production via env
+      secret: process.env.AUTH_SECRET || 'dev-secret-change-me',
+    },
+  },
+})
+```
+
+## Transport examples
+
+### REST with Koa (default)
+
+```ts
+export default defineNuxtConfig({
+  modules: ['nuxt-feathers-zod'],
+  feathers: {
+    transports: { rest: { framework: 'koa' } },
+  },
+})
+```
+
+### REST with Express
+
+```ts
+export default defineNuxtConfig({
+  modules: ['nuxt-feathers-zod'],
+  feathers: {
+    transports: { rest: { framework: 'express' } },
+  },
+})
+```
+
+If you use Express REST, ensure your project includes the Express transport dependencies (Feathers server side):
+
+```bash
+bun add @feathersjs/express express
+```
+
+### WebSocket with Socket.io
+
+```ts
+export default defineNuxtConfig({
+  modules: ['nuxt-feathers-zod'],
+  feathers: {
+    transports: {
+      websocket: { path: '/socket.io', connectTimeout: 45_000 },
+    },
+  },
+})
+```
+
+When both REST and websocket are enabled, the generated client typically uses REST on SSR and websocket in the browser.
+
+## Service structure
+
+Services live in `services/**` and follow this convention:
+
+- `services/<name>/<name>.class.ts` – Feathers service class (MongoDB, memory, custom, ...)
+- `services/<name>/<name>.schema.ts` – Zod schemas + Feathers resolvers
+- `services/<name>/<name>.ts` – service registration + hooks
+- `services/<name>/<name>.shared.ts` – client registration (used by generator)
+
+## Using the generated client in your app
+
+The module injects a typed Feathers client as `nuxtApp.$api`.
+
+```ts
+// example: in a component or composable
+const { $api } = useNuxtApp()
+
+// typed service access (if you generated types)
+const users = $api.service('users')
+const list = await users.find({ query: {} })
+```
+
+## Authentication: testing with curl
+
+Create a user:
+
+```bash
+curl -i -X POST "http://localhost:3000/feathers/users" \
+  -H "Content-Type: application/json" \
+  -d '{"userId":"demo","password":"demo123"}'
+```
+
+Authenticate:
+
+```bash
+curl -i -X POST "http://localhost:3000/feathers/authentication" \
+  -H "Content-Type: application/json" \
+  -d '{"strategy":"local","userId":"demo","password":"demo123"}'
+```
+
+Use the JWT to call a protected endpoint:
+
+```bash
+curl -i "http://localhost:3000/feathers/users" \
+  -H "Authorization: Bearer <ACCESS_TOKEN>"
+```
+
+## Playground
+
+Run the playground:
+
+```bash
+bun install
+bun run dev
+```
+
+Open:
+
+- Nuxt app: `http://localhost:3000/`
+- Feathers REST: `http://localhost:3000/feathers/*`
+
+### End-to-end smoke test (REST + auth)
+
+Once the dev server is up, run the following commands in a terminal.
+
+Create a user:
+
+```bash
+curl -i -X POST "http://localhost:3000/feathers/users" \
+  -H "Content-Type: application/json" \
+  -d '{"userId":"demo","password":"demo123"}'
+```
+
+Authenticate (local strategy):
+
+```bash
+curl -i -X POST "http://localhost:3000/feathers/authentication" \
+  -H "Content-Type: application/json" \
+  -d '{"strategy":"local","userId":"demo","password":"demo123"}'
+```
+
+Copy the `accessToken` from the JSON response, then call a protected route:
+
+```bash
+curl -i "http://localhost:3000/feathers/users" \
+  -H "Authorization: Bearer <ACCESS_TOKEN>"
+```
+
+Expected:
+
+- `POST /feathers/users` returns `201`
+- `POST /feathers/authentication` returns `201` and an `accessToken`
+- `GET /feathers/users` returns `200` when `Authorization: Bearer ...` is provided
+
+### WebSocket smoke test (Socket.io)
+
+If you enabled `transports.websocket`, you can test websocket connectivity with a tiny script.
+
+```bash
+# from the repo root
+bun -e "
+import { io } from 'socket.io-client'
+const socket = io('http://localhost:3000', { path: '/socket.io', transports: ['websocket'] })
+socket.on('connect', async () => {
+  console.log('connected', socket.id)
+  socket.disconnect()
+  process.exit(0)
+})
+socket.on('connect_error', (e) => {
+  console.error('connect_error', e?.message || e)
+  process.exit(1)
+})
+"
+```
+
+If you want to test authenticated websocket calls, use `@feathersjs/socketio-client` in a small script (see `playground/` for a browser-first example).
+
+## Publishing to npm
+
+This repository is a Nuxt module. The published package should only contain the compiled output (see `files: ["dist"]` in `package.json`).
+
+Recommended flow:
+
+```bash
+# 1) install
+bun install
+
+# 2) run unit + type tests
+bun run test:types
+bun run test
+
+# 3) build the module (produces ./dist)
+bun run prepare
+
+# 4) publish (from the repo root)
+npm publish --access public
+```
+
+Notes:
+
+- Keep Feathers packages aligned (single version across the workspace). This repo uses `overrides` for that purpose.
+- Do not publish `playground/` build artifacts (`playground/.nuxt`, `playground/node_modules`).
+
+## Notes about SSR and Pinia auth bootstrap
+
+The runtime auth bootstrap (`src/runtime/plugins/feathers-auth.ts`) re-authenticates **client-side only** to avoid SSR startup failures when the Feathers client is not yet injected.
+
+## License
+
+MIT

package/dist/module.d.mts

@@ -0,0 +1,17 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { ModuleConfig, FeathersRuntimeConfig, FeathersPublicRuntimeConfig, ModuleOptions } from '../dist/runtime/options/index.js';
+
+declare module '@nuxt/schema' {
+    interface NuxtConfig {
+        feathers?: ModuleConfig;
+    }
+    interface RuntimeConfig {
+        _feathers: FeathersRuntimeConfig;
+    }
+    interface PublicRuntimeConfig {
+        _feathers: FeathersPublicRuntimeConfig;
+    }
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "nuxt-feathers-zod",
+  "configKey": "feathers",
+  "compatibility": {
+    "nuxt": "^4.0.0"
+  },
+  "version": "0.1.0",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,124 @@
+import { defineNuxtModule, createResolver, addImportsDir, addTemplate, addServerPlugin, addImports, addPlugin, hasNuxtModule, installModule } from '@nuxt/kit';
+import { consola } from 'consola';
+import defu from 'defu';
+import { resolveOptions, resolveRuntimeConfig, resolvePublicRuntimeConfig } from '../dist/runtime/options/index.js';
+import { serverDefaults } from '../dist/runtime/options/server.js';
+import { getServicesImports, addServicesImports } from '../dist/runtime/services.js';
+import { getClientTemplates } from '../dist/runtime/templates/client/index.js';
+import { getServerTemplates } from '../dist/runtime/templates/server/index.js';
+
+function setAliases(options, nuxt) {
+  const resolver = createResolver(import.meta.url);
+  const aliases = {
+    "nuxt-feathers-zod/server": resolver.resolve(options.templateDir, "server/server"),
+    "nuxt-feathers-zod/validators": resolver.resolve("runtime/zod/validators"),
+    "nuxt-feathers-zod/query": resolver.resolve("runtime/zod/query"),
+    "nuxt-feathers-zod/zod": resolver.resolve("runtime/zod/index"),
+    "nuxt-feathers-zod/options": resolver.resolve("runtime/options")
+  };
+  nuxt.options.alias = defu(nuxt.options.alias, aliases);
+  if (options.client)
+    nuxt.options.alias["nuxt-feathers-zod/client"] = resolver.resolve(options.templateDir, "client/client");
+  nuxt.hook("nitro:config", async (nitroConfig) => {
+    nitroConfig.alias = defu(nitroConfig.alias, aliases);
+  });
+}
+function setTsIncludes(options, nuxt) {
+  const resolver = createResolver(import.meta.url);
+  const servicesDirs = options.servicesDirs.map((dir) => resolver.resolve(dir, "**/*.ts"));
+  nuxt.hook("prepare:types", async ({ tsConfig }) => {
+    tsConfig.include?.push(...servicesDirs);
+  });
+  nuxt.hook("nitro:config", (nitroConfig) => {
+    nitroConfig.typescript?.tsConfig?.include?.push(...servicesDirs);
+  });
+}
+async function loadPinia(client) {
+  const storesDirs = client.pinia?.storesDirs;
+  if (storesDirs?.length) {
+    if (hasNuxtModule("@pinia/nuxt"))
+      return consola.warn("Pinia is already loaded, skipping your configuration");
+    await installModule("@pinia/nuxt", { storesDirs });
+  }
+  if (!hasNuxtModule("@pinia/nuxt"))
+    await installModule("@pinia/nuxt");
+}
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "nuxt-feathers-zod",
+    configKey: "feathers",
+    compatibility: {
+      nuxt: "^4.0.0"
+    }
+  },
+  // Default configuration options of the Nuxt module
+  defaults: {
+    transports: {
+      websocket: true
+    },
+    server: serverDefaults,
+    client: true,
+    servicesDirs: [],
+    validator: {
+      formats: [],
+      extendDefaults: true
+    },
+    loadFeathersConfig: false,
+    auth: true
+  },
+  async setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    const resolvedOptions = await resolveOptions(options, nuxt);
+    nuxt.options.runtimeConfig._feathers = resolveRuntimeConfig(resolvedOptions);
+    nuxt.options.runtimeConfig.public._feathers = resolvePublicRuntimeConfig(resolvedOptions);
+    const servicesImports = await getServicesImports(resolvedOptions.servicesDirs);
+    await addServicesImports(servicesImports);
+    setAliases(resolvedOptions, nuxt);
+    setTsIncludes(resolvedOptions, nuxt);
+    if (resolvedOptions.transports.websocket) {
+      nuxt.hook("nitro:config", (nitroConfig) => {
+        nitroConfig.experimental = defu(nitroConfig.experimental, { websocket: true });
+      });
+    }
+    addImportsDir(resolver.resolve("./runtime/composables"));
+    let serverPluginDst;
+    for (const serverTemplate of getServerTemplates(resolvedOptions)) {
+      const tpl = addTemplate({ ...serverTemplate, options: resolvedOptions });
+      if (serverTemplate.filename?.endsWith("server/plugin.ts") || serverTemplate.filename?.endsWith("server/plugin"))
+        serverPluginDst = tpl.dst;
+    }
+    addServerPlugin(serverPluginDst ?? resolver.resolve(resolvedOptions.templateDir, "server/plugin.ts"));
+    if (resolvedOptions.client) {
+      const clientOptions = resolvedOptions.client;
+      if (clientOptions.pinia) {
+        await loadPinia(clientOptions);
+        nuxt.hook("vite:extendConfig", (config) => {
+          config.optimizeDeps?.include?.push("feathers-pinia");
+        });
+        if (resolvedOptions.auth) {
+          addImports({ from: resolver.resolve("./runtime/stores/auth"), name: "useAuthStore" });
+          addPlugin({ order: 1, src: resolver.resolve("./runtime/plugins/feathers-auth") });
+        }
+      }
+      let clientPluginDst;
+      for (const clientTemplate of getClientTemplates(resolvedOptions, resolver)) {
+        const tpl = addTemplate({ ...clientTemplate, options: resolvedOptions });
+        if (clientTemplate.filename?.endsWith("client/plugin.ts") || clientTemplate.filename?.endsWith("client/plugin"))
+          clientPluginDst = tpl.dst;
+      }
+      addPlugin({ order: 0, src: clientPluginDst ?? resolver.resolve(resolvedOptions.templateDir, "client/plugin.ts"), mode: "client" });
+    }
+    nuxt.hook("mcp:setup", ({ mcp }) => {
+      mcp.tool("get-feathers-config", "Get the Feathers config", {}, async () => {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(resolvedOptions, null, 2)
+          }]
+        };
+      });
+    });
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/adapters/ofetch.d.ts

@@ -0,0 +1,5 @@
+import type { Params } from '@feathersjs/feathers';
+import { FetchClient } from '@feathersjs/rest-client';
+export declare class OFetch extends FetchClient {
+    request(options: any, params: Params): Promise<any>;
+}

package/dist/runtime/adapters/ofetch.js

@@ -0,0 +1,18 @@
+import { FetchClient } from "@feathersjs/rest-client";
+export class OFetch extends FetchClient {
+  async request(options, params) {
+    const fetchOptions = Object.assign({}, options, params.connection);
+    fetchOptions.headers = Object.assign({ Accept: "application/json" }, this.options.headers, fetchOptions.headers);
+    if (options.body)
+      fetchOptions.body = options.body;
+    try {
+      const response = await this.connection.raw(options.url, fetchOptions);
+      const { _data, status } = response;
+      if (status === 204)
+        return null;
+      return _data;
+    } catch (error) {
+      throw error.data;
+    }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { ServiceTypes } from 'nuxt-feathers-zod/client';
+export declare function useFeathers(): {
+    api: import("feathers-pinia").FeathersPiniaClient<import("nuxt-feathers-zod/client").ClientApplication>;
+};
+export declare function useService<L extends keyof ServiceTypes>(path: L): import("@feathersjs/feathers").FeathersService<import("feathers-pinia").FeathersPiniaClient<import("nuxt-feathers-zod/client").ClientApplication>, import("feathers-pinia").CreatePiniaServiceTypes<import("nuxt-feathers-zod/client").ClientApplication>[L]>;

package/dist/runtime/composables/feathers.js

@@ -0,0 +1,9 @@
+import { useNuxtApp } from "#imports";
+export function useFeathers() {
+  const { $api: api } = useNuxtApp();
+  return { api };
+}
+export function useService(path) {
+  const { api } = useFeathers();
+  return api.service(path);
+}

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

@@ -0,0 +1 @@
+export { createPiniaClient, defineGetters, defineSetters, defineValues, useAuth, useBackup, useDataStore, useInstanceDefaults, useServiceInstance, } from 'feathers-pinia';

package/dist/runtime/composables/pinia.js

@@ -0,0 +1,11 @@
+export {
+  createPiniaClient,
+  defineGetters,
+  defineSetters,
+  defineValues,
+  useAuth,
+  useBackup,
+  useDataStore,
+  useInstanceDefaults,
+  useServiceInstance
+} from "feathers-pinia";

package/dist/runtime/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class NuxtFeathersError extends Error {
+    constructor(message?: string);
+}

package/dist/runtime/errors.js

@@ -0,0 +1,5 @@
+export class NuxtFeathersError extends Error {
+  constructor(message) {
+    super(`[nuxt-feathers-zod]: ${message}`);
+  }
+}

package/dist/runtime/options/authentication/client.d.ts

@@ -0,0 +1,13 @@
+import type { AuthStrategies } from '.';
+export interface AuthClientOptions {
+    header?: string;
+    scheme?: string;
+    storageKey?: string;
+    locationKey?: string;
+    locationErrorKey?: string;
+    jwtStrategy?: string;
+    path?: string;
+}
+export type ResolvedAuthClientOptions = AuthClientOptions;
+export declare function getAuthClientDefaults(authStrategies: AuthStrategies): ResolvedAuthClientOptions;
+export declare function resolveAuthClientOptions(authClient: AuthClientOptions | undefined, authStrategies: AuthStrategies): ResolvedAuthClientOptions;

package/dist/runtime/options/authentication/client.js

@@ -0,0 +1,12 @@
+import defu from "defu";
+import { getAuthClientJwtDefaults } from "./jwt.js";
+export function getAuthClientDefaults(authStrategies) {
+  if (!authStrategies.includes("jwt"))
+    return {};
+  return getAuthClientJwtDefaults();
+}
+export function resolveAuthClientOptions(authClient, authStrategies) {
+  const defaultAuthClient = getAuthClientDefaults(authStrategies);
+  const resolvedAuthClient = defu(authClient || {}, defaultAuthClient);
+  return resolvedAuthClient;
+}

package/dist/runtime/options/authentication/index.d.ts

@@ -0,0 +1,42 @@
+import type { Import } from 'unimport';
+import type { ModuleOptions } from '..';
+import type { AuthClientOptions } from './client.js';
+import type { AuthJwtOptions } from './jwt.js';
+import type { AuthLocalOptions } from './local.js';
+export type AuthStrategy = 'jwt' | 'local';
+export type AuthStrategies = [AuthStrategy] | [AuthStrategy, AuthStrategy];
+export interface StaticAuthOptions {
+    service: string;
+    entity: string;
+    entityClass: string;
+}
+export interface DefaultAuthOptions extends StaticAuthOptions {
+    authStrategies: AuthStrategies;
+    secret: string;
+    entityImport?: Import;
+}
+export interface AdditionalAuthOptions {
+    jwtOptions?: AuthJwtOptions;
+    local?: AuthLocalOptions;
+    client?: AuthClientOptions;
+}
+export type AuthOptions = Partial<DefaultAuthOptions> & AdditionalAuthOptions;
+export interface ResolvedAuthOptions extends DefaultAuthOptions, AdditionalAuthOptions {
+    entityImport: Import;
+}
+export type ResolvedAuthOptionsOrDisabled = ResolvedAuthOptions | false;
+export type ResolvedAuthOptionsWithOutEntityImport = Omit<ResolvedAuthOptions, 'entityImport'>;
+export interface PublicAuthOptions {
+    authStrategies: AuthStrategies;
+    servicePath: string;
+    entityKey: string;
+    entityClass: string;
+    client: AuthClientOptions;
+}
+export declare const authStaticDefaults: StaticAuthOptions;
+export declare function getAuthStaticDefaults(): StaticAuthOptions;
+export declare const defaultAuthStrategies: AuthStrategies;
+export declare function getDefaultAuthStrategies(): AuthStrategies;
+export declare function getAuthDefaults(appDir: string, authStrategies?: AuthStrategies): ResolvedAuthOptionsWithOutEntityImport;
+export declare const authClientDefaultOptions: AuthClientOptions;
+export declare function resolveAuthOptions(auth: ModuleOptions['auth'], client: boolean, servicesImports: Import[], appDir: string): ResolvedAuthOptionsOrDisabled;

package/dist/runtime/options/authentication/index.js

@@ -0,0 +1,71 @@
+import { capitalCase } from "change-case";
+import defu from "defu";
+import { klona } from "klona";
+import { digest } from "ohash";
+import { NuxtFeathersError } from "../../errors.js";
+import { resolveAuthClientOptions } from "./client.js";
+import { getAuthJwtDefaults } from "./jwt.js";
+import { getAuthLocalDefaults } from "./local.js";
+export const authStaticDefaults = {
+  entity: "user",
+  entityClass: "User",
+  service: "users"
+};
+export function getAuthStaticDefaults() {
+  return klona(authStaticDefaults);
+}
+export const defaultAuthStrategies = ["local", "jwt"];
+export function getDefaultAuthStrategies() {
+  return klona(defaultAuthStrategies);
+}
+export function getAuthDefaults(appDir, authStrategies) {
+  authStrategies ||= getDefaultAuthStrategies();
+  const authOptions = {
+    ...getAuthStaticDefaults(),
+    secret: digest(appDir),
+    authStrategies
+  };
+  if (authStrategies.includes("jwt"))
+    authOptions.jwtOptions = getAuthJwtDefaults();
+  if (authStrategies.includes("local"))
+    authOptions.local = getAuthLocalDefaults();
+  return authOptions;
+}
+function getEntityClass(authOptions) {
+  return authOptions.entityClass || capitalCase(authOptions.entity || "") || authStaticDefaults.entityClass;
+}
+export const authClientDefaultOptions = {
+  storageKey: "feathers-jwt"
+};
+export function resolveAuthOptions(auth, client, servicesImports, appDir) {
+  if (auth === false)
+    return false;
+  let authOptions;
+  const authDefaults = getAuthDefaults(appDir, auth?.authStrategies);
+  if (auth === true) {
+    authOptions = authDefaults;
+  } else {
+    authOptions = defu(auth, authDefaults);
+    authOptions.authStrategies = authDefaults.authStrategies;
+    if (!authOptions.authStrategies?.includes("jwt"))
+      delete authOptions.jwtOptions;
+    if (!authOptions.authStrategies?.includes("local"))
+      delete authOptions.local;
+  }
+  if (client)
+    authOptions.client = resolveAuthClientOptions(authOptions.client, authOptions.authStrategies);
+  else
+    delete authOptions.client;
+  const entityClass = getEntityClass(auth);
+  const entityImport = servicesImports.find((i) => i.as === entityClass);
+  if (!entityImport)
+    throw new NuxtFeathersError(`Entity class ${entityClass} not found in services imports`);
+  entityImport.from = entityImport.from.replace(/\.ts$/, "");
+  const resolvedAuth = {
+    ...authOptions,
+    entityClass,
+    entityImport
+  };
+  console.log(resolvedAuth);
+  return resolvedAuth;
+}

package/dist/runtime/options/authentication/jwt-types.d.ts

@@ -0,0 +1,29 @@
+export type Algorithm = 'HS256' | 'HS384' | 'HS512' | 'RS256' | 'RS384' | 'RS512' | 'ES256' | 'ES384' | 'ES512' | 'PS256' | 'PS384' | 'PS512' | 'none';
+export interface JwtHeader {
+    'alg': string | Algorithm;
+    'typ'?: string | undefined;
+    'cty'?: string | undefined;
+    'crit'?: Array<string | Exclude<keyof JwtHeader, 'crit'>> | undefined;
+    'kid'?: string | undefined;
+    'jku'?: string | undefined;
+    'x5u'?: string | string[] | undefined;
+    'x5t#S256'?: string | undefined;
+    'x5t'?: string | undefined;
+    'x5c'?: string | string[] | undefined;
+}
+export interface SignOptions {
+    algorithm?: Algorithm | undefined;
+    keyid?: string | undefined;
+    expiresIn?: string | number;
+    notBefore?: string | number | undefined;
+    audience?: string | string[] | undefined;
+    subject?: string | undefined;
+    issuer?: string | undefined;
+    jwtid?: string | undefined;
+    mutatePayload?: boolean | undefined;
+    noTimestamp?: boolean | undefined;
+    header?: JwtHeader | undefined;
+    encoding?: string | undefined;
+    allowInsecureKeySizes?: boolean | undefined;
+    allowInvalidAsymmetricKeyTypes?: boolean | undefined;
+}