@nestjs-kitchen/authz 2.0.3 → 2.0.5

package/dist/jwt/jwt-authz.module.js

@@ -1,261 +1,259 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
 };
-var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
-var jwt_authz_module_exports = {};
-__export(jwt_authz_module_exports, {
-  createJwtAuthzModule: () => createJwtAuthzModule
-});
-module.exports = __toCommonJS(jwt_authz_module_exports);
-var import_node_async_hooks = require("node:async_hooks");
-var import_common = require("@nestjs/common");
-var import_uid = require("uid");
-var import_constants = require("../constants");
-var import_errors = require("../errors");
-var import_utils = require("../utils");
-var import_jwt_authz_als = require("./jwt-authz-als.middleware");
-var import_jwt_authz = require("./jwt-authz.guard");
-var import_jwt_authz2 = require("./jwt-authz.interface");
-var import_jwt_authz3 = require("./jwt-authz.service");
-var import_jwt_authz4 = require("./jwt-authz.strategy");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJwtAuthzModule = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+const common_1 = require("@nestjs/common");
+const uid_1 = require("uid");
+const constants_1 = require("../constants");
+const errors_1 = require("../errors");
+const utils_1 = require("../utils");
+const jwt_authz_als_middleware_1 = require("./jwt-authz-als.middleware");
+const jwt_authz_guard_1 = require("./jwt-authz.guard");
+const jwt_authz_interface_1 = require("./jwt-authz.interface");
+const jwt_authz_service_1 = require("./jwt-authz.service");
+const jwt_authz_strategy_1 = require("./jwt-authz.strategy");
 const store = {
-  globalInited: 0
+    globalInited: 0
 };
