@autofleet/zehut 4.3.4 → 4.3.5

package/lib/index.d.cts

@@ -1,308 +1,314 @@
-import * as fastify from 'fastify';
-import { FastifyPluginCallback } from 'fastify';
-import * as express from 'express';
-import { Handler, Request } from 'express';
-import * as crypto from 'crypto';
-import { LoggerInstanceManager } from '@autofleet/logger';
-import * as outbreak from '@autofleet/outbreak';
-import { newTrace as newTrace$1 } from '@autofleet/outbreak';
-export { outbreak };
+import { LoggerInstanceManager } from "@autofleet/logger";
+import * as outbreak from "@autofleet/outbreak";
+import { newTrace as newTrace$1 } from "@autofleet/outbreak";
+import { Handler, NextFunction, Request, Response } from "express";
+import { FastifyPluginCallback } from "fastify";
 
-type AccountType = 'client' | 'user' | 'service' | 'driver';
+//#region rolldown:runtime
+//#endregion
+//#region src/user/ApiUser.d.ts
+type AccountType = "client" | "user" | "service" | "driver";
 interface EntityPermissions {
-    [key: string]: string[];
+  [key: string]: string[];
 }
 declare const CONTEXTS_IDS_HEADER = "x-af-context-ids";
 interface UserPayload {
-    businessModels: EntityPermissions;
-    fleets: EntityPermissions;
-    demandSources: EntityPermissions;
-    businessAccounts?: EntityPermissions;
-    accountType?: AccountType;
-    contexts?: EntityPermissions;
-    createdAt?: string;
+  businessModels: EntityPermissions;
+  fleets: EntityPermissions;
+  demandSources: EntityPermissions;
+  businessAccounts?: EntityPermissions;
+  accountType?: AccountType;
+  contexts?: EntityPermissions;
+  createdAt?: string;
 }
 interface PartialUserPayload {
-    businessModels?: EntityPermissions;
-    fleets?: EntityPermissions;
-    demandSources?: EntityPermissions;
-    vehicles?: EntityPermissions;
-    drivers?: EntityPermissions;
-    businessAccounts?: EntityPermissions;
+  businessModels?: EntityPermissions;
+  fleets?: EntityPermissions;
+  demandSources?: EntityPermissions;
+  vehicles?: EntityPermissions;
+  drivers?: EntityPermissions;
+  businessAccounts?: EntityPermissions;
 }
 declare class ApiUser {
-    id?: string;
-    accountType?: AccountType;
-    contextIds?: string[];
-    private privatePermissions;
-    private readonly privateElevatedPermissionsHash;
-    private privatePermissionsLegacy;
-    private readonly appPermission;
-    readonly emptyUser: boolean;
-    constructor(id?: string, accountType?: AccountType, elevatedPermissions?: PartialUserPayload, contextIds?: string[]);
-    getUserPermissions(): Promise<UserPayload>;
-    useCustomPermissionLoader(customPermissionLoader: (userId: string) => UserPayload | PromiseLike<UserPayload>): Promise<UserPayload>;
-    get businessModels(): string[];
-    get fleets(): string[];
-    get demandSources(): string[];
-    private getUserProperty;
-    get elevatedPermissions(): UserPayload;
-    get permissions(): UserPayload | undefined;
-    elevatePermissions(addedPermissions: PartialUserPayload): (() => void) & {
-        [Symbol.dispose]: () => void;
-    };
-    getUserPermissionsLegacy(): Promise<any>;
-    get permissionsLegacy(): any;
-    getUserAppPermissions(appId: string, clientSecret: string): Promise<UserPayload | undefined>;
+  id?: string | undefined;
+  accountType?: AccountType | undefined;
+  contextIds?: string[] | undefined;
+  private privatePermissions;
+  private readonly privateElevatedPermissionsHash;
+  private privatePermissionsLegacy;
+  private readonly appPermission;
+  readonly emptyUser: boolean;
+  constructor(id?: string | undefined, accountType?: AccountType | undefined, elevatedPermissions?: PartialUserPayload, contextIds?: string[] | undefined);
+  getUserPermissions(): Promise<UserPayload>;
+  useCustomPermissionLoader(customPermissionLoader: (userId: string) => UserPayload | PromiseLike<UserPayload>): Promise<UserPayload>;
+  get businessModels(): string[];
+  get fleets(): string[];
+  get demandSources(): string[];
+  private getUserProperty;
+  get elevatedPermissions(): UserPayload;
+  get permissions(): UserPayload | undefined;
+  elevatePermissions(addedPermissions: PartialUserPayload): (() => void) & {
+    [Symbol.dispose]: () => void;
+  };
+  getUserPermissionsLegacy(): Promise<unknown>;
+  get permissionsLegacy(): any;
+  getUserAppPermissions(appId: string, clientSecret: string): Promise<UserPayload | undefined>;
 }
