@spfn/core 0.3.0-beta.2 → 0.3.0-beta.21

package/dist/registry-C2KQCh0m.d.ts

@@ -0,0 +1,473 @@
+/**
+ * Environment Variable Schema Definition System
+ *
+ * 환경변수에 메타데이터를 정의하여 중앙 관리, 문서화, 검증을 지원합니다.
+ *
+ * @example
+ * ```typescript
+ * const schema = defineEnvSchema({
+ *   DATABASE_URL: envUrl({
+ *     description: 'Database connection',
+ *     required: true,
+ *     validator: parsePostgresUrl,
+ *     sensitive: true,
+ *   })
+ * });
+ * ```
+ *
+ * @module env/schema
+ */
+/**
+ * 환경변수 스키마 정의
+ */
+interface EnvVarSchema<T = string> {
+    /** 환경변수 키 */
+    key: string;
+    /** 설명 (목적, 사용처) */
+    description: string;
+    /** 타입 */
+    type: 'string' | 'number' | 'boolean' | 'url' | 'enum' | 'json';
+    /** 필수 여부 */
+    required?: boolean;
+    /** 기본값 */
+    default?: T;
+    /** 검증/변환 함수 */
+    validator?: (value: string) => T;
+    /** Fallback 환경변수 키들 (backward compatibility) */
+    fallbackKeys?: string[];
+    /** 최소 길이 (문자열 타입) */
+    minLength?: number;
+    /** 민감정보 여부 (로깅 시 마스킹) */
+    sensitive?: boolean;
+    /**
+     * 자동 생성 방식 — 값이 미지정이면 프로비저닝(secrets 관리 CLI)이 이 방식으로 생성한다.
+     * 외부에서 받아야 하는 시크릿(API 키 등)은 generate를 비워 사용자 입력으로 둔다.
+     */
+    generate?: 'hex32' | 'hex64' | 'uuid' | 'base64url32';
+    /** 예시 값들 (타입과 일치해야 함) */
+    examples?: T[];
+    /**
+     * Next.js 프로세스에서 사용 여부
+     *
+     * - true: .env.local에 존재해야 함 (Next.js 서버 컴포넌트에서 접근 가능)
+     * - false: .env.server에만 존재해야 함 (SPFN 서버에서만 접근)
+     *
+     * @default NEXT_PUBLIC_* 이면 true, 아니면 false
+     */
+    nextjs?: boolean;
+    /**
+     * Which layer of a deployment must supply the value.
+     *
+     * - `'environment'`: one value shared by every instance of an environment
+     *   (a third-party API key) — kept in `secrets/<env>.enc.json`.
+     * - `'instance'`: a value that differs per instance — kept in
+     *   `secrets/<env>.<instance>.enc.json` or computed by the deploy script
+     *   and passed to `spfn secret export --with <file>`.
+     *
+     * Unset: the value may come from any layer. Set it to pin where a value
+     * must live — `spfn secret export` then fails when the value arrives from
+     * another layer. `--all` on `spfn secret set`/`generate`/`rotate` gives an
+     * unset entry to the environment target only.
+     */
+    layer?: EnvLayer;
+    /**
+     * Files that read this variable under a computed key, as paths relative to
+     * the project root — e.g. `['src/server/config/providers.ts']`.
+     *
+     * `spfn env audit` counts a name as read when it appears as a property
+     * access or a string literal; a name only ever reached through
+     * `env[name]` needs this instead. The name passes when every listed file
+     * exists and is scanned. The runtime ignores `readBy`.
+     */
+    readBy?: string[];
+}
+/**
+ * The layer of a deployment an env value comes from — see {@link EnvVarSchema.layer}.
+ */
+type EnvLayer = 'environment' | 'instance';
+/**
+ * 스키마 컬렉션 타입
+ */
+type EnvSchemaCollection = Record<string, EnvVarSchema<any>>;
+/**
+ * Helper type: Check if field has default value
+ */
+type HasDefault<T> = T extends {
+    default: any;
+} ? true : false;
+/**
+ * Helper type: Check if field is explicitly required
+ */
+type IsRequired<T> = T extends {
+    required: true;
+} ? true : false;
+/**
+ * Helper type: Check if field should be required (has default OR required: true)
+ */
+type ShouldBeRequired<T> = HasDefault<T> extends true ? true : IsRequired<T>;
+/**
+ * 스키마로부터 타입 추출
+ *
+ * required: true 또는 default가 있는 필드 → 필수
+ * required: false 또는 미지정 → optional (| undefined)
+ */
+type InferEnvType<T extends EnvSchemaCollection> = {
+    [K in keyof T as ShouldBeRequired<T[K]> extends true ? K : never]: T[K] extends EnvVarSchema<infer U> ? U : string;
+} & {
+    [K in keyof T as ShouldBeRequired<T[K]> extends true ? never : K]?: T[K] extends EnvVarSchema<infer U> ? U | undefined : string | undefined;
+};
+/**
+ * 스키마 정의 헬퍼 (타입 추론 지원)
+ *
+ * Automatically fills in the `key` property from object keys. Every other
+ * field passes through as written — an entry without `layer` may come from
+ * any deployment layer.
+ *
+ * @example
+ * ```typescript
+ * const schema = defineEnvSchema({
+ *   DATABASE_URL: envString({ description: 'Database URL', required: true })
+ * });
+ * // Automatically adds key: 'DATABASE_URL'
+ * ```
+ */
+declare function defineEnvSchema<T extends Record<string, any>>(schema: T): {
+    [K in keyof T]: T[K] & {
+        key: K;
+    };
+};
+/**
+ * 문자열 스키마 헬퍼
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   API_KEY: {
+ *     ...envString({
+ *       description: 'API authentication key',
+ *       required: true,
+ *       sensitive: true,
+ *     }),
+ *     key: 'API_KEY',
+ *   }
+ * };
+ * ```
+ */
+declare function envString<T extends Omit<EnvVarSchema, 'key' | 'type'>>(options: T): T & {
+    type: 'string';
+    validator: (value: string) => string;
+};
+/**
+ * 시크릿 스키마 헬퍼 — sensitive:true 자동.
+ *
+ * generate 지정 시 프로비저닝(secrets CLI)이 값을 자동 생성, 미지정이면 외부 입력(사용자가 붙여넣음).
+ * 이로써 env.config.ts가 "설정(envString) vs 외부 시크릿(envSecret) vs 자동 시크릿(envSecret+generate)"을
+ * 선언적으로 가른다 — CLI·프레임워크·프로비저닝이 한 원천을 읽는다.
+ *
+ * @example
+ * ```typescript
+ * SPFN_AUTH_SESSION_SECRET: envSecret({ description: '세션 서명 키', generate: 'base64url32' }),
+ * OPENAI_API_KEY: envSecret({ description: 'OpenAI API 키' }),  // generate 없음 → 외부 입력
+ * ```
+ */
+declare function envSecret<T extends Omit<EnvVarSchema, 'key' | 'type' | 'sensitive'>>(options: T): T & {
+    type: 'string';
+    sensitive: true;
+    validator: (value: string) => string;
+};
+/**
+ * 숫자 스키마 헬퍼
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   PORT: {
+ *     ...envNumber({
+ *       description: 'Server port',
+ *       default: 3000,
+ *       validator: createNumberParser({ min: 1, max: 65535 }),
+ *     }),
+ *     key: 'PORT',
+ *   }
+ * };
+ * ```
+ */
+declare function envNumber<T extends Omit<EnvVarSchema<number>, 'key' | 'type'>>(options: T): T & {
+    type: 'number';
+    validator: (value: string) => number;
+};
+/**
+ * Boolean 스키마 헬퍼
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   DEBUG: {
+ *     ...envBoolean({
+ *       description: 'Enable debug mode',
+ *       default: false,
+ *     }),
+ *     key: 'DEBUG',
+ *   }
+ * };
+ * ```
+ */
+declare function envBoolean<T extends Omit<EnvVarSchema<boolean>, 'key' | 'type'>>(options: T): T & {
+    type: 'boolean';
+    validator: (value: string) => boolean;
+};
+/**
+ * URL 스키마 헬퍼
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   DATABASE_URL: {
+ *     ...envUrl({
+ *       description: 'Database connection URL',
+ *       required: true,
+ *       validator: parsePostgresUrl,
+ *     }),
+ *     key: 'DATABASE_URL',
+ *   }
+ * };
+ * ```
+ */
+declare function envUrl<T extends Omit<EnvVarSchema, 'key' | 'type'>>(options: T): T & {
+    type: 'url';
+};
+/**
+ * Enum 스키마 헬퍼
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   LOG_LEVEL: {
+ *     ...envEnum(['debug', 'info', 'warn', 'error'] as const, {
+ *       description: 'Logging level',
+ *       default: 'info',
+ *     }),
+ *     key: 'LOG_LEVEL',
+ *   }
+ * };
+ * ```
+ */
+declare function envEnum<T extends string, O extends Omit<EnvVarSchema<T>, 'key' | 'type' | 'validator'>>(allowed: readonly T[], options: O): O & {
+    type: 'enum';
+    validator: (val: string) => T;
+};
+/**
+ * JSON 스키마 헬퍼
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   CONFIG_JSON: {
+ *     ...envJson<{ host: string; port: number }>({
+ *       description: 'JSON configuration object',
+ *       required: true,
+ *     }),
+ *     key: 'CONFIG_JSON',
+ *   }
+ * };
+ * ```
+ */
+declare function envJson<T = any, O extends Omit<EnvVarSchema<T>, 'key' | 'type' | 'validator'> = Omit<EnvVarSchema<T>, 'key' | 'type' | 'validator'>>(options: O): O & {
+    type: 'json';
+    validator: (val: string) => T;
+};
+/**
+ * 환경변수가 클라이언트에서 접근 가능한지 확인
+ * (NEXT_PUBLIC_ 접두사로 판단)
+ *
+ * @param key - 환경변수 키
+ * @returns 클라이언트에서 접근 가능하면 true
+ *
+ * @example
+ * ```typescript
+ * isClientAccessible('NEXT_PUBLIC_API_URL');  // true
+ * isClientAccessible('DATABASE_URL');         // false
+ * ```
+ */
+declare function isClientAccessible(key: string): boolean;
+/**
+ * 환경변수가 서버 전용인지 확인
+ * (NEXT_PUBLIC_ 접두사가 없으면 서버 전용)
+ *
+ * @param key - 환경변수 키
+ * @returns 서버 전용이면 true
+ *
+ * @example
+ * ```typescript
+ * isServerOnly('DATABASE_URL');              // true
+ * isServerOnly('NEXT_PUBLIC_API_URL');       // false
+ * ```
+ */
+declare function isServerOnly(key: string): boolean;
+/**
+ * 스키마의 nextjs 옵션 값 결정
+ *
+ * 명시적으로 지정되지 않은 경우:
+ * - NEXT_PUBLIC_* → true
+ * - 그 외 → false
+ *
+ * @param schema - 환경변수 스키마
+ * @returns Next.js 프로세스에서 사용 가능 여부
+ */
+declare function isNextjsAccessible(schema: EnvVarSchema): boolean;
+/**
+ * 스키마가 SPFN 서버 전용인지 확인
+ *
+ * @param schema - 환경변수 스키마
+ * @returns SPFN 서버에서만 사용되면 true
+ */
+declare function isSpfnServerOnly(schema: EnvVarSchema): boolean;
+
+/**
+ * Environment Variable Registry
+ *
+ * 환경변수 스키마를 등록하고 타입 안전하게 접근할 수 있는 레지스트리
+ *
+ * @example
+ * ```typescript
+ * const schema = defineEnvSchema({
+ *   DATABASE_URL: envString({ description: 'Database URL', required: true })
+ * });
+ *
+ * const registry = createEnvRegistry(schema);
+ * const env = registry.validate(); // 검증 + env 반환
+ * console.log(env.DATABASE_URL);
+ * ```
+ *
+ * @module env/registry
+ */
+
+/**
+ * 환경변수 레지스트리
+ *
+ * 스키마 기반 환경변수 관리 및 검증
+ */
+declare class EnvRegistry<T extends EnvSchemaCollection = EnvSchemaCollection> {
+    private schemas;
+    private hasValidated;
+    constructor(schemas?: T);
+    /**
+     * 스키마 등록
+     */
+    register(schema: EnvVarSchema): void;
+    /**
+     * 여러 스키마 등록
+     */
+    registerMultiple(schemas: EnvSchemaCollection): void;
+    /**
+     * 검증 상태 리셋 (테스트용)
+     */
+    reset(): void;
+    /**
+     * 환경변수 원시값 가져오기 (fallback 지원)
+     */
+    private getRawValue;
+    /**
+     * 값에 validator 적용
+     */
+    private applyValidator;
+    /**
+     * 스키마 검증 수행 (값 읽기 없이)
+     *
+     * @internal
+     */
+    private validateSchemas;
+    /**
+     * SKIP_ENV_VALIDATION 환경변수 확인
+     */
+    private shouldSkipValidation;
+    /**
+     * 실제 접근 시점에 환경변수 값 가져오기 및 검증
+     *
+     * @internal
+     */
+    private getAndValidate;
+    /**
+     * 모든 환경변수를 명시적으로 검증 (SKIP_ENV_VALIDATION 무시)
+     *
+     * CLI에서 사용하기 위한 메서드로, 모든 required 환경변수를 강제 검증합니다.
+     *
+     * @returns 검증 결과 (errors, warnings)
+     */
+    validateAll(): {
+        errors: Array<{
+            key: string;
+            message: string;
+        }>;
+        warnings: Array<{
+            key: string;
+            message: string;
+        }>;
+    };
+    /**
+     * 환경변수 검증 및 타입 안전한 env 객체 반환
+     *
+     * Proxy 기반으로 구현되어 실제 환경변수 접근 시점에 값을 읽고 검증합니다.
+     * 이를 통해 dotenv 로딩 타이밍과 무관하게 최신 환경변수 값을 가져올 수 있습니다.
+     *
+     * @returns 검증된 환경변수 객체 (Proxy)
+     * @throws {Error} 필수 변수 누락 또는 검증 실패 시
+     *
+     * @example
+     * ```typescript
+     * const registry = createEnvRegistry(schema);
+     * const env = registry.validate(); // 스키마만 검증
+     * // ... dotenv 로딩 ...
+     * console.log(env.DATABASE_URL); // 이 시점에 실제 값 읽기
+     * ```
+     */
+    validate(): InferEnvType<T>;
+}
+/**
+ * 환경변수 검증 결과
+ */
+interface EnvValidationResult {
+    valid: boolean;
+    errors: Array<{
+        key: string;
+        message: string;
+    }>;
+    warnings: Array<{
+        key: string;
+        message: string;
+    }>;
+}
+/**
+ * 레지스트리 생성 헬퍼
+ *
+ * @example
+ * ```typescript
+ * const schema = defineEnvSchema({
+ *   DATABASE_URL: envString({ description: 'Database URL', required: true })
+ * });
+ *
+ * const registry = createEnvRegistry(schema);
+ * const env = registry.validate();
+ * ```
+ */
+declare function createEnvRegistry<T extends EnvSchemaCollection>(schemas: T): EnvRegistry<T>;
+/**
+ * 모든 환경변수를 명시적으로 검증 (SKIP_ENV_VALIDATION 무시)
+ *
+ * CLI `spfn env validate` 명령어에서 사용
+ *
+ * @param registries - 검증할 레지스트리 배열
+ * @returns 검증 결과
+ *
+ * @example
+ * ```typescript
+ * const result = validateAllEnv([coreRegistry, authRegistry]);
+ * if (!result.valid) {
+ *   console.error('Missing env vars:', result.errors);
+ *   process.exit(1);
+ * }
+ * ```
+ */
+declare function validateAllEnv(registries: EnvRegistry<any>[]): EnvValidationResult;
+
+export { type EnvLayer as E, type InferEnvType as I, EnvRegistry as a, type EnvSchemaCollection as b, type EnvValidationResult as c, type EnvVarSchema as d, createEnvRegistry as e, defineEnvSchema as f, envBoolean as g, envEnum as h, envJson as i, envNumber as j, envSecret as k, envString as l, envUrl as m, isClientAccessible as n, isNextjsAccessible as o, isServerOnly as p, isSpfnServerOnly as q, validateAllEnv as v };

