zeti-framework-backend 0.2.4

package/dist/generator-CK-ZmWQj.d.ts

@@ -0,0 +1,197 @@
+import { ZodRawShape, ZodTypeAny, ZodObject, z } from 'zod';
+import { Context, Next } from 'hono';
+import { Z as ZetiSwaggerConfig } from './config-VWgz0Iq_.js';
+
+/**
+ * Handler de middleware com db injetado automaticamente.
+ *
+ * O `db` é obtido do contexto (setado pelo framework) e já vem com:
+ * - Filtro de tenant aplicado (se connectionStrategy = 'dynamic')
+ * - Cache por URL (reutiliza instância base)
+ */
+type MiddlewareHandler<TDb = any> = (c: Context, next: Next, db: TDb) => Promise<void | Response>;
+/**
+ * Cria um middleware com o `db` injetado automaticamente.
+ *
+ * O `db` é obtido do contexto (setado pelo framework) e já vem com:
+ * - Filtro de tenant aplicado (se connectionStrategy = 'dynamic')
+ * - Cache por URL (reutiliza instância base)
+ *
+ * @example
+ * ```typescript
+ * import { PrismaClient } from '@prisma/client';
+ *
+ * const authMiddleware = createMiddleware<PrismaClient>(async (c, next, db) => {
+ *   // db já vem tipado e com filtro de tenant
+ *   const user = await db.user.findUnique({
+ *     where: { id: c.req.header('x-user-id') }
+ *   });
+ *
+ *   if (!user) {
+ *     return c.json({ error: 'Unauthorized' }, 401);
+ *   }
+ *
+ *   c.set('user', user);
+ *   await next();
+ * });
+ * ```
+ */
+declare function createMiddleware<TDb = any>(handler: MiddlewareHandler<TDb>): (c: Context, next: Next) => Promise<void | Response>;
+type MiddlewareFactory<T extends any[], TDb = any> = (...args: T) => (c: Context, next: Next) => Promise<void | Response>;
+/**
+ * Cria uma factory de middleware com db injetado.
+ *
+ * @example
+ * ```typescript
+ * const requirePermission = createMiddlewareFactory<[string[]], PrismaClient>(
+ *   (permissions: string[]) => async (c, next, db) => {
+ *     const user = c.get('user');
+ *     const userPermissions = await db.permission.findMany({
+ *       where: { userId: user.id }
+ *     });
+ *
+ *     const hasPermission = permissions.every(p =>
+ *       userPermissions.some(up => up.name === p)
+ *     );
+ *
+ *     if (!hasPermission) {
+ *       return c.json({ error: 'Forbidden' }, 403);
+ *     }
+ *
+ *     await next();
+ *   }
+ * );
+ *
+ * // Uso:
+ * app.use('/admin/*', requirePermission(['admin:read']));
+ * ```
+ */
+declare function createMiddlewareFactory<T extends any[], TDb = any>(factory: (...args: T) => MiddlewareHandler<TDb>): MiddlewareFactory<T, TDb>;
+/**
+ * Helper para obter o db do contexto de forma tipada.
+ * Útil quando você precisa acessar o db fora do createMiddleware.
+ *
+ * @throws Error se o db não estiver disponível
+ *
+ * @example
+ * ```typescript
+ * // Em um handler de rota Hono puro
+ * app.get('/users', async (c) => {
+ *   const db = getDb<PrismaClient>(c);
+ *   const users = await db.user.findMany();
+ *   return c.json(users);
+ * });
+ * ```
+ */
+declare function getDb<TDb = any>(c: Context): TDb;
+/**
+ * Helper para obter o db do contexto de forma segura (pode retornar undefined).
+ *
+ * @example
+ * ```typescript
+ * // Em um handler de rota Hono puro
+ * app.get('/health', async (c) => {
+ *   const db = getDbSafe<PrismaClient>(c);
+ *   if (!db) {
+ *     return c.json({ status: 'degraded', db: false });
+ *   }
+ *   return c.json({ status: 'ok', db: true });
+ * });
+ * ```
+ */
+declare function getDbSafe<TDb = any>(c: Context): TDb | undefined;
+
+type SchemaDefinition = {
+    body?: ZodRawShape | ZodTypeAny;
+    query?: ZodRawShape | ZodTypeAny;
+    response?: ZodRawShape | ZodTypeAny;
+    formData?: ZodRawShape | ZodTypeAny;
+};
+type NormalizeFormData<T> = T extends ZodTypeAny ? T : T extends ZodRawShape ? ZodObject<T> : never;
+type InferFormData<S extends SchemaDefinition> = S['formData'] extends undefined ? unknown : NormalizeFormData<S['formData']> extends never ? unknown : z.infer<NormalizeFormData<S['formData']>>;
+type NormalizeZod<T> = T extends ZodTypeAny ? T : T extends ZodRawShape ? ZodObject<T> : never;
+type InferBody<S extends SchemaDefinition> = S['body'] extends undefined ? unknown : NormalizeZod<S['body']> extends never ? unknown : z.infer<NormalizeZod<S['body']>>;
+type InferQuery<S extends SchemaDefinition> = S['query'] extends undefined ? unknown : NormalizeZod<S['query']> extends never ? unknown : z.infer<NormalizeZod<S['query']>>;
+type ExtractParams<T extends string> = T extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
+    [K in Param]: string;
+} & ExtractParams<Rest> : T extends `${infer _Start}:${infer Param}` ? {
+    [K in Param]: string;
+} : {};
+type ZetiZod = typeof z;
+type ZetiContextExtensions = {
+    ipAddress?: string;
+    userAgent?: string;
+    timezone: string;
+    tenantId: string;
+};
+type ZetiContext<TContext extends Context = Context> = TContext & ZetiContextExtensions;
+interface ZetiRouteProps<TParams extends Record<string, string>, TBody, TQuery, TFormData, TPrisma = any, TUser = any> {
+    context: ZetiContext;
+    next: Next;
+    params: TParams;
+    body: TBody;
+    query: TQuery;
+    formData: TFormData;
+    user?: TUser;
+    db: TPrisma;
+    res: ZetiResponseHelpers;
+}
+interface ZetiResponseHelpers {
+    goneError: (params: {
+        message: string;
+        code?: string;
+    }) => never;
+    unauthorizedError: (message: string) => never;
+    badRequestError: (message: string) => never;
+}
+interface ZetiMethodOptions<TPath extends string, TSchema extends SchemaDefinition, TPrisma = any, TUser = any> {
+    middleware?: {
+        use?: MiddlewareHandler[];
+        schema?: (z: ZetiZod) => TSchema;
+        database?: string;
+        tenant?: boolean;
+        /** Exige auth (injeta `auth` antes dos demais). */
+        auth?: boolean;
+        /** Claims exigidas (usa `requireClaim` de named). */
+        claims?: string[];
+        /** Roles exigidas (usa `requireRole` de named). */
+        roles?: string[];
+    };
+    route: (props: ZetiRouteProps<ExtractParams<TPath>, InferBody<TSchema>, InferQuery<TSchema>, InferFormData<TSchema>, TPrisma, TUser>) => Promise<any>;
+}
+interface RouteMetadata {
+    path: string;
+    method: 'get' | 'post' | 'put' | 'delete' | 'patch';
+    auth: boolean;
+    tenant?: boolean;
+    claims?: string[];
+    roles?: string[];
+    bodySchema?: ZodTypeAny;
+    querySchema?: ZodTypeAny;
+    responseSchema?: ZodTypeAny;
+    formDataSchema?: ZodTypeAny;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+}
+type ZetiRouteMiddleware<TSchema extends SchemaDefinition> = ZetiMethodOptions<any, TSchema>['middleware'];
+
+declare class SwaggerRegistry {
+    private routes;
+    register(metadata: RouteMetadata): void;
+    getAll(): RouteMetadata[];
+    clear(): void;
+}
+
+interface SwaggerGeneratorOptions {
+    loadGeneratedSchemas?: () => Promise<{
+        routeResponseSchemas?: Record<string, Record<string, {
+            schema: ZodTypeAny;
+            ref: string | null;
+        }>>;
+        namedSchemas?: Record<string, ZodTypeAny>;
+    }>;
+}
+declare function generateSwagger(registry: SwaggerRegistry, config: ZetiSwaggerConfig, options?: SwaggerGeneratorOptions): Promise<object>;
+
+export { type ExtractParams as E, type InferBody as I, type MiddlewareFactory as M, type RouteMetadata as R, type SwaggerGeneratorOptions as S, type ZetiMethodOptions as Z, SwaggerRegistry as a, type SchemaDefinition as b, type InferFormData as c, type InferQuery as d, type MiddlewareHandler as e, type ZetiContext as f, generateSwagger as g, type ZetiContextExtensions as h, type ZetiResponseHelpers as i, type ZetiRouteMiddleware as j, type ZetiRouteProps as k, type ZetiZod as l, createMiddleware as m, createMiddlewareFactory as n, getDb as o, getDbSafe as p };