-
+//#endregion
+//#region src/user/common.d.ts
 type CustomPermissionLoader = (userId: string) => Promise<UserPayload>;
 interface AuthFromUserIdHeaderOptions {
-    eagerLoadUserPermissions?: boolean;
-    eagerLoadUserPermissionsLegacy?: boolean;
-    customPermissionLoader?: CustomPermissionLoader;
+  eagerLoadUserPermissions?: boolean;
+  eagerLoadUserPermissionsLegacy?: boolean;
+  customPermissionLoader?: CustomPermissionLoader;
 }
-
-declare module 'express-serve-static-core' {
-    interface Request {
-        user: ApiUser;
-    }
+//#endregion
+//#region src/user/index.d.ts
+declare module "express-serve-static-core" {
+  interface Request {
+    user: ApiUser;
+  }
 }
-declare const middleware: (options?: AuthFromUserIdHeaderOptions) => Handler;
+type Asyncify<T extends (...a: any[]) => any> = (...a: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
+declare const middleware: (options?: AuthFromUserIdHeaderOptions) => Asyncify<Handler>;
 declare const middlewareWithDecode: (options?: {
-    eagerLoadUserPermissions?: boolean;
-    eagerLoadUserPermissionsLegacy?: boolean;
-    returnErrorIfNoToken?: boolean;
-}) => Handler;
+  eagerLoadUserPermissions?: boolean;
+  eagerLoadUserPermissionsLegacy?: boolean;
+  returnErrorIfNoToken?: boolean;
+}) => Asyncify<Handler>;
 declare const appMiddleware: (options: {
-    appId: string;
-    clientSecret: string;
-}) => Handler;
-declare const eagerLoadPermissionsMiddleware: Handler;
+  appId: string;
+  clientSecret: string;
+}) => Asyncify<Handler>;
+declare const eagerLoadPermissionsMiddleware: Asyncify<Handler>;
 declare const getDecodedBearer: (req: Request) => any;
 declare const createOrSetRabbitTrace: (trace: ReturnType<typeof newTrace$1> | undefined, userId: string | undefined) => Promise<void>;