package/dist/route/index.d.ts

@@ -1,8 +1,11 @@
-import { a as RouteDef, R as Router } from '../router-Qbssr11H.js';
-export { M as MergedInput, P as PaginatedResult, c as RouteAuthProfile, d as RouteBuilderContext, e as RouteContract, f as RouteHandlerFn, g as RouteInput, h as defineRouter, r as route } from '../router-Qbssr11H.js';
+import { R as RouteDef } from '../route-builder-DRW-MSCJ.js';
+export { M as MergedInput, P as PaginatedResult, a as RouteAuthProfile, b as RouteBuilderContext, c as RouteContract, d as RouteHandlerFn, e as RouteInput, r as route } from '../route-builder-DRW-MSCJ.js';
+import { R as Router } from '../router-4YoIy5fN.js';
+export { d as defineRouter, a as defineUnmappedRouter } from '../router-4YoIy5fN.js';
 import { Hono, MiddlewareHandler } from 'hono';
 import { HttpMethod } from './types.js';
-export { E as ExtractMiddlewareNames, a as NamedMiddleware, N as NamedMiddlewareFactory, d as defineMiddleware, b as defineMiddlewareFactory } from '../define-middleware-DfDP39Nq.js';
+export { RouteEffect } from './types.js';
+export { E as ExtractMiddlewareNames, a as NamedMiddleware, N as NamedMiddlewareFactory, d as defineMiddleware, b as defineMiddlewareFactory } from '../define-middleware-CVKgqo8S.js';
 import * as _sinclair_typebox from '@sinclair/typebox';
 import { TSchema, Kind } from '@sinclair/typebox';
 import 'hono/utils/http-status';