-const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, ASYNC_OPTIONS_TYPE, OPTIONS_TYPE } = new import_common.ConfigurableModuleBuilder({
-  moduleName: "JwtAuthModule"
-}).setFactoryMethodName("createJwtAuthzModuleOptions").setExtras(
-  {
-    authzProvider: void 0,
+const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, ASYNC_OPTIONS_TYPE, OPTIONS_TYPE } = new common_1.ConfigurableModuleBuilder({
+    moduleName: 'JwtAuthModule'
+})
+    .setFactoryMethodName('createJwtAuthzModuleOptions')
+    .setExtras({
+    authzProvider: undefined,
     global: false
-  },
-  (definition, extras) => {
+}, (definition, extras) => {
     const { authzProvider, global } = extras;
     if (!authzProvider) {
-      throw new import_errors.AuthzError(`InternalError: Missing parameter 'authzProvider' in configuration.`);
+        throw new errors_1.AuthzError(`InternalError: Missing parameter 'authzProvider' in configuration.`);
     }
-    const routes = (0, import_utils.normalizedArray)(extras.routes) ?? [];
-    const excludes = (0, import_utils.normalizedArray)(extras.excludes) ?? [];
+    const routes = (0, utils_1.normalizedArray)(extras.routes) ?? [];
+    const excludes = (0, utils_1.normalizedArray)(extras.excludes) ?? [];
     if (!global && !routes.length) {
-      throw new import_errors.AuthzError(`InternalError: Missing parameter 'global' or 'routes' in configuration.`);
+        throw new errors_1.AuthzError(`InternalError: Missing parameter 'global' or 'routes' in configuration.`);
     }
     if (store.globalInited) {
-      throw new import_errors.AuthzError(
-        `InternalError: Cannot initialize mutiple global modules. Only one global module is allowed.`
-      );
+        throw new errors_1.AuthzError(`InternalError: Cannot initialize mutiple global modules. Only one global module is allowed.`);
     }
     if (global) {
-      store.globalInited += 1;
+        store.globalInited += 1;
     }
-    return (0, import_utils.mergeDynamicModuleConfigs)(definition, {
-      global,
-      providers: [
-        {
-          provide: import_constants.ROUTES_OPTIONS,
-          useValue: {
-            global,
-            excludes,
-            routes
-          }
-        }
-      ],
-      exports: []
+    return (0, utils_1.mergeDynamicModuleConfigs)(definition, {
+        global,
+        providers: [
+            {
+                provide: constants_1.ROUTES_OPTIONS,
+                useValue: {
+                    global,
+                    excludes,
+                    routes
+                }
+            }
+        ],
+        exports: []
     });
-  }
-).build();
+})
+    .build();
+/**
+ * Creates a JWT module along with its associated guard and service,
+ * with types inferred from the provided implementation of `AuthzProviderClass`.
+ *
+ * @param authzProvider - The implementation class of `AuthzProviderClass`
+ * @returns \{AuthzModule, AuthzGuard, AuthzService}
+ */
 const createJwtAuthzModule = (authzProvider) => {
-  const id = `${import_constants.PREFIX}${(0, import_uid.uid)()}`;
-  const JWT_STRATEGY = `${id}_JWT_STRATEGY`;
-  const JWT_REFRESH_STRATEGY = `${id}_REFRESH_STRATEGY`;
-  const AUTHZ_PROVIDER = `${id}_AUTHZ_PROVIDER`;
-  const ALS_PROVIDER = `${id}_ALS_PROVIDER`;
-  const JWT_AUTHZ_OPTIONS = `${id}_JWT_AUTHZ_OPTIONS`;
-  const JWT_META_KEY = `${id}_JWT_META_KEY`;
-  const JWT_REFRESH_META_KEY = `${id}_REFRESH_META_KEY`;
-  const JwtAuthzService = (0, import_jwt_authz3.createJwtAuthzService)([AUTHZ_PROVIDER, JWT_AUTHZ_OPTIONS, ALS_PROVIDER]);
-  const JwtAuthzAlsMiddleware = (0, import_jwt_authz_als.createJwtAuthzAlsMiddleware)([ALS_PROVIDER, JWT_AUTHZ_OPTIONS]);
-  const als = new import_node_async_hooks.AsyncLocalStorage();
-  const JwtStrategy = (0, import_jwt_authz4.createJwtStrategy)([JWT_STRATEGY, AUTHZ_PROVIDER, ALS_PROVIDER]);
-  const RefreshStrategy = (0, import_jwt_authz4.createRefreshStrategy)([JWT_REFRESH_STRATEGY, AUTHZ_PROVIDER, ALS_PROVIDER]);
-  let isStrategyInited = false;
-  const RefreshAuthzGuard = (0, import_jwt_authz.createJwtRefreshAuthzGuard)([JWT_REFRESH_STRATEGY, JWT_AUTHZ_OPTIONS]);
-  const JwtAuthzGuard = (0, import_jwt_authz.createJwtAuthzGuard)([
-    JWT_STRATEGY,
-    AUTHZ_PROVIDER,
-    JWT_AUTHZ_OPTIONS,
-    ALS_PROVIDER,
-    JWT_META_KEY,
-    JWT_REFRESH_META_KEY
-  ]);
-  const Verify = (0, import_utils.createAuthzDecoratorFactory)(JWT_META_KEY);
-  const NoVerify = () => {
-    return (0, import_common.SetMetadata)(JWT_META_KEY, {
-      options: { public: true, override: true }
-    });
-  };
-  const Refresh = () => {
-    return (0, import_common.applyDecorators)(
-      JwtAuthzGuard.NoVerify(),
-      (0, import_common.SetMetadata)(JWT_REFRESH_META_KEY, true),
-      (0, import_common.UseGuards)(RefreshAuthzGuard)
-    );
-  };
-  const Apply = (...rest) => {
-    return (0, import_common.applyDecorators)(JwtAuthzGuard.Verify(...rest), (0, import_common.UseGuards)(JwtAuthzGuard));
-  };
-  JwtAuthzGuard.Verify = Verify;
-  JwtAuthzGuard.NoVerify = NoVerify;
-  JwtAuthzGuard.Refresh = Refresh;
-  JwtAuthzGuard.Apply = Apply;
-  const getCommonConfigs = () => {
-    const configs = {
-      providers: [
-        {
-          provide: AUTHZ_PROVIDER,
-          useClass: authzProvider
-        },
-        {
-          provide: ALS_PROVIDER,
-          useValue: als
-        },
-        ...!isStrategyInited ? [JwtStrategy, RefreshStrategy] : [],
-        JwtAuthzService
-      ],
-      exports: [AUTHZ_PROVIDER, ALS_PROVIDER, JWT_AUTHZ_OPTIONS, JwtAuthzService]
+    // prevent token overriding
+    const id = `${constants_1.PREFIX}${(0, uid_1.uid)()}`;
+    // strategy tokens
+    const JWT_STRATEGY = `${id}_JWT_STRATEGY`;
+    const JWT_REFRESH_STRATEGY = `${id}_REFRESH_STRATEGY`;
+    // provider tokens
+    const AUTHZ_PROVIDER = `${id}_AUTHZ_PROVIDER`;
+    const ALS_PROVIDER = `${id}_ALS_PROVIDER`;
+    const JWT_AUTHZ_OPTIONS = `${id}_JWT_AUTHZ_OPTIONS`;
+    // meta keys
+    const JWT_META_KEY = `${id}_JWT_META_KEY`;
+    const JWT_REFRESH_META_KEY = `${id}_REFRESH_META_KEY`;
+    // providers
+    const JwtAuthzService = (0, jwt_authz_service_1.createJwtAuthzService)([AUTHZ_PROVIDER, JWT_AUTHZ_OPTIONS, ALS_PROVIDER]);
+    const JwtAuthzAlsMiddleware = (0, jwt_authz_als_middleware_1.createJwtAuthzAlsMiddleware)([ALS_PROVIDER, JWT_AUTHZ_OPTIONS]);
+    const als = new node_async_hooks_1.AsyncLocalStorage();
+    // strategy
+    const JwtStrategy = (0, jwt_authz_strategy_1.createJwtStrategy)([JWT_STRATEGY, AUTHZ_PROVIDER, ALS_PROVIDER]);
+    const RefreshStrategy = (0, jwt_authz_strategy_1.createRefreshStrategy)([JWT_REFRESH_STRATEGY, AUTHZ_PROVIDER, ALS_PROVIDER]);
+    // each strategy can be only registered once in passport.
+    // no need to provide multiple times as
+    //  1. they use the same ALS and authzProvider instance.
+    //  2. guard use strategy through passport via strategy name.
+    let isStrategyInited = false;
+    // guards
+    const RefreshAuthzGuard = (0, jwt_authz_guard_1.createJwtRefreshAuthzGuard)([JWT_REFRESH_STRATEGY, JWT_AUTHZ_OPTIONS]);
+    const JwtAuthzGuard = (0, jwt_authz_guard_1.createJwtAuthzGuard)([
+        JWT_STRATEGY,
+        AUTHZ_PROVIDER,
+        JWT_AUTHZ_OPTIONS,
+        ALS_PROVIDER,
+        JWT_META_KEY,
+        JWT_REFRESH_META_KEY
+    ]);
+    const Verify = (0, utils_1.createAuthzDecoratorFactory)(JWT_META_KEY);
+    const NoVerify = () => {
+        return (0, common_1.SetMetadata)(JWT_META_KEY, {
+            options: { public: true, override: true }
+        });
+    };
+    const Refresh = () => {
+        return (0, common_1.applyDecorators)(JwtAuthzGuard.NoVerify(), (0, common_1.SetMetadata)(JWT_REFRESH_META_KEY, true), (0, common_1.UseGuards)(RefreshAuthzGuard));
+    };
+    const Apply = (...rest) => {
+        return (0, common_1.applyDecorators)(JwtAuthzGuard.Verify(...rest), (0, common_1.UseGuards)(JwtAuthzGuard));
+    };
+    JwtAuthzGuard.Verify = Verify;
+    JwtAuthzGuard.NoVerify = NoVerify;
+    JwtAuthzGuard.Refresh = Refresh;
+    JwtAuthzGuard.Apply = Apply;
+    const getCommonConfigs = () => {
+        const configs = {
+            providers: [
+                {
+                    provide: AUTHZ_PROVIDER,
+                    useClass: authzProvider
+                },
+                {
+                    provide: ALS_PROVIDER,
+                    useValue: als
+                },
+                ...(!isStrategyInited ? [JwtStrategy, RefreshStrategy] : []),
+                JwtAuthzService
+            ],
+            exports: [AUTHZ_PROVIDER, ALS_PROVIDER, JWT_AUTHZ_OPTIONS, JwtAuthzService]
+        };
+        isStrategyInited = true;
+        return configs;
+    };
+    let JwtAuthzModule = class JwtAuthzModule extends ConfigurableModuleClass {
+        /**
+         * Configures authz module.
+         */
+        static register(options) {
+            const jwtAuthzOptions = (0, jwt_authz_interface_1.normalizedJwtAuthzModuleOptions)(options);
+            return (0, utils_1.mergeDynamicModuleConfigs)(super.register({ ...options, authzProvider }), getCommonConfigs(), {
+                providers: [
+                    {
+                        provide: JWT_AUTHZ_OPTIONS,
+                        useValue: jwtAuthzOptions
+                    }
+                ]
+            });
+        }
+        /**
+         * Configures authz module asynchronously.
+         */
+        static registerAsync(options) {
+            return (0, utils_1.mergeDynamicModuleConfigs)(super.registerAsync({ ...options, authzProvider }), getCommonConfigs(), {
+                providers: [
+                    {
+                        provide: JWT_AUTHZ_OPTIONS,
+                        useFactory: (moduleOptions) => {
+                            const jwtAuthzOptions = (0, jwt_authz_interface_1.normalizedJwtAuthzModuleOptions)(moduleOptions);
+                            return jwtAuthzOptions;
+                        },
+                        inject: [MODULE_OPTIONS_TOKEN]
+                    }
+                ]
+            });
+        }
+        constructor(routesOpt) {
+            super();
+            this.routesOpt = routesOpt;
+        }
+        configure(consumer) {
+            consumer
+                .apply(JwtAuthzAlsMiddleware)
+                .exclude(...this.routesOpt.excludes)
+                // nestjs v11 will be compatible with splat wildcard.
+                .forRoutes(...(this.routesOpt.global ? ['*'] : this.routesOpt.routes));
+        }
+    };
+    JwtAuthzModule = __decorate([
+        (0, common_1.Module)({}),
+        __param(0, (0, common_1.Inject)(constants_1.ROUTES_OPTIONS)),
+        __metadata("design:paramtypes", [Object])
+    ], JwtAuthzModule);
+    return {
+        /**
+         * A dynamic module used to configure JWT based authentication and authorization features for the application.
+         *
+         * This module can be configured using 2 static methods:
+         *
+         * - `register`
+         * - `registerAsync`
+         *
+         * ### Usage
+         *
+         * ```typescript
+         * ⁣@Module({
+         *   imports: [
+         *     // Import and configure JWT strategy
+         *     AuthzModule.register({
+         *       jwt: {
+         *         jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+         *         secret: '1234567890',
+         *         algorithm: 'HS256'
+         *       },
+         *       // Enable refresh token handling
+         *       refresh: {
+         *         jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+         *         secret: '0987654321',
+         *         algorithm: 'HS256'
+         *       },
+         *       // Apply strategy to specific controllers.
+         *       routes: [BusinessController]
+         *     })
+         *   ],
+         *   controllers: [BusinessController]
+         * })
+         * export class BusinessModule {}
+         * ```
+         */
+        AuthzModule: JwtAuthzModule,
+        /**
+         * A custom guard that applies authentication to controllers.
+         *
+         * This guard also provides 4 utility decorators to apply and modify authorization:
+         *
+         * - `@AuthzGuard.Verify`: Used to verify the user's authorization for specific meta data.
+         * - `@AuthzGuard.NoVerify`: Used to `skip` authentication & authorization checks for specific routes.
+         * - `@AuthzGuard.Apply`: A simplified version of `@UseGuards(AuthzGuard)` and `@AuthzGuard.Verify`, combining both for convenience.
+         * - `@AuthzGuard.Refresh`: Used to ensure that only using refresh token for authentication on specific routes, for refreshing JWT tokens.
+         *
+         * ### Usage:
+         *
+         * ```typescript
+         * ⁣@UseGuards(AuthzGuard)
+         * ⁣@Controller(/⁣/ ...)
+         * export class BusinessController {
+         *   // ...
+         * }
+         * ```
+         */
+        AuthzGuard: JwtAuthzGuard,
+        /**
+         * A custom servcie to provide methods to handle authentication and authorization.
+         */
+        AuthzService: JwtAuthzService
     };
-    isStrategyInited = true;
-    return configs;
-  };
-  let JwtAuthzModule = class extends ConfigurableModuleClass {
-    constructor(routesOpt) {
-      super();
-      this.routesOpt = routesOpt;
-    }
-    /**
-     * Configures authz module.
-     */
-    static register(options) {
-      const jwtAuthzOptions = (0, import_jwt_authz2.normalizedJwtAuthzModuleOptions)(options);
-      return (0, import_utils.mergeDynamicModuleConfigs)(super.register({ ...options, authzProvider }), getCommonConfigs(), {
-        providers: [
-          {
-            provide: JWT_AUTHZ_OPTIONS,
-            useValue: jwtAuthzOptions
-          }
-        ]
-      });
-    }
-    /**
-     * Configures authz module asynchronously.
-     */
-    static registerAsync(options) {
-      return (0, import_utils.mergeDynamicModuleConfigs)(super.registerAsync({ ...options, authzProvider }), getCommonConfigs(), {
-        providers: [
-          {
-            provide: JWT_AUTHZ_OPTIONS,
-            useFactory: (moduleOptions) => {
-              const jwtAuthzOptions = (0, import_jwt_authz2.normalizedJwtAuthzModuleOptions)(moduleOptions);
-              return jwtAuthzOptions;
-            },
-            inject: [MODULE_OPTIONS_TOKEN]
-          }
-        ]
-      });
-    }
-    configure(consumer) {
-      consumer.apply(JwtAuthzAlsMiddleware).exclude(...this.routesOpt.excludes).forRoutes(...this.routesOpt.global ? ["*"] : this.routesOpt.routes);
-    }
-  };
-  JwtAuthzModule = __decorateClass([
-    (0, import_common.Module)({}),
-    __decorateParam(0, (0, import_common.Inject)(import_constants.ROUTES_OPTIONS))
-  ], JwtAuthzModule);
-  return {
-    /**
-     * A dynamic module used to configure JWT based authentication and authorization features for the application.
-     *
-     * This module can be configured using 2 static methods:
-     *
-     * - `register`
-     * - `registerAsync`
-     *
-     * ### Usage
-     *
-     * ```typescript
-     * ⁣@Module({
-     *   imports: [
-     *     // Import and configure JWT strategy
-     *     AuthzModule.register({
-     *       jwt: {
-     *         jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
-     *         secret: '1234567890',
-     *         algorithm: 'HS256'
-     *       },
-     *       // Enable refresh token handling
-     *       refresh: {
-     *         jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
-     *         secret: '0987654321',
-     *         algorithm: 'HS256'
-     *       },
-     *       // Apply strategy to specific controllers.
-     *       routes: [BusinessController]
-     *     })
-     *   ],
-     *   controllers: [BusinessController]
-     * })
-     * export class BusinessModule {}
-     * ```
-     */
-    AuthzModule: JwtAuthzModule,
-    /**
-     * A custom guard that applies authentication to controllers.
-     *
-     * This guard also provides 4 utility decorators to apply and modify authorization:
-     *
-     * - `@AuthzGuard.Verify`: Used to verify the user's authorization for specific meta data.
-     * - `@AuthzGuard.NoVerify`: Used to `skip` authentication & authorization checks for specific routes.
-     * - `@AuthzGuard.Apply`: A simplified version of `@UseGuards(AuthzGuard)` and `@AuthzGuard.Verify`, combining both for convenience.
-     * - `@AuthzGuard.Refresh`: Used to ensure that only using refresh token for authentication on specific routes, for refreshing JWT tokens.
-     *
-     * ### Usage:
-     *
-     * ```typescript
-     * ⁣@UseGuards(AuthzGuard)
-     * ⁣@Controller(/⁣/ ...)
-     * export class BusinessController {
-     *   // ...
-     * }
-     * ```
-     */
-    AuthzGuard: JwtAuthzGuard,
-    /**
-     * A custom servcie to provide methods to handle authentication and authorization.
-     */
-    AuthzService: JwtAuthzService
-  };
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createJwtAuthzModule
-});
+exports.createJwtAuthzModule = createJwtAuthzModule;

package/dist/jwt/jwt-authz.service.d.ts

@@ -1,18 +1,9 @@
-import * as _nestjs_common from '@nestjs/common';
-import { AuthzProviderClass } from '../authz.provider.js';
-import { CookieOptionsWithSecret, DeepReadonly } from '../utils/types.js';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { JwtAlsType } from './jwt-authz-als.middleware.js';
-import { JwtAuthzOptions } from './jwt-authz.interface.js';
-import '@nestjs/common/interfaces';
-import 'express';
-import '../constants.js';
-import 'crypto';
-import 'jsonwebtoken';
-import './extract-jwt.js';
-import 'cookie';
-
-declare const createJwtAuthzService: <P = unknown, U = unknown>([AUTHZ_PROVIDER, JWT_AUTHZ_OPTIONS, ALS_PROVIDER]: [any, any, any]) => _nestjs_common.Type<Omit<{
+import { AuthzProviderClass } from '../authz.provider';
+import { type DeepReadonly } from '../utils';
+import type { JwtAlsType } from './jwt-authz-als.middleware';
+import type { JwtAuthzOptions } from './jwt-authz.interface';
+export declare const createJwtAuthzService: <P = unknown, U = unknown>([AUTHZ_PROVIDER, JWT_AUTHZ_OPTIONS, ALS_PROVIDER]: [any, any, any]) => import("@nestjs/common").Type<Omit<{
     readonly authzProvider: AuthzProviderClass<P, U>;
     readonly jwtAuthzOptions: JwtAuthzOptions;
     readonly als: AsyncLocalStorage<JwtAlsType<U>>;
@@ -44,11 +35,9 @@ declare const createJwtAuthzService: <P = unknown, U = unknown>([AUTHZ_PROVIDER,
     /**
      * Sets a secure HTTP cookie with the given name, value, and optional cookie options.
      */
-    setCookie(name: string, value: string, options?: CookieOptionsWithSecret | undefined): void;
+    setCookie(name: string, value: string, options?: import("../utils").CookieOptionsWithSecret | undefined): void;
     /**
      * Retrieves the current user associated with the request, if available.
      */
     getUser(): DeepReadonly<U> | undefined;
 }, "als" | "jwtAuthzOptions" | "authzProvider">>;
-
-export { createJwtAuthzService };