-
-declare module 'fastify' {
-    interface FastifyRequest {
-        user?: ApiUser;
-    }
+//#endregion
+//#region src/user/fastify.d.ts
+declare module "fastify" {
+  interface FastifyRequest {
+    user?: ApiUser;
+  }
 }
 declare const authFromUserIdHeaderPlugin: FastifyPluginCallback<AuthFromUserIdHeaderOptions>;
-
+//#endregion
+//#region src/check-permission.d.ts
 declare const getUser: () => ApiUser | undefined;
-declare const isUserExist: () => string;
+declare const isUserExist: () => string | undefined;
 declare const checkFleetPermission: (fleetId: string) => boolean;
 declare const checkBusinessModelPermission: (businessModelId: string) => boolean;
 declare const checkDemandSourcePermission: (demandSourceId: string) => boolean;
-
+//#endregion
+//#region src/errors.d.ts
 declare class UnauthorizedAccessError extends Error {
-    user: ApiUser | null;
-    constructor(user?: ApiUser | null, message?: string);
+  user: ApiUser | null;
+  constructor(user?: ApiUser | null, message?: string);
 }
-
+//#endregion
+//#region src/secret-getter.d.ts
 declare const getRefreshTokenSecret: (token?: string) => string;
 declare const getTokenSecret: (token?: string) => string;
-
+//#endregion
+//#region src/authorization.d.ts
 declare const AUTHORIZATION_METHODS: {
-    NONE: string;
-    BASIC: string;
-    JWT: string;
+  NONE: string;
+  BASIC: string;
+  JWT: string;
 };
 declare const getAuthorizationHeader: (authorizationSettings: {
-    method: string;
+  method: string;
 } | undefined) => string | undefined;
-
+//#endregion
+//#region src/permissions/SDK/consts.d.ts
 declare const PERMISSIONS_EVALUATION_OPERATORS: {
-    AND: string;
-    OR: string;
+  AND: string;
+  OR: string;
 };
 declare const PERMISSION_ERROR_TYPES: {
-    USER_NOT_FOUND: string;
-    INSUFFICIENT_PERMISSIONS: string;
-    VALIDATION_ERROR: string;
-    API_ERROR: string;
-    NO_REQUIRED_PERMISSIONS: string;
-    UNAUTHORIZED: string;
-    BAD_REQUEST: string;
-    INTERNAL_ERROR: string;
+  USER_NOT_FOUND: string;
+  INSUFFICIENT_PERMISSIONS: string;
+  VALIDATION_ERROR: string;
+  API_ERROR: string;
+  NO_REQUIRED_PERMISSIONS: string;
+  UNAUTHORIZED: string;
+  BAD_REQUEST: string;
+  INTERNAL_ERROR: string;
 };
-
+//#endregion
+//#region src/permissions/SDK/errors.d.ts
 type PermissionErrorType = typeof PERMISSION_ERROR_TYPES[keyof typeof PERMISSION_ERROR_TYPES];
-
+//#endregion
+//#region src/permissions/SDK/types.d.ts
 type Logger = {
-    debug: (message: string, meta?: unknown) => void;
-    info: (message: string, meta?: unknown) => void;
-    warn: (message: string, meta?: unknown) => void;
-    error: (message: string, meta?: unknown) => void;
+  debug: (message: string, meta?: unknown) => void;
+  info: (message: string, meta?: unknown) => void;
+  warn: (message: string, meta?: unknown) => void;
+  error: (message: string, meta?: unknown) => void;
 };
 /**
- * The operator to use when evaluating permissions
- * - AND: All required permissions must be present
- * - OR: At least one required permission must be present
- */
+* The operator to use when evaluating permissions
+* - AND: All required permissions must be present
+* - OR: At least one required permission must be present
+*/
 type PermissionsEvaluationOperator = typeof PERMISSIONS_EVALUATION_OPERATORS[keyof typeof PERMISSIONS_EVALUATION_OPERATORS];
 /**
- * Options for evaluating permissions
- * - requireAll: If true, all contexts must have the required permissions for the user to be considered authorized (default: true)
- * - timeout: Optional - timeout in milliseconds for the permissions evaluation (default: 10 seconds)
- * - enforce: Optional - If true, the permissions evaluation will throw an error if the user does not have the required permissions (default: false)
- * - permissionsEvaluationOperator: Optional - If set, the permissions evaluation will use this operator to evaluate the permissions (default: AND)
- */
+* Options for evaluating permissions
+* - requireAll: If true, all contexts must have the required permissions for the user to be considered authorized (default: true)
+* - timeout: Optional - timeout in milliseconds for the permissions evaluation (default: 10 seconds)
+* - enforce: Optional - If true, the permissions evaluation will throw an error if the user does not have the required permissions (default: false)
+* - permissionsEvaluationOperator: Optional - If set, the permissions evaluation will use this operator to evaluate the permissions (default: AND)
+*/
 type EvaluatePermissionsOpts = {
-    requireAll?: boolean;
-    timeout?: number;
-    enforce?: boolean;
-    permissionsEvaluationOperator?: PermissionsEvaluationOperator;
+  requireAll?: boolean;
+  timeout?: number;
+  enforce?: boolean;
+  permissionsEvaluationOperator?: PermissionsEvaluationOperator;
 };
 /**
- * Parameters for evaluating permissions for a user across multiple contexts
- * - requiredPermissions: The required permissions to check against the user
- * - contextIds: The context IDs to check the permissions against
- * - logger: logger instance for logging
- * - options: Options for evaluating permissions {@link EvaluatePermissionsOpts}
- * - userId: The user id, if not provided, we will get the user from the current context
- */
+* Parameters for evaluating permissions for a user across multiple contexts
+* - requiredPermissions: The required permissions to check against the user
+* - contextIds: The context IDs to check the permissions against
+* - logger: logger instance for logging
+* - options: Options for evaluating permissions {@link EvaluatePermissionsOpts}
+* - userId: The user id, if not provided, we will get the user from the current context
+*/
 type EvaluatePermissionsParams = {
-    requiredPermissions: string[];
-    contextIds: string[];
-    logger: Logger;
-    options: EvaluatePermissionsOpts;
-    userId?: string;
+  requiredPermissions: string[];
+  contextIds: string[];
+  logger?: Logger;
+  options: EvaluatePermissionsOpts;
+  userId?: string;
 };
 /**
- * The permissions evaluation result for a specific context
- * - permissions: The full list of permissions the user has in the context
- * - hasRequiredPermissions: Whether the user has the required permissions in the context
+* Parameters for resolving permissions for a user across multiple contexts
+* - user: The user for whom permissions are being resolved
+* - contextIds: The list of context IDs to resolve permissions for
+* - requiredPermissions: The list of permissions to check for each context
+* - options: Options for evaluating permissions {@link EvaluatePermissionsOpts}
+*/
+
+/**
+* The permissions evaluation result for a specific context
+* - permissions: The full list of permissions the user has in the context
+* - hasRequiredPermissions: Whether the user has the required permissions in the context
 */
 type PermissionsEvaluation = {
-    permissions: string[];
-    hasRequiredPermissions: boolean;
+  permissions: string[];
+  hasRequiredPermissions: boolean;
 };
 /**
- * A mapping of context IDs to their corresponding permissions evaluation results
- */
+* A mapping of context IDs to their corresponding permissions evaluation results
+*/
 type PermissionsEvaluationByContextId = Record<string, PermissionsEvaluation>;
 /**
- * A mapping of context IDs to the list of permissions the user has in that context
- * - isAuthorized: Whether the user has the required permissions in any of the contexts
- * - userId: The ID of the user
- * - resolvedPermissions: The detailed permissions evaluation results by context ID
- * - requiredPermissions: The list of permissions that were required for the evaluation
- * - contextIds: The list of context IDs that were evaluated
- * - error: Optional error type if the evaluation failed
- * - message: Optional error message if the evaluation failed
- */
+* A mapping of context IDs to the list of permissions the user has in that context
+* - isAuthorized: Whether the user has the required permissions in any of the contexts
+* - userId: The ID of the user
+* - resolvedPermissions: The detailed permissions evaluation results by context ID
+* - requiredPermissions: The list of permissions that were required for the evaluation
+* - contextIds: The list of context IDs that were evaluated
+* - error: Optional error type if the evaluation failed
+* - message: Optional error message if the evaluation failed
+*/
 type PermissionCheckResult = {
-    isAuthorized: boolean;
-    userId?: string;
-    resolvedPermissions: PermissionsEvaluationByContextId;
-    requiredPermissions: string[];
-    contextIds: string[];
-    error?: PermissionErrorType;
-    message?: string;
+  isAuthorized: boolean;
+  userId?: string;
+  resolvedPermissions: PermissionsEvaluationByContextId;
+  requiredPermissions: string[];
+  contextIds: string[];
+  error?: PermissionErrorType;
+  message?: string;
 };
-
+/**
+* A mapping of context IDs to the list of the effective permissions the user has in that context
+*/
+//#endregion
+//#region src/permissions/SDK/evaluatePermissions.d.ts
+/**
+* Main SDK function to evaluate user permissions
+* Checks both cached and API-resolved permissions to determine access
+* @param params - {@link EvaluatePermissionsParams}
+* @returns {@link PermissionCheckResult} Detailed permission check result with access status and context
+*/
+declare const evaluatePermissions: ({
+  requiredPermissions,
+  contextIds,
+  logger,
+  userId,
+  options: {
+    requireAll,
+    permissionsEvaluationOperator,
+    timeout
+  }
+}: EvaluatePermissionsParams) => Promise<PermissionCheckResult>;
+//#endregion
+//#region src/permissions/middleware/requirePermissions.d.ts
 interface RequirePermissionsOptions extends EvaluatePermissionsOpts {
-    logger?: LoggerInstanceManager;
+  logger?: LoggerInstanceManager;
 }
-
-declare const sdk: {
-    evaluatePermissions: ({ requiredPermissions, contextIds, logger, userId, options: { requireAll, permissionsEvaluationOperator, timeout, }, }: EvaluatePermissionsParams) => Promise<PermissionCheckResult>;
-};
-declare const middlewares: {
-    requirePermissions: (requiredPermissions: string[], options?: RequirePermissionsOptions) => (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<void | express.Response<any, Record<string, any>>>;
-};
-declare const _default$1: {
-    sdk: {
-        evaluatePermissions: ({ requiredPermissions, contextIds, logger, userId, options: { requireAll, permissionsEvaluationOperator, timeout, }, }: EvaluatePermissionsParams) => Promise<PermissionCheckResult>;
-    };
-    middlewares: {
-        requirePermissions: (requiredPermissions: string[], options?: RequirePermissionsOptions) => (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<void | express.Response<any, Record<string, any>>>;
-    };
-};
-
-declare const permissions_middlewares: typeof middlewares;
-declare const permissions_sdk: typeof sdk;
-declare namespace permissions {
-  export { _default$1 as default, permissions_middlewares as middlewares, permissions_sdk as sdk };
+/**
+* Express middleware that requires specific permissions for route access
+*
+* @param requiredPermissions - Array of permissions required to access the route
+* @param options - Configuration options for permission checking
+* @returns Express middleware function
+*/
+declare const requirePermissions: (requiredPermissions: string[], options?: RequirePermissionsOptions) => (req: Request, res: Response, next: NextFunction) => Promise<void>;
+declare namespace index_d_exports {
+  export { _default as default, middlewares, sdk };
 }
-
-declare const getCurrentPayload: () => {
-    type: "httpRequest" | "webSocket" | "rabbit" | "bull";
-    readonly id: crypto.UUID;
-    readonly context: Map<string, unknown>;
-    readonly nonHeaderContext: Map<string, unknown>;
-} | Record<string, never>;
+interface SdkExports {
+  evaluatePermissions: typeof evaluatePermissions;
+}
+interface MiddlewareExports {
+  requirePermissions: typeof requirePermissions;
+}
+interface PermissionsModule {
+  sdk: SdkExports;
+  middlewares: MiddlewareExports;
+}
+declare const sdk: SdkExports;
+declare const middlewares: MiddlewareExports;
+declare const _default: PermissionsModule;
+//#endregion
+//#region src/index.d.ts
+declare const getCurrentPayload: typeof outbreak.getCurrentContext;
 type OutbreakOptions = Parameters<typeof outbreak.default>[0];
-type LoggerWithContextMiddleware = Partial<Pick<LoggerInstanceManager, 'addContextMiddleware'>>;
-declare const enableTracing: ({ outbreakOptions, logger }?: {
-    outbreakOptions?: OutbreakOptions;
-    logger?: LoggerWithContextMiddleware;
+type LoggerWithContextMiddleware = Partial<Pick<LoggerInstanceManager, "addContextMiddleware">>;
+declare const enableTracing: ({
+  outbreakOptions,
+  logger
+}?: {
+  outbreakOptions?: OutbreakOptions;
+  logger?: LoggerWithContextMiddleware;
 }) => void;
-declare const traceTypes: {
-    readonly HTTP_REQUEST: "httpRequest";
-    readonly WEB_SOCKET: "webSocket";
-    readonly RABBIT: "rabbit";
-    readonly BULL_MQ: "bull";
-};
-declare const newTrace: (type: "httpRequest" | "webSocket" | "rabbit" | "bull") => {
-    type: "httpRequest" | "webSocket" | "rabbit" | "bull";
-    readonly id: crypto.UUID;
-    readonly context: Map<string, unknown>;
-    readonly nonHeaderContext: Map<string, unknown>;
-};
-
-declare const _default: {
-    traceTypes: {
-        readonly HTTP_REQUEST: "httpRequest";
-        readonly WEB_SOCKET: "webSocket";
-        readonly RABBIT: "rabbit";
-        readonly BULL_MQ: "bull";
-    };
-    newTrace: (type: "httpRequest" | "webSocket" | "rabbit" | "bull") => {
-        type: "httpRequest" | "webSocket" | "rabbit" | "bull";
-        readonly id: crypto.UUID;
-        readonly context: Map<string, unknown>;
-        readonly nonHeaderContext: Map<string, unknown>;
-    };
-    User: typeof ApiUser;
-    middleware: (options?: AuthFromUserIdHeaderOptions) => express.Handler;
-    middlewareWithDecode: (options?: {
-        eagerLoadUserPermissions?: boolean;
-        eagerLoadUserPermissionsLegacy?: boolean;
-        returnErrorIfNoToken?: boolean;
-    }) => express.Handler;
-    eagerLoadPermissionsMiddleware: express.Handler;
-    getCurrentPayload: () => {
-        type: "httpRequest" | "webSocket" | "rabbit" | "bull";
-        readonly id: crypto.UUID;
-        readonly context: Map<string, unknown>;
-        readonly nonHeaderContext: Map<string, unknown>;
-    } | Record<string, never>;
-    getDecodedBearer: (req: express.Request) => any;
-    checkFleetPermission: (fleetId: string) => boolean;
-    checkBusinessModelPermission: (businessModelId: string) => boolean;
-    checkDemandSourcePermission: (demandSourceId: string) => boolean;
-    isUserExist: () => string;
-    getUser: () => ApiUser | undefined;
-    UnauthorizedAccessError: typeof UnauthorizedAccessError;
-    appMiddleware: (options: {
-        appId: string;
-        clientSecret: string;
-    }) => express.Handler;
-    createOrSetRabbitTrace: (trace: ReturnType<typeof outbreak.newTrace> | undefined, userId: string | undefined) => Promise<void>;
-    outbreak: typeof outbreak;
-    AUTHORIZATION_METHODS: {
-        NONE: string;
-        BASIC: string;
-        JWT: string;
-    };
-    getAuthorizationHeader: (authorizationSettings: {
-        method: string;
-    } | undefined) => string | undefined;
-    CONTEXTS_IDS_HEADER: string;
-    authFromUserIdHeaderPlugin: fastify.FastifyPluginCallback<AuthFromUserIdHeaderOptions>;
-    permissions: typeof permissions;
-};
-
-export { AUTHORIZATION_METHODS, CONTEXTS_IDS_HEADER, UnauthorizedAccessError, ApiUser as User, type UserPayload, appMiddleware, authFromUserIdHeaderPlugin, checkBusinessModelPermission, checkDemandSourcePermission, checkFleetPermission, createOrSetRabbitTrace, _default as default, eagerLoadPermissionsMiddleware, enableTracing, getAuthorizationHeader, getCurrentPayload, getDecodedBearer, getRefreshTokenSecret, getTokenSecret, getUser, isUserExist, middleware, middlewareWithDecode, newTrace, permissions, traceTypes };
+declare const traceTypes: typeof outbreak.traceTypes;
+declare const newTrace: typeof outbreak.newTrace;
+interface Default {
+  traceTypes: typeof outbreak.traceTypes;
+  newTrace: typeof outbreak.newTrace;
+  User: typeof ApiUser;
+  middleware: typeof middleware;
+  middlewareWithDecode: typeof middlewareWithDecode;
+  eagerLoadPermissionsMiddleware: typeof eagerLoadPermissionsMiddleware;
+  getCurrentPayload: typeof outbreak.getCurrentContext;
+  getDecodedBearer: typeof getDecodedBearer;
+  checkFleetPermission: typeof checkFleetPermission;
+  checkBusinessModelPermission: typeof checkBusinessModelPermission;
+  checkDemandSourcePermission: typeof checkDemandSourcePermission;
+  isUserExist: typeof isUserExist;
+  getUser: typeof getUser;
+  UnauthorizedAccessError: typeof UnauthorizedAccessError;
+  appMiddleware: typeof appMiddleware;
+  createOrSetRabbitTrace: typeof createOrSetRabbitTrace;
+  outbreak: typeof outbreak;
+  AUTHORIZATION_METHODS: typeof AUTHORIZATION_METHODS;
+  getAuthorizationHeader: typeof getAuthorizationHeader;
+  CONTEXTS_IDS_HEADER: typeof CONTEXTS_IDS_HEADER;
+  authFromUserIdHeaderPlugin: typeof authFromUserIdHeaderPlugin;
+  permissions: typeof index_d_exports;
+}
+declare const zehutDefault: Default;
+//#endregion
+export { AUTHORIZATION_METHODS, CONTEXTS_IDS_HEADER, UnauthorizedAccessError, ApiUser as User, type UserPayload, appMiddleware, authFromUserIdHeaderPlugin, checkBusinessModelPermission, checkDemandSourcePermission, checkFleetPermission, createOrSetRabbitTrace, zehutDefault as default, eagerLoadPermissionsMiddleware, enableTracing, getAuthorizationHeader, getCurrentPayload, getDecodedBearer, getRefreshTokenSecret, getTokenSecret, getUser, isUserExist, middleware, middlewareWithDecode, newTrace, outbreak, index_d_exports as permissions, traceTypes };
+//# sourceMappingURL=index.d.cts.map