package/dist/route/index.js

@@ -12,6 +12,8 @@ var RouteBuilder = class _RouteBuilder {
   _middlewares;
   _skipMiddlewares;
   _contract;
+  _effect;
+  _summary;
   /**
    * Create a new RouteBuilder with copied properties and optional overrides
    */
@@ -24,6 +26,8 @@ var RouteBuilder = class _RouteBuilder {
     builder._middlewares = overrides?.middlewares ?? this._middlewares;
     builder._skipMiddlewares = overrides?.skipMiddlewares ?? this._skipMiddlewares;
     builder._contract = overrides?.contract ?? this._contract;
+    builder._effect = overrides?.effect ?? this._effect;
+    builder._summary = overrides?.summary ?? this._summary;
     return builder;
   }
   /**
@@ -143,7 +147,7 @@ var RouteBuilder = class _RouteBuilder {
    * @example
    * ```ts
    * // Skip specific middlewares
-   * route.get('/health')
+   * route.get('/status')
    *   .skip(['auth', 'rateLimit'])
    *   .handler(async (c) => c.json({ status: 'ok' }));
    *
@@ -194,6 +198,49 @@ var RouteBuilder = class _RouteBuilder {
   contract(contract) {
     return this.clone({ contract });
   }
+  /**
+   * Declare what invoking this route does
+   *
+   * Read by a command surface (`@spfn/core/surface`, `@spfn/core/ops`),
+   * which announces it in its manifest so a machine caller can tell a read
+   * from a write before it calls — `spfn ops call` asks for `--yes` before a
+   * `destructive` command. A surface built with `defineSurface` refuses an
+   * app command that does not declare one; on `/_ops` it is optional.
+   *
+   * Nothing else reads it: codegen, the route map, and the contract are
+   * unaffected, and a route outside any surface simply carries it.
+   *
+   * @example
+   * ```ts
+   * export const pageAdd = app.route.post('/pages')
+   *   .input({ body: PageAddBody })
+   *   .effect('write')
+   *   .summary('Add a page to the blueprint')
+   *   .handler(async (c) => { ... });
+   * ```
+   */
+  effect(effect) {
+    return this.clone({ effect });
+  }
+  /**
+   * Describe this route in one line for a command surface's manifest
+   *
+   * A surface announces it beside the command in `spfn ops list` and
+   * `--describe`, and refuses one that is empty or longer than 500
+   * characters. Codegen, the route map, and the contract ignore it. On a
+   * module command the module's own summary wins.
+   *
+   * @example
+   * ```ts
+   * export const pageAdd = app.route.post('/pages')
+   *   .effect('write')
+   *   .summary('Add a page to the blueprint')
+   *   .handler(async (c) => { ... });
+   * ```
+   */
+  summary(summary) {
+    return this.clone({ summary });
+  }
   /**
    * Define handler function
    *
@@ -249,6 +296,8 @@ var RouteBuilder = class _RouteBuilder {
       middlewares: this._middlewares,
       skipMiddlewares: this._skipMiddlewares,
       contract: this._contract,
+      ...this._effect !== void 0 ? { effect: this._effect } : {},
+      ...this._summary !== void 0 ? { summary: this._summary } : {},
       handler: fn,
       _input: {},
       _interceptor: {},
@@ -273,43 +322,33 @@ var route = {
 };
 
 // src/route/router.ts
-function createRouterInstance(routes, packageRouters = [], globalMiddlewares = [], contractVersion = null) {
+function createRouterInstance(state) {
   return {
-    routes,
-    _routes: routes,
-    _packageRouters: packageRouters,
-    _globalMiddlewares: globalMiddlewares,
-    _contractVersion: contractVersion,
+    routes: state.routes,
+    _routes: state.routes,
+    _packageRouters: state.packageRouters,
+    _globalMiddlewares: state.globalMiddlewares,
+    _contractVersion: state.contractVersion,
+    _publishesRouteMap: state.publishesRouteMap,
     packages(routers) {
-      const newPackageRouters = [...this._packageRouters, ...routers];
+      const newPackageRouters = [...state.packageRouters, ...routers];
       for (const pkgRouter of routers) {
         if (pkgRouter._packageRouters?.length > 0) {
           newPackageRouters.push(...pkgRouter._packageRouters);
         }
       }
-      return createRouterInstance(
-        this.routes,
-        newPackageRouters,
-        this._globalMiddlewares,
-        this._contractVersion
-      );
+      assertDistinctSurfaces(newPackageRouters);
+      return createRouterInstance({ ...state, packageRouters: newPackageRouters });
     },
     use(middlewares) {
-      return createRouterInstance(
-        this.routes,
-        this._packageRouters,
-        [...this._globalMiddlewares, ...middlewares],
-        this._contractVersion
-      );
+      return createRouterInstance({
+        ...state,
+        globalMiddlewares: [...state.globalMiddlewares, ...middlewares]
+      });
     },
     contractVersion(version) {
       assertContractVersion(version);
-      return createRouterInstance(
-        this.routes,
-        this._packageRouters,
-        this._globalMiddlewares,
-        version
-      );
+      return createRouterInstance({ ...state, contractVersion: version });
     }
   };
 }
@@ -320,8 +359,38 @@ function assertContractVersion(version) {
     );
   }
 }
+function assertDistinctSurfaces(packageRouters) {
+  const namespaces = /* @__PURE__ */ new Set();
+  for (const router of packageRouters) {
+    const namespace = router._surfaceNamespace;
+    if (namespace === void 0) {
+      continue;
+    }
+    if (namespaces.has(namespace)) {
+      throw new Error(
+        `.packages() mounts two command surfaces on "${namespace}". Both serve ${namespace}/_manifest, so the second one's commands would answer while no manifest lists them. Mount one router per namespace.`
+      );
+    }
+    namespaces.add(namespace);
+  }
+}
 function defineRouter(routes) {
-  return createRouterInstance(routes);
+  return createRouterInstance({
+    routes,
+    packageRouters: [],
+    globalMiddlewares: [],
+    contractVersion: null,
+    publishesRouteMap: true
+  });
+}
+function defineUnmappedRouter(routes) {
+  return createRouterInstance({
+    routes,
+    packageRouters: [],
+    globalMiddlewares: [],
+    contractVersion: null,
+    publishesRouteMap: false
+  });
 }
 function FileSchema(options) {
   return Type.Unsafe({
@@ -864,6 +933,6 @@ function isHttpMethod(value) {
 var Nullable = (schema) => Type.Union([schema, Type.Null()]);
 var OptionalNullable = (schema) => Type.Optional(Type.Union([schema, Type.Null()]));
 
-export { FileArraySchema, FileSchema, Nullable, OptionalFileSchema, OptionalNullable, defineMiddleware, defineMiddlewareFactory, defineRouter, formatFileSize, getFileOptions, isFileArraySchema, isFileSchema, isHttpMethod, registerRoutes, route };
+export { FileArraySchema, FileSchema, Nullable, OptionalFileSchema, OptionalNullable, defineMiddleware, defineMiddlewareFactory, defineRouter, defineUnmappedRouter, formatFileSize, getFileOptions, isFileArraySchema, isFileSchema, isHttpMethod, registerRoutes, route };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map