package/dist/generator-KC24DE6M.js

@@ -0,0 +1,8 @@
+import {
+  generateSwagger
+} from "./chunk-TTILJJ3O.js";
+import "./chunk-7D4SUZUM.js";
+export {
+  generateSwagger
+};
+//# sourceMappingURL=generator-KC24DE6M.js.map

package/dist/generator-KC24DE6M.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,333 @@
+import * as hono_types from 'hono/types';
+import { Context, Next, Hono } from 'hono';
+import { a as ZetiConfigInternal, W as WorkerConfig, b as ZetiPrismaConnectionConfig, R as RedisConfig } from './config-VWgz0Iq_.js';
+export { C as ConnectionStrategy, E as ErrorResponse, c as ErrorTrace, M as Middleware, P as Prisma, d as PrismaClientBase, S as SecurityScope, T as TenantSelection, V as ValidationError, e as WorkersConfig, f as ZetiConfig, g as ZetiCorsConfig, h as ZetiDatabaseConfig, i as ZetiDevConfig, j as ZetiErrorHandlerConfig, k as ZetiHeadersConfig, l as ZetiMiddlewareConfig, m as ZetiPrismaConfig, Z as ZetiSwaggerConfig, n as ZetiSwaggerHeaderParam, o as ZetiTenantConfig, p as closeRedis, q as createErrorHandler, r as defineZetiConfig, s as getRedisClient, t as getRedisConfig, u as handleError, v as initRedis } from './config-VWgz0Iq_.js';
+import { b as SchemaDefinition, Z as ZetiMethodOptions, a as SwaggerRegistry } from './generator-CK-ZmWQj.js';
+export { E as ExtractParams, I as InferBody, c as InferFormData, d as InferQuery, M as MiddlewareFactory, e as MiddlewareHandler, R as RouteMetadata, S as SwaggerGeneratorOptions, f as ZetiContext, h as ZetiContextExtensions, i as ZetiResponseHelpers, j as ZetiRouteMiddleware, k as ZetiRouteProps, l as ZetiZod, m as createMiddleware, n as createMiddlewareFactory, g as generateSwagger, o as getDb, p as getDbSafe } from './generator-CK-ZmWQj.js';
+import { TenantManager } from './tenants/index.js';
+export { MetricsCollector, TenantMetrics } from './tenants/index.js';
+import Redis from 'ioredis';
+export { default as Redis } from 'ioredis';
+import { z } from 'zod';
+export { GenerateRegistryOptions, GenerateSwaggerTypesOptions, generateRegistry, generateSwaggerTypes, runPrebuild } from './scripts/index.js';
+import 'hono/http-exception';
+
+/**
+ * Handler de middleware tipado com o PrismaClient do projeto.
+ */
+type ZetiMiddlewareHandler<TPrisma = any> = (c: Context, next: Next, db: TPrisma) => Promise<void | Response>;
+interface ZetiApp<TPrisma = any, TUser = any> {
+    get: <TPath extends string, TSchema extends SchemaDefinition = {}>(url: TPath, options: ZetiMethodOptions<TPath, TSchema, TPrisma, TUser>) => void;
+    post: <TPath extends string, TSchema extends SchemaDefinition = {}>(url: TPath, options: ZetiMethodOptions<TPath, TSchema, TPrisma, TUser>) => void;
+    put: <TPath extends string, TSchema extends SchemaDefinition = {}>(url: TPath, options: ZetiMethodOptions<TPath, TSchema, TPrisma, TUser>) => void;
+    del: <TPath extends string, TSchema extends SchemaDefinition = {}>(url: TPath, options: ZetiMethodOptions<TPath, TSchema, TPrisma, TUser>) => void;
+    patch: <TPath extends string, TSchema extends SchemaDefinition = {}>(url: TPath, options: ZetiMethodOptions<TPath, TSchema, TPrisma, TUser>) => void;
+    /**
+     * Cria um middleware com o db tipado automaticamente.
+     *
+     * @example
+     * ```typescript
+     * const authMiddleware = app.createMiddleware(async (c, next, db) => {
+     *   const user = await db.user.findUnique({
+     *     where: { id: c.req.header('x-user-id') }
+     *   });
+     *   if (!user) return c.json({ error: 'Unauthorized' }, 401);
+     *   c.set('user', user);
+     *   await next();
+     * });
+     * ```
+     */
+    createMiddleware: (handler: ZetiMiddlewareHandler<TPrisma>) => (c: Context, next: Next) => Promise<void | Response>;
+    honoApp: Hono;
+    swaggerRegistry: SwaggerRegistry;
+    tenantManager: TenantManager;
+    shutdown: () => Promise<void>;
+}
+/**
+ * Cria uma instância do Zeti App
+ *
+ * @template TPrisma - Tipo do PrismaClient do projeto do usuário
+ * @template TUser - Tipo do usuário autenticado (opcional)
+ *
+ * @example
+ * ```typescript
+ * import { PrismaClient } from '@prisma/client';
+ *
+ * const app = createZetiApp<PrismaClient>({
+ *   config,
+ *   prismaClient: PrismaClient,
+ * });
+ *
+ * // Agora todas as rotas terão db tipado como PrismaClient do usuário
+ * app.get('/users', {
+ *   route: async ({ db }) => {
+ *     // db é tipado como PrismaClient do usuário
+ *     // Com todos os modelos do schema.prisma
+ *     const users = await db.user.findMany();
+ *     return { data: users };
+ *   },
+ * });
+ * ```
+ */
+declare function createZetiApp<TPrisma = any, TUser = any>(options: {
+    config: ZetiConfigInternal;
+    prismaClient: new (...args: any[]) => TPrisma;
+}): ZetiApp<TPrisma, TUser>;
+declare function initializeZetiApp<TPrisma = any, TUser = any>(options: {
+    config: ZetiConfigInternal;
+    prismaClient: new (...args: any[]) => TPrisma;
+}): ZetiApp<TPrisma, TUser>;
+declare function getZetiApp(): ZetiApp<any, any> | null;
+declare function getZetiAppTyped<TPrisma = any, TUser = any>(): ZetiApp<TPrisma, TUser>;
+declare function autoInitializeZetiApp<TPrisma = any, TUser = any>(options?: {
+    configPath?: string;
+    prismaClient?: new (...args: any[]) => TPrisma;
+}): Promise<ZetiApp<TPrisma, TUser> | null>;
+declare const honoRoutesZeti: Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">;
+
+/**
+ * Função para obter conexão do banco
+ * Para multi-tenant, recebe o tenantId e retorna o banco do tenant
+ */
+type GetDbFn = (tenantId?: string) => any | Promise<any>;
+/**
+ * Instância de um Worker em execução
+ */
+declare class WorkerInstance {
+    private name;
+    private config;
+    private intervalId;
+    private isRunning;
+    private isProcessing;
+    private isStopping;
+    private getDb;
+    private getTenants?;
+    private executionCount;
+    private startedAt;
+    constructor(name: string, config: WorkerConfig, getDb: GetDbFn, getTenants?: () => string[]);
+    start(): void;
+    /**
+     * Para o worker de forma graciosa, aguardando execução atual terminar
+     */
+    stop(): Promise<void>;
+    /**
+     * Verifica se está processando
+     */
+    getIsProcessing(): boolean;
+    private run;
+}
+/**
+ * Gerenciador de Workers com Graceful Shutdown
+ */
+declare class WorkerManager {
+    private workers;
+    private isShuttingDown;
+    constructor();
+    /**
+     * Configura listeners para sinais de shutdown
+     */
+    private setupGracefulShutdown;
+    startAll(workersConfig: Record<string, WorkerConfig>, getDb: GetDbFn, getTenants?: () => string[]): void;
+    /**
+     * Para todos os workers de forma graciosa
+     */
+    stopAll(): Promise<void>;
+    /**
+     * Para um worker específico
+     */
+    stop(name: string): Promise<void>;
+    getActiveWorkers(): string[];
+    /**
+     * Verifica se algum worker está processando
+     */
+    hasActiveProcessing(): boolean;
+}
+
+interface StartZetiOptions<TPrisma = any, TUser = any> {
+    config: ZetiConfigInternal;
+    prisma?: ZetiPrismaConnectionConfig<TPrisma>;
+    redis?: RedisConfig;
+    port?: number;
+    registryPath?: string;
+    onReady?: (app: ZetiApp<TPrisma, TUser>) => void | Promise<void>;
+}
+declare function startZeti<TPrisma = any, TUser = any>(options: StartZetiOptions<TPrisma, TUser>): Promise<ZetiApp<TPrisma, TUser>>;
+declare function getPrismaClient<TPrisma = any>(tenantId?: string): TPrisma;
+declare function createAppProxy<TPrisma = any, TUser = any>(): ZetiApp<TPrisma, TUser>;
+declare function getPrismaConnectionConfig(): ZetiPrismaConnectionConfig | null;
+declare function getWorkerManager(): WorkerManager | null;
+declare function stopAllWorkers(): void;
+declare function getRedis(): Redis;
+declare function hasRedis(): boolean;
+declare function getRedisConfiguration(): RedisConfig | null;
+declare function shutdownZeti(): Promise<void>;
+
+interface PrismaConfigOptions {
+    /** Caminho do schema. Default: "prisma/schema.prisma" */
+    schema?: string;
+    /** Caminho das migrations. Default: "prisma/migrations" */
+    migrationsPath?: string;
+}
+interface PrismaDefineConfig {
+    schema: string;
+    migrations: {
+        path: string;
+    };
+    datasource: {
+        url: string;
+    };
+}
+/**
+ * Gera a configuração do Prisma.
+ *
+ * Aceita opcionalmente um ZetiConfig, mas NÃO É NECESSÁRIO passá-lo.
+ * A função busca automaticamente a URL do banco no .env.
+ *
+ * @example Uso simples (recomendado para evitar importar zeti.config.ts)
+ * ```typescript
+ * // prisma.config.ts
+ * import { definePrismaConfig } from "zeti-framework";
+ *
+ * export default definePrismaConfig();
+ * ```
+ *
+ * @example Uso com config (opcional)
+ * ```typescript
+ * // prisma.config.ts
+ * import { zetiConfig } from "./zeti.config";
+ * import { definePrismaConfig } from "zeti-framework";
+ *
+ * export default definePrismaConfig(zetiConfig);
+ * ```
+ */
+declare function definePrismaConfig(zetiConfigOrOptions?: ZetiConfigInternal | PrismaConfigOptions, options?: PrismaConfigOptions): PrismaDefineConfig;
+/**
+ * Retorna todas as URLs de banco de dados configuradas (para multi-tenant migrations).
+ *
+ * @example
+ * ```typescript
+ * const urls = getAllDatabaseUrls(zetiConfig);
+ * for (const [name, url] of Object.entries(urls)) {
+ *   console.log(`Migrating ${name}...`);
+ *   // executar migration para cada tenant
+ * }
+ * ```
+ */
+declare function getAllDatabaseUrls(zetiConfig: ZetiConfigInternal): Record<string, string>;
+
+declare function badRequestError(message: string, cause?: any): never;
+declare function unauthorizedError(message: string, cause?: any): never;
+declare function forbiddenError(message: string, cause?: any): never;
+declare function notFoundError(message: string, cause?: any): never;
+declare function conflictError(message: string, cause?: any): never;
+declare function goneError(message: string, cause?: any): never;
+declare function unprocessableEntityError(message: string, cause?: any): never;
+declare function internalServerError(message: string, cause?: any): never;
+
+declare function loadEnv(): void;
+/**
+ * Retorna o valor de uma variável de ambiente.
+ *
+ * @param key - Nome da variável de ambiente
+ * @param fallback - Valor padrão se a variável não existir (padrão: undefined = obrigatório)
+ * @returns O valor da variável ou o fallback
+ * @throws Error se a variável não existir e não houver fallback
+ *
+ * @example
+ * ```typescript
+ * // Obrigatório - lança erro se não existir
+ * const dbUrl = env("DATABASE_URL");
+ *
+ * // Opcional - retorna fallback
+ * const port = env("PORT", "3000");
+ * ```
+ */
+declare function env(key: string, fallback?: string): string;
+
+/**
+ * Symbol usado para identificar schemas de arquivo
+ */
+declare const FILE_SCHEMA_SYMBOL: unique symbol;
+/**
+ * Cria um schema Zod para upload de arquivo
+ *
+ * @example
+ * ```typescript
+ * app.post("/upload", {
+ *   middleware: {
+ *     schema: (zod) => ({
+ *       formData: zod.object({
+ *         file: zFile(),
+ *         avatar: zFile("Foto de perfil"),
+ *         documents: zFiles("Documentos PDF"),
+ *       }),
+ *     }),
+ *   },
+ *   route: async ({ formData }) => {
+ *     const file = formData.file as File;
+ *     // ...
+ *   },
+ * });
+ * ```
+ */
+declare function zFile(description?: string): z.ZodAny;
+/**
+ * Cria um schema Zod para upload de múltiplos arquivos
+ */
+declare function zFiles(description?: string): z.ZodArray<z.ZodAny, "many">;
+/**
+ * Verifica se um schema Zod é um schema de arquivo
+ */
+declare function isFileSchema(schema: z.ZodTypeAny): boolean;
+/**
+ * Verifica se um schema Zod é um schema de múltiplos arquivos
+ */
+declare function isMultipleFileSchema(schema: z.ZodTypeAny): boolean;
+
+/**
+ * Cria middleware que resolve o banco de dados e coloca no contexto.
+ *
+ * Este middleware usa o TenantManager.getContextualClient() para:
+ * 1. Resolver a URL do banco (single ou dynamic)
+ * 2. Aplicar $extends com filtro de tenantId (se aplicável)
+ * 3. Colocar o cliente no contexto via c.set('db', client)
+ *
+ * @param tenantManager - Instância do TenantManager
+ * @returns Middleware do Hono
+ *
+ * @example
+ * ```typescript
+ * // No framework.ts
+ * const dbMiddleware = createDatabaseMiddleware(tenantManager);
+ * honoApp.use('*', dbMiddleware);
+ *
+ * // Nas rotas
+ * app.get('/users', {
+ *   route: async ({ db }) => {
+ *     // db já vem com filtro de tenant aplicado
+ *     const users = await db.user.findMany();
+ *     return { data: users };
+ *   },
+ * });
+ * ```
+ */
+declare function createDatabaseMiddleware(tenantManager: TenantManager): (c: Context, next: Next) => Promise<void>;
+/**
+ * Tipo do contexto com db disponível.
+ * Útil para tipar middlewares customizados.
+ */
+interface DatabaseContext {
+    db: any;
+}
+/**
+ * Helper para obter db do contexto de forma tipada.
+ *
+ * @example
+ * ```typescript
+ * const db = getDbFromContext<PrismaClient>(c);
+ * const users = await db.user.findMany();
+ * ```
+ */
+declare function getDbFromContext<TPrisma = any>(c: Context): TPrisma;
+
+export { type DatabaseContext, FILE_SCHEMA_SYMBOL, type PrismaConfigOptions, RedisConfig, SchemaDefinition, type StartZetiOptions, SwaggerRegistry, TenantManager, WorkerConfig, WorkerInstance, WorkerManager, type ZetiApp, ZetiConfigInternal, ZetiMethodOptions, type ZetiMiddlewareHandler, ZetiPrismaConnectionConfig, autoInitializeZetiApp, badRequestError, conflictError, createAppProxy, createDatabaseMiddleware, createZetiApp, definePrismaConfig, env, forbiddenError, getAllDatabaseUrls, getDbFromContext, getPrismaClient, getPrismaConnectionConfig, getRedis, getRedisConfiguration, getWorkerManager, getZetiApp, getZetiAppTyped, goneError, hasRedis, honoRoutesZeti, initializeZetiApp, internalServerError, isFileSchema, isMultipleFileSchema, loadEnv, notFoundError, shutdownZeti, startZeti, stopAllWorkers, unauthorizedError, unprocessableEntityError, zFile, zFiles };