@buildplease/apikit 1.0.0

package/dist/src/index.d.cts

@@ -0,0 +1,3049 @@
+import "reflect-metadata";
+import { Assembly, JSONSerializable, UnitFormatterController } from "@buildplease/core";
+import fastifyCookie, { SerializeOptions } from "@fastify/cookie";
+import { IncomingHttpHeaders } from "http";
+import fastifyBasicAuth, { FastifyBasicAuthOptions } from "@fastify/basic-auth";
+import fastifyCors, { FastifyCorsOptions } from "@fastify/cors";
+import { InitOptions, TOptions } from "i18next";
+import { Logger, LoggerTransportOptions } from "@buildplease/core/node";
+import { FastifyInstance, FastifyReply, FastifyRequest, FastifySchema, RouteOptions } from "fastify";
+import fastifyMultipart, { FastifyMultipartAttachFieldsToBodyOptions, FastifyMultipartBaseOptions, FastifyMultipartOptions } from "@fastify/multipart";
+import fastifyStatic, { FastifyStaticOptions } from "@fastify/static";
+import { AvifOptions, FormatEnum, GifOptions, HeifOptions, Jp2Options, JpegOptions, JxlOptions, PngOptions, ResizeOptions, Sharp, TiffOptions, WebpOptions } from "sharp";
+import { Readable } from "stream";
+import fp from "fastify-plugin";
+import fastifyUnderPressure from "@fastify/under-pressure";
+import fastifyView from "@fastify/view";
+import fastifyIp from "fastify-ip";
+import fastifyMetrics from "fastify-metrics";
+import { ZodType, z } from "zod";
+export * from "@buildplease/core";
+export * from "@buildplease/core/node";
+//#region src/request/request-log-metadata.d.ts
+declare class RequestLogMetadata {
+  private readonly metadata;
+  constructor(metadata: Partial<RequestMetadata>);
+  toJSON(): object | undefined;
+}
+//#endregion
+//#region src/http/cookie.d.ts
+type CookieOptions = SerializeOptions;
+interface CookieMutation {
+  name?: string;
+  value?: string;
+  options?: CookieOptions;
+}
+declare class Cookie {
+  private _name;
+  private _value;
+  private _options;
+  constructor(name: string, value: string, options?: CookieOptions);
+  get name(): string;
+  get value(): string;
+  get options(): Readonly<CookieOptions>;
+  mutate(mutation: CookieMutation): this;
+  serialize(): string;
+  toString(): string;
+}
+//#endregion
+//#region src/http/http-headers.d.ts
+declare const HttpHeaders: {
+  readonly accept: "accept";
+  readonly acceptLanguage: "accept-language";
+  readonly authorization: "authorization";
+  readonly cacheControl: "cache-control";
+  readonly contentType: "content-type";
+  readonly cookie: "cookie";
+  readonly setCookie: "set-cookie";
+  readonly userAgent: "user-agent";
+};
+interface HttpHeaders extends IncomingHttpHeaders {}
+type HttpHeaderValues = { [K in keyof HttpHeaders as string extends K ? never : number extends K ? never : K]: HttpHeaders[K]; };
+type HttpHeaderKey = Extract<keyof HttpHeaderValues, string>;
+//#endregion
+//#region src/http/http-method.d.ts
+declare enum HttpMethod {
+  POST = "POST",
+  PUT = "PUT",
+  PATCH = "PATCH",
+  GET = "GET",
+  DELETE = "DELETE",
+  OPTIONS = "OPTIONS"
+}
+//#endregion
+//#region src/http/http-response.d.ts
+declare enum ResponseType {
+  JSON = "JSON",
+  File = "File"
+}
+declare abstract class HttpResponse {
+  readonly statusCode: number;
+  readonly headers?: HttpHeaders;
+  abstract readonly responseType: ResponseType;
+  constructor({ statusCode, headers }: {
+    statusCode: number;
+    headers?: HttpHeaders;
+  });
+}
+declare class JSONHttpResponse extends HttpResponse {
+  readonly data: any;
+  readonly responseType = ResponseType.JSON;
+  constructor({ statusCode, data, headers }: {
+    statusCode: number;
+    data: any;
+    headers?: HttpHeaders;
+  });
+}
+declare class FileHttpResponse extends HttpResponse {
+  readonly filePath: string;
+  readonly shouldRender: boolean;
+  readonly data?: any;
+  readonly responseType = ResponseType.File;
+  constructor({ statusCode, filePath, shouldRender, headers, data }: {
+    statusCode: number;
+    filePath: string;
+    shouldRender: boolean;
+    headers?: HttpHeaders;
+    data?: any;
+  });
+}
+//#endregion
+//#region src/request/request-metadata.d.ts
+interface RequestMetadata {
+  requestId: string;
+  method: string;
+  url: string;
+  protocol: string;
+  query: any;
+  params: any;
+  ip: string;
+  headers: HttpHeaders;
+  locale: string;
+}
+//#endregion
+//#region src/request/request-scope.d.ts
+interface RequestScopeData {
+  metadata: RequestMetadata;
+}
+interface IRequestScope {
+  readonly metadata: RequestMetadata;
+  readonly locale: string;
+  readonly requestId: string;
+  run<T>(data: RequestScopeData, callback: () => T): T;
+}
+declare const RequestScope: IRequestScope;
+//#endregion
+//#region types/fastify.d.ts
+declare module 'fastify' {
+  interface FastifyRequest {
+    metadata: RequestMetadata;
+  }
+}
+//#endregion
+//#region src/configuration/core/build-metadata.d.ts
+interface BuildMetadata {
+  readonly name: {
+    readonly original: string;
+    readonly base: string;
+  };
+  readonly version: string;
+  readonly id: string;
+  readonly createdAt: string;
+}
+//#endregion
+//#region src/configuration/core/field.d.ts
+interface ConfigurationField<Output, Required extends boolean = true, Input = Output> {
+  readonly required: Required;
+  readonly hasDefault: boolean;
+  readonly defaultValue?: Output;
+  parse(value: unknown, path: string): Output;
+  optional(): ConfigurationField<Output | undefined, false, Input | undefined | null>;
+  default(value: Output): ConfigurationField<Output, false, Input>;
+  map<NextOutput>(transform: (value: Output) => NextOutput): ConfigurationField<NextOutput, Required, Input>;
+}
+declare const field: {
+  string(): ConfigurationField<string, true, string>;
+  number(): ConfigurationField<number, true, string | number>;
+  boolean(): ConfigurationField<boolean, true, string | boolean>;
+  array<Item, ItemInput>(item: ConfigurationField<Item, boolean, ItemInput>): ConfigurationField<readonly Item[], true, readonly ItemInput[]>;
+  custom<T>(): ConfigurationField<T, true, T>;
+};
+//#endregion
+//#region src/configuration/core/environments.d.ts
+interface EnvironmentDefinition {
+  readonly file: string;
+  readonly fileDir?: string;
+}
+interface EnvironmentConfig<Name extends string = string> {
+  readonly name: Name;
+  readonly file: string;
+  readonly fileDir: string;
+}
+type EnvironmentRegistry = Record<string, EnvironmentDefinition>;
+declare function defineEnvironments<const Environments extends EnvironmentRegistry>(environments: Environments): Environments;
+//#endregion
+//#region src/configuration/core/source.d.ts
+type ConfigurationSourceKind = 'env' | 'by-environment' | 'compute' | 'static';
+interface ConfigurationResolveContext<EnvironmentName extends string = string> {
+  readonly environment: EnvironmentConfig<EnvironmentName>;
+  readonly buildMetadata: BuildMetadata;
+}
+interface ConfigurationSource<Output = unknown> {
+  readonly kind: ConfigurationSourceKind;
+  readonly options: unknown;
+  readonly transforms: readonly ConfigurationSourceTransform[];
+  map<NextOutput>(transform: (value: Output, context: ConfigurationResolveContext) => NextOutput | Promise<NextOutput>): ConfigurationSource<NextOutput>;
+}
+declare function defineSource<const Environments extends Record<string, unknown>>(_environments: Environments): {
+  env(name: string): ConfigurationSource<string>;
+  byEnvironment<const Cases extends { readonly [Key in keyof Environments & string]: unknown; }>(cases: Cases): ConfigurationSource<InferSourceOutput<Cases[keyof Environments & string]>>;
+  compute<Output>(compute: (context: ConfigurationResolveContext<keyof Environments & string>) => Output | Promise<Output>): ConfigurationSource<Output>;
+  static<Output>(value: Output): ConfigurationSource<Output>;
+};
+type ConfigurationSourceTransform = (value: unknown, context: ConfigurationResolveContext) => unknown | Promise<unknown>;
+type InferSourceOutput<T> = T extends ConfigurationSource<infer Output> ? Output : T extends ((...args: any[]) => any) ? T : T extends readonly [unknown, ...unknown[]] ? { readonly [Key in keyof T]: InferSourceOutput<T[Key]>; } : T extends readonly (infer Item)[] ? readonly InferSourceOutput<Item>[] : T extends object ? { readonly [Key in keyof T]: InferSourceOutput<T[Key]>; } : T;
+//#endregion
+//#region src/configuration/core/configuration.d.ts
+type ConfigurationSchema = ConfigurationField<any, boolean, any> | {
+  readonly [key: string]: ConfigurationSchema;
+};
+type InferSchemaOutput<Schema> = Schema extends ConfigurationField<infer Output, any, any> ? Output : Schema extends object ? { readonly [Key in keyof Schema]: InferSchemaOutput<Schema[Key]>; } : never;
+type InferSchemaInput<Schema> = Schema extends ConfigurationField<any, any, infer Input> ? Input : Schema extends object ? { readonly [Key in RequiredSchemaKeys<Schema>]: InferSchemaInput<Schema[Key]>; } & { readonly [Key in OptionalSchemaKeys<Schema>]?: InferSchemaInput<Schema[Key]>; } : never;
+type ConfigurationValueInput<T> = ConfigurationSource<T | undefined> | (T extends unknown ? ConfigurationValueInputValue<T> : never);
+type ConfigurationInputFromSchema<Schema> = ConfigurationSource<InferSchemaInput<Schema> | undefined> | (Schema extends ConfigurationField<any, any, infer Input> ? ConfigurationValueInput<Input> : Schema extends object ? { readonly [Key in RequiredSchemaKeys<Schema>]: ConfigurationInputFromSchema<Schema[Key]>; } & { readonly [Key in OptionalSchemaKeys<Schema>]?: ConfigurationInputFromSchema<Schema[Key]>; } : never);
+interface ConfigurationContract<Output, Schema extends ConfigurationSchema = ConfigurationSchema> {
+  readonly key: string;
+  readonly schema: Schema;
+  (input: ConfigurationInputFromSchema<Schema>): ConfigurationBinding<Output, Schema>;
+}
+interface ConfigurationBinding<Output = unknown, Schema extends ConfigurationSchema = ConfigurationSchema> {
+  readonly contract: ConfigurationContract<Output, Schema>;
+  readonly input: ConfigurationInputFromSchema<Schema>;
+}
+type InferConfiguration<Contract> = Contract extends ConfigurationContract<infer Output, any> ? Output : never;
+declare function defineConfiguration<const Schema extends ConfigurationSchema>(key: string, schema: Schema): ConfigurationContract<InferSchemaOutput<Schema>, Schema>;
+type ConfigurationValueInputValue<T> = T extends ((...args: any[]) => any) ? T : T extends readonly [unknown, ...unknown[]] ? { readonly [Key in keyof T]: ConfigurationValueInput<T[Key]>; } : T extends readonly (infer Item)[] ? readonly ConfigurationValueInput<Item>[] : T extends object ? { readonly [Key in keyof T]: ConfigurationValueInput<T[Key]>; } : T;
+type IsSchemaInputRequired<Schema> = Schema extends ConfigurationField<any, infer Required, any> ? Required : Schema extends object ? RequiredSchemaKeys<Schema> extends never ? false : true : true;
+type RequiredSchemaKeys<Schema extends object> = { [Key in keyof Schema]-?: IsSchemaInputRequired<Schema[Key]> extends true ? Key : never; }[keyof Schema];
+type OptionalSchemaKeys<Schema extends object> = { [Key in keyof Schema]-?: IsSchemaInputRequired<Schema[Key]> extends true ? never : Key; }[keyof Schema];
+//#endregion
+//#region src/configuration/configs/basic-auth.d.ts
+type BasicAuthAuthenticate = FastifyBasicAuthOptions['authenticate'];
+declare const BasicAuthConfiguration: ConfigurationContract<{
+  readonly enabled: boolean;
+  readonly authenticate: boolean | {
+    realm?: string | ((req: import("fastify").FastifyRequest) => string);
+    header?: string;
+  } | undefined;
+  readonly proxyMode: boolean;
+  readonly header: string | undefined;
+  readonly strictCredentials: boolean | undefined;
+  readonly username: string | undefined;
+  readonly password: string | undefined;
+}, {
+  readonly enabled: ConfigurationField<boolean, false, string | boolean>;
+  readonly authenticate: ConfigurationField<boolean | {
+    realm?: string | ((req: import("fastify").FastifyRequest) => string);
+    header?: string;
+  } | undefined, false, boolean | {
+    realm?: string | ((req: import("fastify").FastifyRequest) => string);
+    header?: string;
+  } | undefined>;
+  readonly proxyMode: ConfigurationField<boolean, false, string | boolean>;
+  readonly header: ConfigurationField<string | undefined, false, string | null | undefined>;
+  readonly strictCredentials: ConfigurationField<boolean | undefined, false, string | boolean | null | undefined>;
+  readonly username: ConfigurationField<string | undefined, false, string | null | undefined>;
+  readonly password: ConfigurationField<string | undefined, false, string | null | undefined>;
+}>;
+type BasicAuthConfig = InferConfiguration<typeof BasicAuthConfiguration>;
+//#endregion
+//#region src/configuration/configs/build.d.ts
+declare const BuildConfiguration: ConfigurationContract<{
+  readonly outDir: string;
+}, {
+  readonly outDir: ConfigurationField<string, false, string>;
+}>;
+type BuildConfig = InferConfiguration<typeof BuildConfiguration>;
+//#endregion
+//#region src/configuration/configs/cors.d.ts
+type CorsOptions = FastifyCorsOptions;
+declare const CorsConfiguration: ConfigurationContract<{
+  readonly enabled: boolean;
+  readonly allowAllOrigins: boolean;
+  readonly includeWwwSubdomain: boolean;
+  readonly options: FastifyCorsOptions;
+}, {
+  readonly enabled: ConfigurationField<boolean, false, string | boolean>;
+  readonly allowAllOrigins: ConfigurationField<boolean, false, string | boolean>;
+  readonly includeWwwSubdomain: ConfigurationField<boolean, false, string | boolean>;
+  readonly options: ConfigurationField<FastifyCorsOptions, false, FastifyCorsOptions>;
+}>;
+type CorsConfig = InferConfiguration<typeof CorsConfiguration>;
+//#endregion
+//#region src/configuration/configs/email.d.ts
+declare const EmailConfiguration: ConfigurationContract<{
+  readonly enabled: boolean;
+  readonly templatesPath: string;
+  readonly globals: Record<string, unknown>;
+  readonly smtp: {
+    readonly host: string | undefined;
+    readonly port: number | undefined;
+    readonly secure: boolean | undefined;
+    readonly user: string | undefined;
+    readonly password: string | undefined;
+  };
+}, {
+  readonly enabled: ConfigurationField<boolean, false, string | boolean>;
+  readonly templatesPath: ConfigurationField<string, false, string>;
+  readonly globals: ConfigurationField<Record<string, unknown>, false, Record<string, unknown>>;
+  readonly smtp: {
+    readonly host: ConfigurationField<string | undefined, false, string | null | undefined>;
+    readonly port: ConfigurationField<number | undefined, false, string | number | null | undefined>;
+    readonly secure: ConfigurationField<boolean | undefined, false, string | boolean | null | undefined>;
+    readonly user: ConfigurationField<string | undefined, false, string | null | undefined>;
+    readonly password: ConfigurationField<string | undefined, false, string | null | undefined>;
+  };
+}>;
+type EmailConfig = InferConfiguration<typeof EmailConfiguration>;
+//#endregion
+//#region src/configuration/configs/health.d.ts
+declare const HealthConfiguration: ConfigurationContract<{
+  readonly enabled: boolean;
+  readonly url: string;
+  readonly pressure: {
+    readonly maxEventLoopDelay: number;
+    readonly maxHeapUsedBytes: number;
+    readonly maxRssBytes: number;
+    readonly maxEventLoopUtilization: number;
+  };
+}, {
+  readonly enabled: ConfigurationField<boolean, false, string | boolean>;
+  readonly url: ConfigurationField<string, false, string>;
+  readonly pressure: {
+    readonly maxEventLoopDelay: ConfigurationField<number, false, string | number>;
+    readonly maxHeapUsedBytes: ConfigurationField<number, false, string | number>;
+    readonly maxRssBytes: ConfigurationField<number, false, string | number>;
+    readonly maxEventLoopUtilization: ConfigurationField<number, false, string | number>;
+  };
+}>;
+type HealthConfig = InferConfiguration<typeof HealthConfiguration>;
+//#endregion
+//#region src/configuration/configs/i18n.d.ts
+interface I18nDirectoryEntry {
+  readonly path: string;
+  readonly namespace?: string;
+}
+interface I18nFileEntry {
+  readonly locale: string;
+  readonly path: string;
+  readonly namespace?: string;
+}
+type I18nInitOptions = InitOptions<object>;
+type I18nFallbackLanguages = Extract<NonNullable<I18nInitOptions['fallbackLng']>, string | readonly string[]>;
+type I18nLoadMode = NonNullable<I18nInitOptions['load']>;
+type I18nPreload = NonNullable<I18nInitOptions['preload']>;
+declare const I18nConfiguration: ConfigurationContract<{
+  readonly resources: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+  readonly directories: readonly I18nDirectoryEntry[];
+  readonly files: readonly I18nFileEntry[];
+  readonly defaultLanguage: string;
+  readonly fallbackLanguages: I18nFallbackLanguages;
+  readonly supportedLanguages: readonly string[];
+  readonly load: I18nLoadMode;
+  readonly preload: I18nPreload;
+  readonly nonExplicitSupportedLngs: boolean;
+  readonly lowerCaseLng: boolean;
+  readonly cleanCode: boolean;
+  readonly namespaces: readonly string[] | undefined;
+  readonly defaultNamespace: string;
+  readonly keySeparator: string;
+  readonly nsSeparator: string;
+  readonly pluralSeparator: string;
+  readonly contextSeparator: string;
+}, {
+  readonly resources: ConfigurationField<Readonly<Record<string, Readonly<Record<string, unknown>>>>, false, Readonly<Record<string, Readonly<Record<string, unknown>>>>>;
+  readonly directories: ConfigurationField<readonly I18nDirectoryEntry[], false, readonly I18nDirectoryEntry[]>;
+  readonly files: ConfigurationField<readonly I18nFileEntry[], false, readonly I18nFileEntry[]>;
+  readonly defaultLanguage: ConfigurationField<string, false, string>;
+  readonly fallbackLanguages: ConfigurationField<I18nFallbackLanguages, false, I18nFallbackLanguages>;
+  readonly supportedLanguages: ConfigurationField<readonly string[], false, readonly string[]>;
+  readonly load: ConfigurationField<I18nLoadMode, false, I18nLoadMode>;
+  readonly preload: ConfigurationField<I18nPreload, false, I18nPreload>;
+  readonly nonExplicitSupportedLngs: ConfigurationField<boolean, false, string | boolean>;
+  readonly lowerCaseLng: ConfigurationField<boolean, false, string | boolean>;
+  readonly cleanCode: ConfigurationField<boolean, false, string | boolean>;
+  readonly namespaces: ConfigurationField<readonly string[] | undefined, false, readonly string[] | null | undefined>;
+  readonly defaultNamespace: ConfigurationField<string, false, string>;
+  readonly keySeparator: ConfigurationField<string, false, string>;
+  readonly nsSeparator: ConfigurationField<string, false, string>;
+  readonly pluralSeparator: ConfigurationField<string, false, string>;
+  readonly contextSeparator: ConfigurationField<string, false, string>;
+}>;
+type I18nConfig = InferConfiguration<typeof I18nConfiguration>;
+//#endregion
+//#region src/configuration/configs/logger.d.ts
+interface LoggerRequestOptions {
+  /**
+   * @description Additional request paths skipped by the ApiKit request logger.
+   *
+   * ApiKit skips enabled internal endpoints automatically:
+   * - `health.url`
+   * - `metrics.endpoint`
+   *
+   * Matching is path-based and ignores query strings.
+   *
+   * @default []
+   *
+   * @example
+   * ```ts
+   * logger: {
+   *   enabled: true,
+   *   transports: [{ type: 'file', path: from.env('LOGGER_PATH') }],
+   *   request: {
+   *     ignoredPaths: ['/internal/ping'],
+   *   },
+   * }
+   * ```
+   */
+  readonly ignoredPaths?: readonly string[];
+}
+type LoggerConfigurationValue = {
+  readonly enabled: false;
+  readonly transports?: never;
+  readonly request?: never;
+} | {
+  readonly enabled: true;
+  readonly transports: readonly [LoggerTransportOptions, ...LoggerTransportOptions[]];
+  readonly request?: LoggerRequestOptions;
+};
+declare const LoggerConfiguration: ConfigurationContract<LoggerConfigurationValue, ConfigurationField<LoggerConfigurationValue, false, LoggerConfigurationValue>>;
+type LoggerConfig = InferConfiguration<typeof LoggerConfiguration>;
+//#endregion
+//#region src/configuration/configs/metrics.d.ts
+type MetricsEndpoint = string | null | RouteOptions;
+interface MetricsDefaultConfig {
+  readonly enabled: boolean;
+}
+interface MetricsRouteConfig {
+  readonly enabled?: boolean | {
+    readonly histogram?: boolean;
+    readonly summary?: boolean;
+  };
+  readonly registeredRoutesOnly?: boolean;
+  readonly groupStatusCodes?: boolean;
+  readonly routeBlacklist?: readonly (string | RegExp)[];
+  readonly methodBlacklist?: readonly string[];
+  readonly invalidRouteGroup?: string;
+}
+declare const MetricsConfiguration: ConfigurationContract<{
+  readonly enabled: boolean;
+  readonly endpoint: MetricsEndpoint;
+  readonly name: string;
+  readonly defaultMetrics: MetricsDefaultConfig;
+  readonly routeMetrics: MetricsRouteConfig;
+  readonly clearRegisterOnInit: boolean;
+}, {
+  readonly enabled: ConfigurationField<boolean, false, string | boolean>;
+  readonly endpoint: ConfigurationField<MetricsEndpoint, false, MetricsEndpoint>;
+  readonly name: ConfigurationField<string, false, string>;
+  readonly defaultMetrics: ConfigurationField<MetricsDefaultConfig, false, MetricsDefaultConfig>;
+  readonly routeMetrics: ConfigurationField<MetricsRouteConfig, false, MetricsRouteConfig>;
+  readonly clearRegisterOnInit: ConfigurationField<boolean, false, string | boolean>;
+}>;
+type MetricsConfig = InferConfiguration<typeof MetricsConfiguration>;
+//#endregion
+//#region src/configuration/configs/multipart.d.ts
+type MultipartOptions = FastifyMultipartBaseOptions | FastifyMultipartOptions | FastifyMultipartAttachFieldsToBodyOptions;
+declare const MultipartConfiguration: ConfigurationContract<{
+  readonly enabled: boolean;
+  readonly options: MultipartOptions;
+}, {
+  readonly enabled: ConfigurationField<boolean, false, string | boolean>;
+  readonly options: ConfigurationField<MultipartOptions, false, MultipartOptions>;
+}>;
+type MultipartConfig = InferConfiguration<typeof MultipartConfiguration>;
+//#endregion
+//#region src/configuration/configs/notification.d.ts
+interface TelegramNotificationConfig {
+  readonly token: string;
+  readonly chatId: string;
+}
+interface NotificationChannelsConfig {
+  readonly telegram?: TelegramNotificationConfig;
+}
+type NotificationConfigurationValue = {
+  readonly enabled: false;
+  readonly channels?: never;
+} | {
+  readonly enabled: true;
+  readonly channels: NotificationChannelsConfig;
+};
+declare const NotificationConfiguration: ConfigurationContract<NotificationConfigurationValue, ConfigurationField<NotificationConfigurationValue, false, NotificationConfigurationValue>>;
+type NotificationConfig = InferConfiguration<typeof NotificationConfiguration>;
+//#endregion
+//#region src/configuration/configs/server.d.ts
+type TrustProxy = boolean | string | number | string[] | ((address: string, hop: number) => boolean);
+declare const ServerConfiguration: ConfigurationContract<{
+  readonly identifier: string;
+  readonly debug: boolean;
+  readonly host: string;
+  readonly port: number;
+  readonly trustProxy: TrustProxy;
+}, {
+  readonly identifier: ConfigurationField<string, true, string>;
+  readonly debug: ConfigurationField<boolean, false, string | boolean>;
+  readonly host: ConfigurationField<string, true, string>;
+  readonly port: ConfigurationField<number, true, string | number>;
+  readonly trustProxy: ConfigurationField<TrustProxy, false, TrustProxy>;
+}>;
+type ServerConfig = InferConfiguration<typeof ServerConfiguration>;
+//#endregion
+//#region src/configuration/configs/static-files.d.ts
+type StaticFilesDotfilesMode = NonNullable<FastifyStaticOptions['dotfiles']>;
+declare const StaticFilesConfiguration: ConfigurationContract<{
+  readonly enabled: boolean;
+  readonly publicDirectory: string | undefined;
+  readonly routePrefix: string;
+  readonly maxAge: number;
+  readonly dotfiles: StaticFilesDotfilesMode;
+  readonly etag: boolean;
+  readonly immutable: boolean;
+  readonly decorateReply: boolean;
+  readonly preCompressed: boolean;
+}, {
+  readonly enabled: ConfigurationField<boolean, false, string | boolean>;
+  readonly publicDirectory: ConfigurationField<string | undefined, false, string | null | undefined>;
+  readonly routePrefix: ConfigurationField<string, false, string>;
+  readonly maxAge: ConfigurationField<number, false, string | number>;
+  readonly dotfiles: ConfigurationField<StaticFilesDotfilesMode, false, StaticFilesDotfilesMode>;
+  readonly etag: ConfigurationField<boolean, false, string | boolean>;
+  readonly immutable: ConfigurationField<boolean, false, string | boolean>;
+  readonly decorateReply: ConfigurationField<boolean, false, string | boolean>;
+  readonly preCompressed: ConfigurationField<boolean, false, string | boolean>;
+}>;
+type StaticFilesConfig = InferConfiguration<typeof StaticFilesConfiguration>;
+//#endregion
+//#region src/configuration/config.d.ts
+interface DefineApiKitInput {
+  readonly build?: InputOf<typeof BuildConfiguration>;
+  readonly server: InputOf<typeof ServerConfiguration>;
+  readonly logger?: InputOf<typeof LoggerConfiguration>;
+  readonly metrics?: InputOf<typeof MetricsConfiguration>;
+  readonly health?: InputOf<typeof HealthConfiguration>;
+  readonly email?: InputOf<typeof EmailConfiguration>;
+  readonly notification?: InputOf<typeof NotificationConfiguration>;
+  readonly i18n?: InputOf<typeof I18nConfiguration>;
+  readonly staticFiles?: InputOf<typeof StaticFilesConfiguration>;
+  readonly basicAuth?: InputOf<typeof BasicAuthConfiguration>;
+  readonly cors?: InputOf<typeof CorsConfiguration>;
+  readonly multipart?: InputOf<typeof MultipartConfiguration>;
+  readonly configurations?: readonly ExtensionConfigurationBinding[];
+}
+interface ApiKitConfig<Environments extends EnvironmentRegistry = EnvironmentRegistry> extends DefineApiKitInput {
+  readonly environments: Environments;
+  readonly configurations: readonly ExtensionConfigurationBinding[];
+}
+type InputOf<Contract extends ConfigurationContract<any, ConfigurationSchema>> = Contract extends ConfigurationContract<any, infer Schema> ? ConfigurationInputFromSchema<Schema> : never;
+type ExtensionConfigurationBinding = ConfigurationBinding<any, any>;
+//#endregion
+//#region src/configuration/controller.d.ts
+interface ApiKitController {
+  get build(): BuildMetadata;
+  get isDebug(): boolean;
+  get environment(): EnvironmentConfig;
+  get logger(): LoggerConfig;
+  get server(): ServerConfig;
+  get metrics(): MetricsConfig;
+  get health(): HealthConfig;
+  get email(): EmailConfig;
+  get notification(): NotificationConfig;
+  get i18n(): I18nConfig;
+  get staticFiles(): StaticFilesConfig;
+  get basicAuth(): BasicAuthConfig;
+  get cors(): CorsConfig;
+  get multipart(): MultipartConfig;
+  get<T>(configuration: ConfigurationContract<T, any>): T;
+  optional<T>(configuration: ConfigurationContract<T, any>): T | undefined;
+}
+declare class ApiKitControllerImpl implements ApiKitController {
+  get build(): BuildMetadata;
+  get isDebug(): boolean;
+  get environment(): EnvironmentConfig;
+  get logger(): LoggerConfig;
+  get server(): ServerConfig;
+  get metrics(): MetricsConfig;
+  get health(): HealthConfig;
+  get email(): EmailConfig;
+  get notification(): NotificationConfig;
+  get i18n(): I18nConfig;
+  get staticFiles(): StaticFilesConfig;
+  get basicAuth(): BasicAuthConfig;
+  get cors(): CorsConfig;
+  get multipart(): MultipartConfig;
+  get<T>(configuration: ConfigurationContract<T, any>): T;
+  optional<T>(configuration: ConfigurationContract<T, any>): T | undefined;
+}
+//#endregion
+//#region src/configuration/define.d.ts
+declare function defineApiKit<const Environments extends EnvironmentRegistry>(environments: Environments, input: DefineApiKitInput): ApiKitConfig<Environments>;
+//#endregion
+//#region src/configuration/load-context.d.ts
+interface LoadApiKitContextOptions {
+  readonly environment: string;
+  readonly config?: string;
+}
+declare function loadApiKitContext(options: LoadApiKitContextOptions): Promise<void>;
+//#endregion
+//#region types/global.d.ts
+declare global {
+  var apikit: {
+    build: BuildMetadata;
+    environmentConfig: EnvironmentConfig;
+    loggerConfig: LoggerConfig;
+    serverConfig: ServerConfig;
+    metricsConfig: MetricsConfig;
+    healthConfig: HealthConfig;
+    emailConfig: EmailConfig;
+    notificationConfig: NotificationConfig;
+    i18nConfig: I18nConfig;
+    staticFilesConfig: StaticFilesConfig;
+    basicAuthConfig: BasicAuthConfig;
+    corsConfig: CorsConfig;
+    multipartConfig: MultipartConfig;
+    configurations: ReadonlyMap<string, unknown>;
+  };
+}
+//#endregion
+//#region src/database/mongodb-query.d.ts
+type MongoDbQuery<T> = MongoDbFieldQuery<T> & MongoDbLogicalOperators<T>;
+type MongoDbFieldQuery<T> = { [K in keyof T]?: MongoDbFieldValue<T[K]>; };
+type MongoDbFieldValue<V> = V | MongoDbComparisonOperators<V> | (V extends object ? MongoDbFieldQuery<V> : never);
+type MongoDbLogicalOperators<T> = {
+  $and?: MongoDbQuery<T>[];
+  $or?: MongoDbQuery<T>[];
+  $nor?: MongoDbQuery<T>[];
+  $not?: MongoDbQuery<T>;
+  $expr?: Record<string, any>;
+};
+type MongoDbComparisonOperators<V> = {
+  $eq?: V;
+  $ne?: V;
+  $gt?: V;
+  $gte?: V;
+  $lt?: V;
+  $lte?: V;
+  $in?: V[];
+  $nin?: V[];
+  $exists?: boolean;
+  $regex?: V extends string ? string | RegExp : never;
+};
+interface MongoDbUpdateOptions {
+  /**
+   * If true, creates a new document when no document matches the query.
+   * Equivalent to `INSERT if not exists`.
+   */
+  upsert?: boolean;
+  /**
+   * If true, returns the updated document.
+   * If false, returns the document as it was before the update.
+   * Defaults to `true` in most framework layers.
+   */
+  new?: boolean;
+  /**
+   * If true, applies schema-level validations before applying the update.
+   * Useful for ensuring data consistency.
+   */
+  runValidators?: boolean;
+  /**
+   * If true, replaces the entire document instead of performing a `$set` update.
+   * Use this with caution — all unspecified fields will be removed.
+   */
+  overwrite?: boolean;
+  /**
+   * If true, returns a plain JavaScript object instead of a Mongoose document.
+   * Improves performance if you don’t need Mongoose features like getters or methods.
+   */
+  lean?: boolean;
+  /**
+   * Selects specific fields to include (`1`) or exclude (`0`) in the returned document.
+   * Example: `{ name: 1, email: 1 }` or `{ password: 0 }`
+   */
+  projection?: Record<string, 0 | 1>;
+  /**
+   * Controls how unknown fields are handled.
+   * - `true`: strip unknown fields (default mongoose behavior)
+   * - `false`: allow unknown fields
+   * - `'throw'`: raise an error on unknown fields
+   */
+  strict?: boolean | 'throw';
+  /**
+   * When used with `upsert: true`, applies schema defaults
+   * to newly inserted documents.
+   */
+  setDefaultsOnInsert?: boolean;
+  /**
+   * Overrides schema-level timestamps for this operation.
+   * Set to `false` to skip updating `updatedAt` / `createdAt`.
+   */
+  timestamps?: boolean;
+  /**
+   * If true, returns the raw MongoDB result object
+   * instead of the mapped document.
+   */
+  rawResult?: boolean;
+  /**
+   * Maximum time in milliseconds the server should spend
+   * processing this update before aborting.
+   */
+  maxTimeMS?: number;
+}
+//#endregion
+//#region src/database/mongodb-query-formatter.d.ts
+/**
+ * Flattens a potentially nested MongoDbQuery<T> into a single-level filter object.
+ *
+ * - Skips any `undefined` values.
+ * - Skips any empty plain objects (`{}`).
+ * - Preserves MongoDB operators (keys starting with `$`).
+ * - Flattens nested fields into dot-notation (e.g. `{ a: { b: 5 } }` → `{ "a.b": 5 }`).
+ */
+interface MongoDbQueryFormatter {
+  /**
+   * @template T
+   * @param query
+   *   Possibly nested query filters.
+   * @returns
+   *   A flat filter with no `undefined` or empty-object keys.
+   */
+  format<T>(query: MongoDbQuery<T>): Record<string, any>;
+}
+declare class MongoDbQueryFormatterImpl implements MongoDbQueryFormatter {
+  /**
+   * Flattens the provided query object into a single-level map.
+   *
+   * @template T
+   * @param query
+   *   Possibly nested query filters.
+   * @returns
+   *   A flat filter with no `undefined` or empty-object keys.
+   */
+  format<T>(query: MongoDbQuery<T>): Record<string, any>;
+  /**
+   * Recursively traverses `input` to build a flat filter map.
+   *
+   * - Skips `undefined` values.
+   * - Skips empty plain objects (`{}`).
+   * - Preserves MongoDB operator keys (starting with `$`).
+   * - Flattens nested objects (without operators) into dot-notation keys.
+   *
+   * @param input
+   *   The current subtree to flatten.
+   * @param path
+   *   Dot-notation prefix (empty for top-level).
+   * @returns
+   *   The accumulated flat filter for this branch.
+   */
+  private flattenRecursive;
+  /**
+   * Checks if a key is a MongoDB operator (starts with `$`).
+   *
+   * @param key
+   * @returns
+   *   True if the key begins with `$`.
+   */
+  private isOperator;
+  /**
+   * Determines whether `obj` has any keys that start with `$`.
+   *
+   * @param obj
+   * @returns
+   *   True if at least one key begins with `$`.
+   */
+  private containsOperator;
+  /**
+   * Checks if `val` is a plain object (i.e., `{ ... }`).
+   * Returns false for arrays, Date objects, and other non-plain values.
+   *
+   * @param val
+   * @returns
+   *   True if `val` is a non-null object whose prototype is `Object.prototype`.
+   */
+  private isPlainObject;
+  /**
+   * Handles the contents of a MongoDB operator clause:
+   *
+   * - For `$expr`, return as-is (aggregation expression).
+   * - If the operator’s value is an array (e.g. `$or: [ {...}, {...} ]`),
+   *   flatten each element recursively.
+   * - If the operator’s value is a nested object (e.g. `$gt: 5`), flatten that object.
+   * - Otherwise, return the primitive/RegExp as-is.
+   *
+   * @param key
+   *   The operator name (e.g. `"$or"`, `"$gt"`).
+   * @param value
+   *   The operator’s value.
+   * @returns
+   *   The processed operator value.
+   */
+  private processOperator;
+}
+//#endregion
+//#region src/di/symbols.d.ts
+declare const ApiKitSymbols: {
+  DI: {
+    Configuration: {
+      Controller: symbol;
+    };
+    Database: {
+      MongoDB: {
+        QueryFormatter: symbol;
+      };
+    };
+    Email: {
+      Controller: symbol;
+    };
+    File: {
+      TemporaryRepository: symbol;
+    };
+    Validation: {
+      Controller: symbol;
+      DtoController: symbol;
+    };
+    OpenAPI: {
+      SchemaController: symbol;
+    };
+    I18n: {
+      Controller: symbol;
+    };
+    Notification: {
+      Controller: symbol;
+    };
+    Normalization: {
+      Controller: symbol;
+    };
+    Formatter: {
+      Controller: symbol;
+      MultipartController: symbol;
+    };
+    Generator: {
+      RandomValueGenerator: symbol;
+    };
+    Image: {
+      NormalizationController: symbol;
+    };
+    Server: {
+      Controller: symbol;
+      RequestController: symbol;
+      ResponseController: symbol;
+    };
+    Security: {
+      CryptographyController: symbol;
+    };
+  };
+};
+//#endregion
+//#region src/email/email-controller.d.ts
+interface EmailController {
+  sendEmail(template: EmailTemplate): Promise<void>;
+}
+declare class EmailControllerImpl implements EmailController {
+  private readonly configuration;
+  private readonly logger;
+  private transporter?;
+  private readonly templatesPath;
+  private readonly isEnabled;
+  private readonly smtpConfig;
+  constructor(configuration: ApiKitController, logger: Logger);
+  sendEmail(template: EmailTemplate): Promise<void>;
+  private getOrCreateTransporter;
+  private renderTemplate;
+  private makeFilePath;
+  private makeGlobals;
+  private sanitizeTemplatePath;
+}
+//#endregion
+//#region src/email/email-template.d.ts
+/**
+ * Represents the resolved structure of an email template.
+ *
+ * @template TData - Type of the data passed to the template.
+ */
+interface EmailTemplate<TData extends object = object> {
+  data: TData;
+  recipient: string;
+  sender: string;
+  subject: string;
+  templatePath: string;
+  fallbackPath?: string;
+  replyTo?: string;
+}
+/**
+ * Input used to construct an email template.
+ *
+ * @template TData - Type of the data passed to the template.
+ */
+type EmailTemplateInput<TData extends object> = {
+  data: TData;
+  recipient: string;
+  sender?: string;
+  replyTo?: string;
+  subject?: string;
+};
+/**
+ * Abstract base class to simplify creating email templates.
+ *
+ * @template TData - Type of the data passed to the template.
+ */
+declare abstract class BaseEmailTemplate<TData extends object> implements EmailTemplate<TData> {
+  data: TData;
+  recipient: string;
+  sender: string;
+  subject: string;
+  replyTo?: string;
+  constructor(input: EmailTemplateInput<TData>);
+  /**
+   * Provides the relative path to the EJS template file.
+   */
+  abstract get templatePath(): string;
+  /**
+   * Provides an optional fallback path to the EJS template.
+   */
+  get fallbackPath(): string | undefined;
+  /**
+   * Provides a default sender if none is explicitly passed.
+   */
+  protected abstract defaultSender(): string;
+  /**
+   * Provides a default subject if none is explicitly passed.
+   */
+  protected abstract defaultSubject(): string;
+}
+//#endregion
+//#region src/error/api-error.d.ts
+type ApiErrorDetails = unknown;
+interface ApiErrorProperties {
+  code: string;
+  message: string;
+  statusCode: number;
+  details?: ApiErrorDetails;
+}
+declare class ApiError extends Error implements ApiErrorProperties, JSONSerializable {
+  private _code;
+  private _statusCode;
+  private _details?;
+  constructor({ code, message, statusCode, details }: ApiErrorProperties);
+  get code(): string;
+  get statusCode(): number;
+  get details(): ApiErrorDetails | undefined;
+  toJSON(): any;
+  private formatDetails;
+}
+//#endregion
+//#region src/error/api-error-definition.d.ts
+/**
+ * @description Metadata attached to a localized API error response.
+ */
+interface ApiErrorDefinition {
+  /**
+   * @description L10n key used for the public error message.
+   */
+  message: string;
+  /**
+   * @description Machine-readable error code.
+   */
+  code: string;
+  /**
+   * @description Associated HTTP status code.
+   */
+  statusCode: number;
+}
+/**
+ * @description Recursive object structure for organizing API error definitions.
+ */
+type ApiErrorTree = {
+  [key: string]: ApiErrorTree | ApiErrorDefinition;
+};
+/**
+ * @description Dot-separated path to an API error definition in a nested error tree.
+ */
+type ApiErrorPath<TTree extends ApiErrorTree> = { [TKey in keyof TTree & string]: TTree[TKey] extends ApiErrorDefinition ? TKey : TTree[TKey] extends ApiErrorTree ? `${TKey}.${ApiErrorPath<TTree[TKey]>}` : never; }[keyof TTree & string];
+declare function isApiErrorDefinition(value: ApiErrorTree | ApiErrorDefinition | undefined): value is ApiErrorDefinition;
+//#endregion
+//#region src/i18n/i18n-controller.d.ts
+interface ParseLocaleOptions {
+  /**
+   * If true, always ignore region (e.g., "en-GB" → "en").
+   * Useful when you only ship base locales.
+   * @default true
+   */
+  ignoreRegion?: boolean;
+}
+interface I18nController {
+  /** Initializes i18next with merged built-in and consumer-provided translations. */
+  prepare(): Promise<void>;
+  /**
+   * Determines the client’s preferred language from an Accept-Language header,
+   * honoring quality values (q=) and falling back to the configured default language.
+   *
+   * Matching strategy:
+   *  - When `ignoreRegion` is false: prefer exact region (e.g., "en-gb"),
+   *    then fall back to base ("en").
+   *  - When `ignoreRegion` is true: always match by base only ("en-gb" → "en").
+   *
+   * @param input   Full Accept-Language header, e.g. "fr-CA,fr;q=0.8,en-US;q=0.6,en;q=0.4".
+   * @param options Matching behavior.
+   * @returns       Best matching language code.
+   */
+  parseLocale(input?: string, options?: ParseLocaleOptions): string;
+}
+declare class I18nControllerImpl implements I18nController {
+  private readonly configurationController;
+  constructor(configurationController: ApiKitController);
+  prepare(): Promise<void>;
+  parseLocale(input?: string, options?: ParseLocaleOptions): string;
+  private makeOptions;
+  private makeConfig;
+  private makeNamespaces;
+}
+//#endregion
+//#region src/i18n/i18n-provider.d.ts
+interface I18nOptions extends TOptions {}
+declare class I18nProvider {
+  /**
+   * Translates a key using i18next.
+   *
+   * @param key - Translation key (e.g., 'errors.INVALID_EMAIL')
+   * @param options - Optional interpolation and config
+   */
+  static t(key: string, options?: TOptions): string;
+  /**
+   * Returns the current effective locale.
+   */
+  static get currentLocale(): string;
+  /**
+   * Check if a locale is supported by the runtime i18n configuration.
+   *
+   * @param locale       Any locale tag (e.g., "en", "en-GB", "sk-SK").
+   * @param options
+   *   - ignoreRegion: if true (default), allow matching just the base language.
+   *                   e.g., if "en" is supported, "en-GB" is considered supported.
+   */
+  static isSupportedLanguage(locale?: string, options?: {
+    ignoreRegion?: boolean;
+  }): boolean;
+}
+//#endregion
+//#region src/i18n/i18n-factory.d.ts
+/**
+ * @description Options used when resolving localized text.
+ */
+interface I18nFactoryOptions {
+  /**
+   * @description Explicit message override returned instead of resolving the L10n key.
+   * @default null
+   */
+  overrideMessage?: string | null;
+  /**
+   * @description i18next options passed to the active i18n provider.
+   * @default undefined
+   */
+  i18n?: I18nOptions;
+}
+/**
+ * @description Resolves L10n keys into localized text.
+ *
+ * @example
+ * ```ts
+ * const message = I18nFactory.make('messages.account.email_code_sent');
+ * ```
+ *
+ * @example
+ * ```ts
+ * const message = I18nFactory.make(L10n.Errors.Common.NotFound, {
+ *   i18n: { resource: 'account' },
+ * });
+ * ```
+ */
+declare class I18nFactory {
+  /**
+   * @description Resolves an L10n key into localized text.
+   *
+   * @param key L10n key, for example `errors.common.not_found`.
+   * @param options Optional override or i18next options.
+   * @returns Localized text from the active i18n provider.
+   */
+  static make(key: string, options?: I18nFactoryOptions): string;
+  /**
+   * @description Resolves an L10n key into localized text.
+   *
+   * @param key L10n key, for example `errors.common.not_found`.
+   * @param options Optional override or i18next options.
+   * @returns Localized text from the active i18n provider.
+   */
+  static translateKey(key: string, options?: I18nFactoryOptions): string;
+}
+//#endregion
+//#region src/error/api-error-factory.d.ts
+/**
+ * @description Options for creating a localized API error.
+ */
+interface ApiErrorFactoryOptions {
+  /**
+   * @description Explicit message override returned instead of resolving the error L10n key.
+   * @default null
+   */
+  overrideMessage?: string | null;
+  /**
+   * @description Technical details returned in the API error payload.
+   * @default undefined
+   */
+  details?: ApiErrorDetails;
+  /**
+   * @description i18next options passed to the active i18n provider.
+   * @default undefined
+   */
+  i18n?: I18nOptions;
+}
+/**
+ * @description Factory API for creating standardized, localized API errors.
+ */
+interface ApiErrorFactory<TCodes extends ApiErrorTree> {
+  /**
+   * @description Error metadata tree owned by this factory.
+   */
+  readonly codes: TCodes;
+  /**
+   * @description Creates an API error from a typed path in this factory's error tree.
+   *
+   * @param path Dot-separated path to an error definition, for example `Validation.BAD_REQUEST`.
+   * @param options Optional message override, details, or i18next options.
+   * @returns Configured `ApiError` instance.
+   */
+  make(path: ApiErrorPath<TCodes>, options?: ApiErrorFactoryOptions): ApiError;
+  /**
+   * @description Creates a new factory with custom error metadata merged over this factory.
+   *
+   * @param extra Custom error metadata tree.
+   * @returns Factory with merged error metadata.
+   */
+  extend<TExtra extends ApiErrorTree>(extra: TExtra): ApiErrorFactory<TCodes & TExtra>;
+}
+/**
+ * @description Factory for creating standardized, localized API errors.
+ *
+ * @example
+ * ```ts
+ * throw ApiErrorFactory.make('Validation.BAD_REQUEST');
+ * ```
+ *
+ * @example
+ * ```ts
+ * export const AccountErrors = defineErrors({
+ *   BLOCKED: {
+ *     message: L10n.Errors.Account.Blocked,
+ *     code: 'account_blocked',
+ *     statusCode: 403,
+ *   },
+ * });
+ *
+ * export const ErrorFactory = ApiErrorFactory.extend({ Account: AccountErrors });
+ * throw ErrorFactory.make('Account.BLOCKED');
+ * ```
+ */
+declare const ApiErrorFactory: ApiErrorFactory<{
+  readonly Common: {
+    NOT_FOUND: {
+      message: "apikit.errors.common.not_found";
+      code: string;
+      statusCode: number;
+    };
+    UNKNOWN_ERROR: {
+      message: "apikit.errors.common.unknown_error";
+      code: string;
+      statusCode: number;
+    };
+    UNABLE_TO_PROCESS_REQUEST: {
+      message: "apikit.errors.common.unable_to_process_request";
+      code: string;
+      statusCode: number;
+    };
+    RESOURCE_ALREADY_EXISTS: {
+      message: "apikit.errors.common.already_exists";
+      code: string;
+      statusCode: number;
+    };
+  };
+  readonly Server: {
+    INTERNAL_SERVER_ERROR: {
+      message: "apikit.errors.server.internal";
+      code: string;
+      statusCode: number;
+    };
+    SERVICE_UNAVAILABLE: {
+      message: "apikit.errors.server.unavailable";
+      code: string;
+      statusCode: number;
+    };
+    DEPENDENCY_FAILED: {
+      message: "apikit.errors.server.dependency_failed";
+      code: string;
+      statusCode: number;
+    };
+    TIMEOUT: {
+      message: "apikit.errors.server.timeout";
+      code: string;
+      statusCode: number;
+    };
+  };
+  readonly Limit: {
+    TOO_MANY_REQUESTS: {
+      message: "apikit.errors.limit.too_many_requests";
+      code: string;
+      statusCode: number;
+    };
+  };
+  readonly Authorization: {
+    UNAUTHORIZED: {
+      message: "apikit.errors.auth.unauthorized";
+      code: string;
+      statusCode: number;
+    };
+    FORBIDDEN: {
+      message: "apikit.errors.auth.forbidden";
+      code: string;
+      statusCode: number;
+    };
+  };
+  readonly Validation: {
+    BAD_REQUEST: {
+      message: "apikit.errors.validation.bad_request";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_JSON_SYNTAX: {
+      message: "apikit.errors.validation.invalid_json_syntax";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_PROPERTIES: {
+      message: "apikit.errors.validation.invalid_properties";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_FORMAT: {
+      message: "apikit.errors.validation.invalid_format";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_DATE_FORMAT: {
+      message: "apikit.errors.validation.invalid_date_format";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_PASSWORD: {
+      message: "apikit.errors.validation.invalid_password";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_PASSWORD_NEW_SAME_AS_OLD: {
+      message: "apikit.errors.validation.invalid_password_new_same_as_old";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_PHONE_NUMBER_FORMAT: {
+      message: "apikit.errors.validation.invalid_phone_number_format";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_PHONE_NEW_SAME_AS_OLD: {
+      message: "apikit.errors.validation.invalid_phone_new_same_as_old";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_EMAIL_FORMAT: {
+      message: "apikit.errors.validation.invalid_email_format";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_EMAIL_NEW_SAME_AS_OLD: {
+      message: "apikit.errors.validation.invalid_email_new_same_as_old";
+      code: string;
+      statusCode: number;
+    };
+  };
+  readonly Format: {
+    UNSUPPORTED_FORMAT: {
+      message: "apikit.errors.format.unsupported";
+      code: string;
+      statusCode: number;
+    };
+    MAX_SIZE_EXCEEDED: {
+      message: "apikit.errors.format.max_size_exceeded";
+      code: string;
+      statusCode: number;
+    };
+  };
+  readonly Image: {
+    MAX_SIZE_EXCEEDED: {
+      message: "apikit.errors.image.max_size_exceeded";
+      code: string;
+      statusCode: number;
+    };
+  };
+}>;
+//#endregion
+//#region src/error/api-error-codes.d.ts
+/**
+ * @description Defines a validated, nested API error metadata tree.
+ *
+ * @template T Recursive tree where every leaf is an `ApiErrorDefinition`.
+ * @param errors Nested API error metadata tree.
+ * @returns The same tree, typed for later reuse.
+ *
+ * @example
+ * ```ts
+ * export const AccountErrors = defineErrors({
+ *   BLOCKED: {
+ *     message: L10n.Errors.Account.Blocked,
+ *     code: 'account_blocked',
+ *     statusCode: 403,
+ *   },
+ * });
+ * ```
+ */
+declare function defineErrors<T extends ApiErrorTree>(errors: T): T;
+declare const CommonErrors: {
+  NOT_FOUND: {
+    message: "apikit.errors.common.not_found";
+    code: string;
+    statusCode: number;
+  };
+  UNKNOWN_ERROR: {
+    message: "apikit.errors.common.unknown_error";
+    code: string;
+    statusCode: number;
+  };
+  UNABLE_TO_PROCESS_REQUEST: {
+    message: "apikit.errors.common.unable_to_process_request";
+    code: string;
+    statusCode: number;
+  };
+  RESOURCE_ALREADY_EXISTS: {
+    message: "apikit.errors.common.already_exists";
+    code: string;
+    statusCode: number;
+  };
+};
+declare const ServerErrors: {
+  INTERNAL_SERVER_ERROR: {
+    message: "apikit.errors.server.internal";
+    code: string;
+    statusCode: number;
+  };
+  SERVICE_UNAVAILABLE: {
+    message: "apikit.errors.server.unavailable";
+    code: string;
+    statusCode: number;
+  };
+  DEPENDENCY_FAILED: {
+    message: "apikit.errors.server.dependency_failed";
+    code: string;
+    statusCode: number;
+  };
+  TIMEOUT: {
+    message: "apikit.errors.server.timeout";
+    code: string;
+    statusCode: number;
+  };
+};
+declare const LimitErrors: {
+  TOO_MANY_REQUESTS: {
+    message: "apikit.errors.limit.too_many_requests";
+    code: string;
+    statusCode: number;
+  };
+};
+declare const AuthorizationErrors: {
+  UNAUTHORIZED: {
+    message: "apikit.errors.auth.unauthorized";
+    code: string;
+    statusCode: number;
+  };
+  FORBIDDEN: {
+    message: "apikit.errors.auth.forbidden";
+    code: string;
+    statusCode: number;
+  };
+};
+declare const ValidationErrors: {
+  BAD_REQUEST: {
+    message: "apikit.errors.validation.bad_request";
+    code: string;
+    statusCode: number;
+  };
+  INVALID_JSON_SYNTAX: {
+    message: "apikit.errors.validation.invalid_json_syntax";
+    code: string;
+    statusCode: number;
+  };
+  INVALID_PROPERTIES: {
+    message: "apikit.errors.validation.invalid_properties";
+    code: string;
+    statusCode: number;
+  };
+  INVALID_FORMAT: {
+    message: "apikit.errors.validation.invalid_format";
+    code: string;
+    statusCode: number;
+  };
+  INVALID_DATE_FORMAT: {
+    message: "apikit.errors.validation.invalid_date_format";
+    code: string;
+    statusCode: number;
+  };
+  INVALID_PASSWORD: {
+    message: "apikit.errors.validation.invalid_password";
+    code: string;
+    statusCode: number;
+  };
+  INVALID_PASSWORD_NEW_SAME_AS_OLD: {
+    message: "apikit.errors.validation.invalid_password_new_same_as_old";
+    code: string;
+    statusCode: number;
+  };
+  INVALID_PHONE_NUMBER_FORMAT: {
+    message: "apikit.errors.validation.invalid_phone_number_format";
+    code: string;
+    statusCode: number;
+  };
+  INVALID_PHONE_NEW_SAME_AS_OLD: {
+    message: "apikit.errors.validation.invalid_phone_new_same_as_old";
+    code: string;
+    statusCode: number;
+  };
+  INVALID_EMAIL_FORMAT: {
+    message: "apikit.errors.validation.invalid_email_format";
+    code: string;
+    statusCode: number;
+  };
+  INVALID_EMAIL_NEW_SAME_AS_OLD: {
+    message: "apikit.errors.validation.invalid_email_new_same_as_old";
+    code: string;
+    statusCode: number;
+  };
+};
+declare const FormatErrors: {
+  UNSUPPORTED_FORMAT: {
+    message: "apikit.errors.format.unsupported";
+    code: string;
+    statusCode: number;
+  };
+  MAX_SIZE_EXCEEDED: {
+    message: "apikit.errors.format.max_size_exceeded";
+    code: string;
+    statusCode: number;
+  };
+};
+declare const ImageErrors: {
+  MAX_SIZE_EXCEEDED: {
+    message: "apikit.errors.image.max_size_exceeded";
+    code: string;
+    statusCode: number;
+  };
+};
+declare const ApiErrorCodes: {
+  readonly Common: {
+    NOT_FOUND: {
+      message: "apikit.errors.common.not_found";
+      code: string;
+      statusCode: number;
+    };
+    UNKNOWN_ERROR: {
+      message: "apikit.errors.common.unknown_error";
+      code: string;
+      statusCode: number;
+    };
+    UNABLE_TO_PROCESS_REQUEST: {
+      message: "apikit.errors.common.unable_to_process_request";
+      code: string;
+      statusCode: number;
+    };
+    RESOURCE_ALREADY_EXISTS: {
+      message: "apikit.errors.common.already_exists";
+      code: string;
+      statusCode: number;
+    };
+  };
+  readonly Server: {
+    INTERNAL_SERVER_ERROR: {
+      message: "apikit.errors.server.internal";
+      code: string;
+      statusCode: number;
+    };
+    SERVICE_UNAVAILABLE: {
+      message: "apikit.errors.server.unavailable";
+      code: string;
+      statusCode: number;
+    };
+    DEPENDENCY_FAILED: {
+      message: "apikit.errors.server.dependency_failed";
+      code: string;
+      statusCode: number;
+    };
+    TIMEOUT: {
+      message: "apikit.errors.server.timeout";
+      code: string;
+      statusCode: number;
+    };
+  };
+  readonly Limit: {
+    TOO_MANY_REQUESTS: {
+      message: "apikit.errors.limit.too_many_requests";
+      code: string;
+      statusCode: number;
+    };
+  };
+  readonly Authorization: {
+    UNAUTHORIZED: {
+      message: "apikit.errors.auth.unauthorized";
+      code: string;
+      statusCode: number;
+    };
+    FORBIDDEN: {
+      message: "apikit.errors.auth.forbidden";
+      code: string;
+      statusCode: number;
+    };
+  };
+  readonly Validation: {
+    BAD_REQUEST: {
+      message: "apikit.errors.validation.bad_request";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_JSON_SYNTAX: {
+      message: "apikit.errors.validation.invalid_json_syntax";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_PROPERTIES: {
+      message: "apikit.errors.validation.invalid_properties";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_FORMAT: {
+      message: "apikit.errors.validation.invalid_format";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_DATE_FORMAT: {
+      message: "apikit.errors.validation.invalid_date_format";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_PASSWORD: {
+      message: "apikit.errors.validation.invalid_password";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_PASSWORD_NEW_SAME_AS_OLD: {
+      message: "apikit.errors.validation.invalid_password_new_same_as_old";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_PHONE_NUMBER_FORMAT: {
+      message: "apikit.errors.validation.invalid_phone_number_format";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_PHONE_NEW_SAME_AS_OLD: {
+      message: "apikit.errors.validation.invalid_phone_new_same_as_old";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_EMAIL_FORMAT: {
+      message: "apikit.errors.validation.invalid_email_format";
+      code: string;
+      statusCode: number;
+    };
+    INVALID_EMAIL_NEW_SAME_AS_OLD: {
+      message: "apikit.errors.validation.invalid_email_new_same_as_old";
+      code: string;
+      statusCode: number;
+    };
+  };
+  readonly Format: {
+    UNSUPPORTED_FORMAT: {
+      message: "apikit.errors.format.unsupported";
+      code: string;
+      statusCode: number;
+    };
+    MAX_SIZE_EXCEEDED: {
+      message: "apikit.errors.format.max_size_exceeded";
+      code: string;
+      statusCode: number;
+    };
+  };
+  readonly Image: {
+    MAX_SIZE_EXCEEDED: {
+      message: "apikit.errors.image.max_size_exceeded";
+      code: string;
+      statusCode: number;
+    };
+  };
+};
+//#endregion
+//#region src/formatter/format-type.d.ts
+/**
+ * Wraps both raw MIME strings (e.g. "image/png") and file extensions (e.g. "png", "foo.png")
+ * into a validated media-type. Throws if the input cannot be resolved.
+ *
+ * @param {string} input
+ *   Either a raw media-type ("type/subtype") or a filename/extension
+ *   (e.g. "foo.png", ".png", "png"). If unrecognized, throws a Format error.
+ *
+ * @example
+ * // Using FormatErrors from defineErrors:
+ * import { defineErrors } from '@buildplease/apikit';
+ *
+ * export const FormatErrors = defineErrors({
+ *   UNSUPPORTED_FORMAT: {
+ *     code: 'UNSUPPORTED_FORMAT',
+ *     message: L10n.Errors.Format.Unsupported,
+ *     statusCode: 400,
+ *   },
+ * });
+ *
+ * // Create from a filename extension
+ * const fmt1 = new FormatType('foo.png');
+ * console.log(fmt1.value);      // "image/png"
+ * console.log(fmt1.extension);  // "png"
+ *
+ * @example
+ * // Create directly from a MIME string
+ * const fmt2 = new FormatType('application/json');
+ * console.log(fmt2.value);      // "application/json"
+ * console.log(fmt2.extension);  // "json"
+ *
+ * @example
+ * // Compare two formats for equality
+ * const a = new FormatType('png');
+ * const b = new FormatType('image/png');
+ * console.log(a.equals(b));     // true
+ *
+ * @example
+ * // Catch error when extension lookup fails
+ * try {
+ *   const fmt = new FormatType('application/octet-stream');
+ *   console.log(fmt.extension);
+ * } catch {
+ *   // FormatErrors.UNSUPPORTED_FORMAT was thrown
+ *   throw ApiErrorFactory.make('Format.UNSUPPORTED_FORMAT');
+ * }
+ *
+ * @example
+ * // Validate a Content-Type header in an HTTP handler
+ * function handleUpload(contentTypeHeader: string) {
+ *   try {
+ *     const fmt = new FormatType(contentTypeHeader);
+ *     // downstream: use fmt.extension to decide where to store or how to process
+ *   } catch {
+ *     // rethrow a standardized error for unsupported formats
+ *     throw ApiErrorFactory.make('Format.UNSUPPORTED_FORMAT');
+ *   }
+ * }
+ */
+declare class FormatType {
+  private readonly mimeType;
+  constructor(input: string);
+  /**
+   * The validated media-type string (e.g. "image/png").
+   */
+  get value(): string;
+  /**
+   * The canonical file extension for this media type (e.g. "png" for "image/png").
+   *
+   * @throws {Error}
+   *   ApiErrorFactory.make('Format.UNSUPPORTED_FORMAT') if no extension is found.
+   *
+   * @example
+   * const fmt = new FormatType('image/gif');
+   * console.log(fmt.extension); // "gif"
+   */
+  get extension(): string;
+  /**
+   * Compares this FormatType with another by their media-type strings.
+   *
+   * @param {FormatType} other
+   *   Another FormatType to compare against.
+   *
+   * @returns {boolean}
+   *   True if both instances resolve to the same media-type; false otherwise.
+   *
+   * @example
+   * const f1 = new FormatType('jpg');
+   * const f2 = new FormatType('image/jpeg');
+   * console.log(f1.equals(f2)); // true
+   *
+   * @example
+   * const f3 = new FormatType('text/html');
+   * console.log(f2.equals(f3)); // false
+   */
+  equals(other: FormatType): boolean;
+}
+//#endregion
+//#region src/formatter/formatter-controller.d.ts
+/**
+ * FormatterController is responsible for creating Formatter instances.
+ * Use FormatterController to apply transformations and filters to any data
+ * object in a fluent, chainable manner.
+ */
+interface FormatterController {
+  /**
+   * Creates a new Formatter for the provided input value.
+   * @param input - The value to format (object, array, primitive, etc.).
+   */
+  format<T>(input: T): Formatter<T>;
+}
+/**
+ * Formatter<T> provides a fluent API for transforming and filtering
+ * values of type T. Supports:
+ * - apply(): field-level transformations or full-object mapping
+ * - filter(): deep removal of undefined or unwanted values
+ * - exec(): retrieve the final formatted result
+ *
+ * @typeParam T - The type of the value being formatted.
+ */
+declare class Formatter<T> {
+  private value;
+  /**
+   * @param value - The initial value to be processed.
+   */
+  constructor(value: T);
+  /**
+   * Applies transformations to the current value.
+   * @param transformationsOrTransformer - Field map or full-object transformer.
+   * @returns The same Formatter instance for chaining.
+   */
+  apply(transformationsOrTransformer: Partial<Record<keyof T, (value: any) => any>> | ((value: T) => T | null | undefined)): Formatter<T | null | undefined>;
+  /**
+   * Recursively filters out values based on the provided predicate.
+   * Works deeply on arrays and plain objects, while treating custom
+   * class instances and primitives as leaves.
+   * @param predicate - Function to test each leaf value.
+   * @returns The same Formatter instance for chaining.
+   */
+  filter(predicate?: (value: any) => boolean): this;
+  /**
+   * Retrieves the formatted and filtered result.
+   * @returns The processed value of type T.
+   */
+  exec(): T;
+  /**
+   * Applies multiple field-level transformations in a single step.
+   * @param transformations - Object mapping keys to transformer functions.
+   */
+  private applyTransformations;
+}
+declare class FormatterControllerImpl implements FormatterController {
+  format<T>(input: T): Formatter<T>;
+}
+//#endregion
+//#region src/formatter/multipart-formatter-controller.d.ts
+interface MultipartFormatterController {
+  /**
+   * Normalize multipart fields into JSON-compatible values.
+   *
+   * - "true"/"false" → boolean
+   * - Numeric strings → number
+   * - Valid JSON → parsed
+   * - Fallback → plain string
+   *
+   * @param input Raw multipart fields as { [key: string]: unknown }
+   * @returns Normalized fields as { [key: string]: unknown }
+   */
+  normalizeFields(input: Record<string, unknown>): Record<string, unknown>;
+}
+declare class MultipartFormatterControllerImpl implements MultipartFormatterController {
+  normalizeFields(input: Record<string, unknown>): Record<string, unknown>;
+  private normalizeValue;
+}
+//#endregion
+//#region src/file/temporary-file-repository.d.ts
+interface TemporaryFileRepository {
+  /**
+   * Absolute path to the OS temporary directory used as a root for all operations.
+   */
+  get rootDirectory(): string;
+  /**
+   * Ensure a subdirectory under the temp root exists.
+   *
+   * @param relativePath - A subpath like `request-id/cover`. Treated as relative to the temp root.
+   * @returns Absolute path to the created/existing directory.
+   * @throws If the directory cannot be created.
+   */
+  createDirectory(relativePath: string): Promise<string>;
+  /**
+   * Remove a directory (recursively) under the temp root.
+   *
+   * @param relativePath - A subpath like `request-id/cover`. Treated as relative to the temp root.
+   * @returns Resolves when deletion completes. No-op if it doesn’t exist.
+   * @throws If the deletion fails.
+   */
+  deleteDirectory(relativePath: string): Promise<void>;
+  /**
+   * Persist a file under the temp root.
+   *
+   * The final filename will be `<filename>.<type.extension>`.
+   *
+   * @param filename - Basename without extension (e.g., `cover`, `preview_0`).
+   * @param content - Buffer or Readable stream to write.
+   * @param type - Output type providing the file extension.
+   * @param relativeDirectory - Subdirectory under the temp root (e.g., `request-id/cover`).
+   * @returns Absolute file path written on disk.
+   * @throws If writing fails or content type is unsupported.
+   */
+  save(filename: string, content: NodeJS.ReadableStream | Buffer, type: FormatType, relativeDirectory: string): Promise<string>;
+  /**
+   * Remove a file under the temp root.
+   *
+   * @param relativeFilePath - Subpath like `request-id/cover/cover.jpeg`.
+   * @returns Resolves when deletion completes. No-op if it doesn’t exist.
+   * @throws If the deletion fails.
+   */
+  delete(relativeFilePath: string): Promise<void>;
+}
+declare class TemporaryFileRepositoryImpl implements TemporaryFileRepository {
+  private readonly logger;
+  private readonly rootDir;
+  constructor(logger: Logger);
+  get rootDirectory(): string;
+  createDirectory(relativePath: string): Promise<string>;
+  deleteDirectory(relativePath: string): Promise<void>;
+  save(filename: string, content: NodeJS.ReadableStream | Buffer, type: FormatType, relativeDirectory: string): Promise<string>;
+  delete(relativeFilePath: string): Promise<void>;
+  /**
+   * Resolve a user-provided relative path against the repository root,
+   * normalize it, and reject traversal outside the root.
+   */
+  private safeJoin;
+}
+//#endregion
+//#region src/generator/random-value-generator-options.d.ts
+/**
+ * @description Built-in alphabet presets for random string generation.
+ */
+type RandomValueAlphabetPreset = 'decimal' | 'lowercase' | 'uppercase' | 'letters' | 'alphanumeric' | 'hex' | 'base64' | 'base64url';
+/**
+ * @description Custom alphabet used for random string generation.
+ * @example
+ * ```ts
+ * const alphabet = { characters: 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789' };
+ * ```
+ */
+interface RandomValueCustomAlphabet {
+  /**
+   * @description Characters that may appear in the generated string.
+   */
+  characters: string;
+}
+/**
+ * @description Alphabet used for random string generation.
+ */
+type RandomValueAlphabet = RandomValueAlphabetPreset | RandomValueCustomAlphabet;
+/**
+ * @description Options for random integer generation.
+ */
+interface GenerateNumberOptions {
+  /**
+   * @description Inclusive lower bound.
+   */
+  min: number;
+  /**
+   * @description Inclusive upper bound.
+   */
+  max: number;
+}
+/**
+ * @description Options for random string generation.
+ */
+interface GenerateStringOptions {
+  /**
+   * @description Exact output length in characters.
+   * @default 8
+   */
+  length?: number;
+  /**
+   * @description Alphabet used to generate the string.
+   * @default 'alphanumeric'
+   */
+  alphabet?: RandomValueAlphabet;
+}
+//#endregion
+//#region src/generator/random-value-generator.d.ts
+/**
+ * @description Generator limits used by `RandomValueGeneratorImpl`.
+ */
+declare const RANDOM_VALUE_GENERATOR_LIMITS: {
+  readonly maxStringLength: 4096;
+  readonly randomIntegerRangeLimit: number;
+};
+/**
+ * @description Default options for `RandomValueGenerator.generateString`.
+ */
+declare const DEFAULT_GENERATE_STRING_OPTIONS: {
+  readonly length: 8;
+  readonly alphabet: "alphanumeric";
+};
+/**
+ * @description Crypto-safe random primitive value generator.
+ */
+interface RandomValueGenerator {
+  /**
+   * @description Generates a random integer inside an inclusive range.
+   * @example
+   * ```ts
+   * generator.generateNumber({ min: 1000, max: 9999 });
+   * ```
+   * @throws Error when `min`, `max`, or the requested range is invalid.
+   */
+  generateNumber(options: GenerateNumberOptions): number;
+  /**
+   * @description Generates a random string from an alphabet.
+   * @default DEFAULT_GENERATE_STRING_OPTIONS
+   * @example
+   * ```ts
+   * generator.generateString({ length: 6, alphabet: 'decimal' });
+   * ```
+   * @example
+   * ```ts
+   * generator.generateString({ length: 64, alphabet: 'base64url' });
+   * ```
+   * @throws Error when `length` or `alphabet` is invalid.
+   */
+  generateString(options?: GenerateStringOptions): string;
+  /**
+   * @description Generates a random UUID v4 string.
+   * @example
+   * ```ts
+   * generator.generateUuidV4();
+   * ```
+   */
+  generateUuidV4(): string;
+  /**
+   * @description Generates a time-ordered UUID v7 string.
+   * @example
+   * ```ts
+   * generator.generateUuidV7();
+   * ```
+   */
+  generateUuidV7(): string;
+}
+declare class RandomValueGeneratorImpl implements RandomValueGenerator {
+  generateNumber(options: GenerateNumberOptions): number;
+  generateString(options?: GenerateStringOptions): string;
+  generateUuidV4(): string;
+  generateUuidV7(): string;
+  private resolveAlphabet;
+  private assertGenerateNumberOptions;
+  private assertStringLength;
+  private assertAlphabet;
+}
+//#endregion
+//#region src/l10n/resources.d.ts
+declare const ApiKitL10nResource: import("@buildplease/core").L10nResource<{
+  readonly en: {
+    readonly apikit: {
+      errors: {
+        common: {
+          not_found: string;
+          unable_to_process_request: string;
+          unknown_error: string;
+          already_exists: string;
+        };
+        server: {
+          internal: string;
+          unavailable: string;
+          dependency_failed: string;
+          timeout: string;
+        };
+        limit: {
+          too_many_requests: string;
+        };
+        auth: {
+          unauthorized: string;
+          forbidden: string;
+        };
+        validation: {
+          bad_request: string;
+          invalid_json_syntax: string;
+          invalid_properties: string;
+          invalid_format: string;
+          invalid_date_format: string;
+          invalid_password: string;
+          invalid_password_new_same_as_old: string;
+          invalid_phone_number_format: string;
+          invalid_phone_new_same_as_old: string;
+          invalid_email_format: string;
+          invalid_email_new_same_as_old: string;
+        };
+        format: {
+          unsupported: string;
+          max_size_exceeded: string;
+        };
+        image: {
+          max_size_exceeded: string;
+        };
+      };
+    };
+    readonly core: {
+      common: {
+        actions: {
+          save: string;
+          cancel: string;
+          delete: string;
+          confirm: string;
+          close: string;
+          back: string;
+          next: string;
+        };
+        date_time: {
+          relative: {
+            today: string;
+            tomorrow: string;
+            yesterday: string;
+          };
+          interval: {
+            second: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            minute: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            hour: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            day: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            week: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            month: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            year: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+          };
+          weekday: {
+            monday: string;
+            tuesday: string;
+            wednesday: string;
+            thursday: string;
+            friday: string;
+            saturday: string;
+            sunday: string;
+          };
+          month: {
+            january: string;
+            february: string;
+            march: string;
+            april: string;
+            may: string;
+            june: string;
+            july: string;
+            august: string;
+            september: string;
+            october: string;
+            november: string;
+            december: string;
+          };
+        };
+        validation: {
+          opening_hours: {
+            time_required: string;
+            time_range_incomplete: string;
+          };
+        };
+      };
+    };
+  };
+  readonly sk: {
+    readonly apikit: {
+      errors: {
+        common: {
+          not_found: string;
+          unable_to_process_request: string;
+          unknown_error: string;
+          already_exists: string;
+        };
+        server: {
+          internal: string;
+          unavailable: string;
+          dependency_failed: string;
+          timeout: string;
+        };
+        limit: {
+          too_many_requests: string;
+        };
+        auth: {
+          unauthorized: string;
+          forbidden: string;
+        };
+        validation: {
+          bad_request: string;
+          invalid_json_syntax: string;
+          invalid_properties: string;
+          invalid_format: string;
+          invalid_date_format: string;
+          invalid_password: string;
+          invalid_password_new_same_as_old: string;
+          invalid_phone_number_format: string;
+          invalid_phone_new_same_as_old: string;
+          invalid_email_format: string;
+          invalid_email_new_same_as_old: string;
+        };
+        format: {
+          unsupported: string;
+          max_size_exceeded: string;
+        };
+        image: {
+          max_size_exceeded: string;
+        };
+      };
+    };
+    readonly core: {
+      common: {
+        actions: {
+          save: string;
+          cancel: string;
+          delete: string;
+          confirm: string;
+          close: string;
+          back: string;
+          next: string;
+        };
+        date_time: {
+          relative: {
+            today: string;
+            tomorrow: string;
+            yesterday: string;
+          };
+          interval: {
+            second: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            minute: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            hour: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            day: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            week: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            month: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            year: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+          };
+          weekday: {
+            monday: string;
+            tuesday: string;
+            wednesday: string;
+            thursday: string;
+            friday: string;
+            saturday: string;
+            sunday: string;
+          };
+          month: {
+            january: string;
+            february: string;
+            march: string;
+            april: string;
+            may: string;
+            june: string;
+            july: string;
+            august: string;
+            september: string;
+            october: string;
+            november: string;
+            december: string;
+          };
+        };
+        validation: {
+          opening_hours: {
+            time_required: string;
+            time_range_incomplete: string;
+          };
+        };
+      };
+    };
+  };
+  readonly cs: {
+    readonly apikit: {
+      errors: {
+        common: {
+          not_found: string;
+          unable_to_process_request: string;
+          unknown_error: string;
+          already_exists: string;
+        };
+        server: {
+          internal: string;
+          unavailable: string;
+          dependency_failed: string;
+          timeout: string;
+        };
+        limit: {
+          too_many_requests: string;
+        };
+        auth: {
+          unauthorized: string;
+          forbidden: string;
+        };
+        validation: {
+          bad_request: string;
+          invalid_json_syntax: string;
+          invalid_properties: string;
+          invalid_format: string;
+          invalid_date_format: string;
+          invalid_password: string;
+          invalid_password_new_same_as_old: string;
+          invalid_phone_number_format: string;
+          invalid_phone_new_same_as_old: string;
+          invalid_email_format: string;
+          invalid_email_new_same_as_old: string;
+        };
+        format: {
+          unsupported: string;
+          max_size_exceeded: string;
+        };
+        image: {
+          max_size_exceeded: string;
+        };
+      };
+    };
+    readonly core: {
+      common: {
+        actions: {
+          save: string;
+          cancel: string;
+          delete: string;
+          confirm: string;
+          close: string;
+          back: string;
+          next: string;
+        };
+        date_time: {
+          relative: {
+            today: string;
+            tomorrow: string;
+            yesterday: string;
+          };
+          interval: {
+            second: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            minute: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            hour: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            day: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            week: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            month: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+            year: {
+              one: string;
+              few: string;
+              many: string;
+              other: string;
+            };
+          };
+          weekday: {
+            monday: string;
+            tuesday: string;
+            wednesday: string;
+            thursday: string;
+            friday: string;
+            saturday: string;
+            sunday: string;
+          };
+          month: {
+            january: string;
+            february: string;
+            march: string;
+            april: string;
+            may: string;
+            june: string;
+            july: string;
+            august: string;
+            september: string;
+            october: string;
+            november: string;
+            december: string;
+          };
+        };
+        validation: {
+          opening_hours: {
+            time_required: string;
+            time_range_incomplete: string;
+          };
+        };
+      };
+    };
+  };
+}>;
+declare const ApiKitL10n: {
+  readonly Apikit: {
+    readonly Errors: {
+      readonly Common: {
+        readonly NotFound: "apikit.errors.common.not_found";
+        readonly UnableToProcessRequest: "apikit.errors.common.unable_to_process_request";
+        readonly UnknownError: "apikit.errors.common.unknown_error";
+        readonly AlreadyExists: "apikit.errors.common.already_exists";
+      };
+      readonly Server: {
+        readonly Internal: "apikit.errors.server.internal";
+        readonly Unavailable: "apikit.errors.server.unavailable";
+        readonly DependencyFailed: "apikit.errors.server.dependency_failed";
+        readonly Timeout: "apikit.errors.server.timeout";
+      };
+      readonly Limit: {
+        readonly TooManyRequests: "apikit.errors.limit.too_many_requests";
+      };
+      readonly Auth: {
+        readonly Unauthorized: "apikit.errors.auth.unauthorized";
+        readonly Forbidden: "apikit.errors.auth.forbidden";
+      };
+      readonly Validation: {
+        readonly BadRequest: "apikit.errors.validation.bad_request";
+        readonly InvalidJsonSyntax: "apikit.errors.validation.invalid_json_syntax";
+        readonly InvalidProperties: "apikit.errors.validation.invalid_properties";
+        readonly InvalidFormat: "apikit.errors.validation.invalid_format";
+        readonly InvalidDateFormat: "apikit.errors.validation.invalid_date_format";
+        readonly InvalidPassword: "apikit.errors.validation.invalid_password";
+        readonly InvalidPasswordNewSameAsOld: "apikit.errors.validation.invalid_password_new_same_as_old";
+        readonly InvalidPhoneNumberFormat: "apikit.errors.validation.invalid_phone_number_format";
+        readonly InvalidPhoneNewSameAsOld: "apikit.errors.validation.invalid_phone_new_same_as_old";
+        readonly InvalidEmailFormat: "apikit.errors.validation.invalid_email_format";
+        readonly InvalidEmailNewSameAsOld: "apikit.errors.validation.invalid_email_new_same_as_old";
+      };
+      readonly Format: {
+        readonly Unsupported: "apikit.errors.format.unsupported";
+        readonly MaxSizeExceeded: "apikit.errors.format.max_size_exceeded";
+      };
+      readonly Image: {
+        readonly MaxSizeExceeded: "apikit.errors.image.max_size_exceeded";
+      };
+    };
+  };
+  readonly Core: {
+    readonly Common: {
+      readonly Validation: {
+        readonly OpeningHours: {
+          readonly TimeRequired: "core.common.validation.opening_hours.time_required";
+          readonly TimeRangeIncomplete: "core.common.validation.opening_hours.time_range_incomplete";
+        };
+      };
+      readonly Actions: {
+        readonly Save: "core.common.actions.save";
+        readonly Cancel: "core.common.actions.cancel";
+        readonly Delete: "core.common.actions.delete";
+        readonly Confirm: "core.common.actions.confirm";
+        readonly Close: "core.common.actions.close";
+        readonly Back: "core.common.actions.back";
+        readonly Next: "core.common.actions.next";
+      };
+      readonly DateTime: {
+        readonly Relative: {
+          readonly Today: "core.common.date_time.relative.today";
+          readonly Tomorrow: "core.common.date_time.relative.tomorrow";
+          readonly Yesterday: "core.common.date_time.relative.yesterday";
+        };
+        readonly Interval: {
+          readonly Month: {
+            readonly One: "core.common.date_time.interval.month.one";
+            readonly Few: "core.common.date_time.interval.month.few";
+            readonly Many: "core.common.date_time.interval.month.many";
+            readonly Other: "core.common.date_time.interval.month.other";
+          };
+          readonly Day: {
+            readonly One: "core.common.date_time.interval.day.one";
+            readonly Few: "core.common.date_time.interval.day.few";
+            readonly Many: "core.common.date_time.interval.day.many";
+            readonly Other: "core.common.date_time.interval.day.other";
+          };
+          readonly Second: {
+            readonly One: "core.common.date_time.interval.second.one";
+            readonly Few: "core.common.date_time.interval.second.few";
+            readonly Many: "core.common.date_time.interval.second.many";
+            readonly Other: "core.common.date_time.interval.second.other";
+          };
+          readonly Minute: {
+            readonly One: "core.common.date_time.interval.minute.one";
+            readonly Few: "core.common.date_time.interval.minute.few";
+            readonly Many: "core.common.date_time.interval.minute.many";
+            readonly Other: "core.common.date_time.interval.minute.other";
+          };
+          readonly Hour: {
+            readonly One: "core.common.date_time.interval.hour.one";
+            readonly Few: "core.common.date_time.interval.hour.few";
+            readonly Many: "core.common.date_time.interval.hour.many";
+            readonly Other: "core.common.date_time.interval.hour.other";
+          };
+          readonly Week: {
+            readonly One: "core.common.date_time.interval.week.one";
+            readonly Few: "core.common.date_time.interval.week.few";
+            readonly Many: "core.common.date_time.interval.week.many";
+            readonly Other: "core.common.date_time.interval.week.other";
+          };
+          readonly Year: {
+            readonly One: "core.common.date_time.interval.year.one";
+            readonly Few: "core.common.date_time.interval.year.few";
+            readonly Many: "core.common.date_time.interval.year.many";
+            readonly Other: "core.common.date_time.interval.year.other";
+          };
+        };
+        readonly Weekday: {
+          readonly Monday: "core.common.date_time.weekday.monday";
+          readonly Tuesday: "core.common.date_time.weekday.tuesday";
+          readonly Wednesday: "core.common.date_time.weekday.wednesday";
+          readonly Thursday: "core.common.date_time.weekday.thursday";
+          readonly Friday: "core.common.date_time.weekday.friday";
+          readonly Saturday: "core.common.date_time.weekday.saturday";
+          readonly Sunday: "core.common.date_time.weekday.sunday";
+        };
+        readonly Month: {
+          readonly January: "core.common.date_time.month.january";
+          readonly February: "core.common.date_time.month.february";
+          readonly March: "core.common.date_time.month.march";
+          readonly April: "core.common.date_time.month.april";
+          readonly May: "core.common.date_time.month.may";
+          readonly June: "core.common.date_time.month.june";
+          readonly July: "core.common.date_time.month.july";
+          readonly August: "core.common.date_time.month.august";
+          readonly September: "core.common.date_time.month.september";
+          readonly October: "core.common.date_time.month.october";
+          readonly November: "core.common.date_time.month.november";
+          readonly December: "core.common.date_time.month.december";
+        };
+      };
+    };
+  };
+};
+//#endregion
+//#region src/image/image-options.d.ts
+/**
+ * Runtime Sharp pipeline instance.
+ */
+type SharpInstance = Sharp;
+/**
+ * Sharp format key accepted by the normalization pipeline.
+ */
+type SharpFormat = Extract<keyof FormatEnum, string>;
+/**
+ * Shared options applied to every image configuration.
+ */
+type Base = {
+  maximumSize?: number;
+  allowedInputFormats?: SharpFormat[];
+  /**
+   * Direct passthrough for Sharp configuration.
+   *
+   * @remarks
+   * If any normalization constraints (`minWidth`, `maxWidth`, `minAspectRatio`, `maxAspectRatio`)
+   * are provided, they take precedence. When no constraints are provided, `resize` is applied.
+   */
+  sharp?: {
+    /** Optional resize transformation applied before encoding. Mirrors `sharp.resize()` options. */
+    resize?: ResizeOptions;
+    /**
+     * Low-level hook executed after framework transforms and before output.
+     * Must return the same Sharp pipeline instance (mutated) or a new pipeline.
+     *
+     * @example
+     * ```ts
+     * configure: s => s.rotate().withMetadata()
+     * ```
+     */
+    configure?: (instance: SharpInstance) => SharpInstance;
+  };
+};
+/** Mapping of encoder-specific options keyed by output format. */
+type OutputOptionsMap = {
+  jpeg: JpegOptions;
+  png: PngOptions;
+  webp: WebpOptions;
+  avif: AvifOptions;
+  heif: HeifOptions;
+  tiff: TiffOptions;
+  jp2: Jp2Options;
+  jxl: JxlOptions;
+  gif: GifOptions;
+};
+/**
+ * Image normalization options describing validation and encoding.
+ */
+type ImageOptions = { [F in keyof OutputOptionsMap]: Base & {
+  /**
+   * Target encoder/format for the processed output.
+   * Determines the allowed type of `sharp.toFormat` options below.
+   */
+  outputFormat: F;
+  /**
+   * Sharp passthrough:
+   * - `resize` (honored only when no normalization constraints are present)
+   * - `toFormat` options (passed to `sharp.toFormat(outputFormat, toFormat)`).
+   */
+  sharp?: Base['sharp'] & {
+    /** Options passed to `sharp.toFormat(outputFormat, toFormat)` */
+    toFormat?: OutputOptionsMap[F];
+  };
+}; }[keyof OutputOptionsMap] & {
+  /** Minimum target width (e.g., 320). */
+  minWidth?: number;
+  /** Maximum target width (e.g., 1080). */
+  maxWidth?: number;
+  /** Minimum supported aspect ratio (width/height), e.g., 0.8 (4:5). */
+  minAspectRatio?: number;
+  /** Maximum supported aspect ratio (width/height), e.g., 1.91 (1.91:1). */
+  maxAspectRatio?: number;
+  /** Aspect-ratio comparison tolerance (e.g., 0.01). */
+  aspectRatioTolerance?: number;
+};
+//#endregion
+//#region src/image/image-normalization-controller.d.ts
+interface ImageNormalizationController {
+  processBufferToBuffer(input: Buffer, options?: ImageOptions): Promise<{
+    buffer: Buffer;
+    type: FormatType;
+  }>;
+  processBufferToStream(input: Buffer, options?: ImageOptions): Promise<{
+    stream: Readable;
+    type: FormatType;
+  }>;
+  processStreamToBuffer(input: Readable, options?: ImageOptions): Promise<{
+    buffer: Buffer;
+    type: FormatType;
+  }>;
+  processStreamToStream(input: Readable, options?: ImageOptions): Promise<{
+    stream: Readable;
+    type: FormatType;
+  }>;
+}
+declare class ImageNormalizationControllerImpl implements ImageNormalizationController {
+  private readonly formatter;
+  constructor(formatter: UnitFormatterController);
+  processBufferToBuffer(input: Buffer, options?: ImageOptions): Promise<{
+    buffer: Buffer<ArrayBuffer>;
+    type: FormatType;
+  }>;
+  processBufferToStream(input: Buffer, options?: ImageOptions): Promise<{
+    stream: Readable;
+    type: FormatType;
+  }>;
+  processStreamToBuffer(input: Readable, options?: ImageOptions): Promise<{
+    buffer: Buffer<ArrayBuffer>;
+    type: FormatType;
+  }>;
+  processStreamToStream(input: Readable, options?: ImageOptions): Promise<{
+    stream: Readable;
+    type: FormatType;
+  }>;
+  private transform;
+  private validateInputFormat;
+  private validateMaximumSize;
+  private toSharpFormat;
+  private toFormatType;
+  private getFormatInfo;
+  private asReadable;
+  private applyNormalization;
+  private validateConstraints;
+  private pickTargetAspectRatio;
+  private makeDefaultOptions;
+}
+//#endregion
+//#region src/normalization/normalization-controller.d.ts
+interface NormalizationController {
+  normalizeEmail(email: string): string;
+  normalizePhoneToE164(phoneNumber: string): string;
+  normalizePhoneToInternational(phoneNumber: string): string;
+  normalizePhoneToNational(phoneNumber: string): string;
+}
+declare class NormalizationControllerImpl implements NormalizationController {
+  normalizeEmail(email: string): string;
+  normalizePhoneToE164(phoneNumber: string): string;
+  normalizePhoneToInternational(phoneNumber: string): string;
+  normalizePhoneToNational(phoneNumber: string): string;
+}
+//#endregion
+//#region src/notification/notification-channel.d.ts
+declare enum NotificationChannel {
+  Telegram = "telegram"
+}
+//#endregion
+//#region src/notification/notification-message.d.ts
+interface NotificationMessage {
+  readonly title?: string;
+  readonly message: string;
+}
+//#endregion
+//#region src/notification/channels/telegram/telegram-notification-request.d.ts
+interface TelegramNotificationRequest {
+  readonly type: NotificationChannel.Telegram;
+  readonly payload: NotificationMessage;
+}
+//#endregion
+//#region src/notification/notification-request.d.ts
+type NotificationChannelRequest = TelegramNotificationRequest;
+interface NotificationRequest {
+  readonly channels: readonly [NotificationChannelRequest, ...NotificationChannelRequest[]];
+}
+//#endregion
+//#region src/notification/notification-result.d.ts
+type NotificationDeliveryStatus = 'sent' | 'failed';
+interface NotificationDeliveryResult {
+  readonly channel: NotificationChannel;
+  readonly status: NotificationDeliveryStatus;
+}
+interface NotificationResult {
+  readonly deliveries: readonly NotificationDeliveryResult[];
+}
+//#endregion
+//#region src/notification/notification-controller.d.ts
+interface NotificationSendOptions {
+  readonly throwOnFailure?: boolean;
+}
+interface NotificationController {
+  send(request: NotificationRequest, options?: NotificationSendOptions): Promise<NotificationResult>;
+}
+//#endregion
+//#region src/openapi/controller.d.ts
+interface OpenAPISchemaController {
+  makeResponse(description: string, contents: Partial<Record<OpenAPIMediaType, OpenAPISchemaMediaType>>, headers?: OpenAPISchemaHeaders): OpenAPISchemaResponse;
+}
+declare class OpenAPISchemaControllerImpl implements OpenAPISchemaController {
+  makeResponse(description: string, contents: Partial<Record<OpenAPIMediaType, OpenAPISchemaMediaType>>, headers?: OpenAPISchemaHeaders): OpenAPISchemaResponse;
+  private constructContent;
+  private constructExamples;
+  private constructHeaders;
+}
+//#endregion
+//#region src/openapi/example.d.ts
+interface OpenAPISchemaExample {
+  summary: string;
+  value: any;
+}
+//#endregion
+//#region src/openapi/headers.d.ts
+interface OpenAPISchemaHeader {
+  description?: string;
+  type: string;
+  format?: string;
+}
+type OpenAPISchemaHeaders = Partial<Record<string, OpenAPISchemaHeader>>;
+//#endregion
+//#region src/openapi/media-type.d.ts
+type OpenAPIMediaType = 'application/json' | 'application/xml' | 'application/x-www-form-urlencoded' | 'multipart/form-data' | 'text/plain; charset=utf-8' | 'text/html' | 'application/pdf' | 'image/png' | 'application/vnd.mycompany.myapp.v2+json' | 'application/vnd.ms-excel' | 'application/vnd.openstreetmap.data+xml' | 'application/vnd.github-issue.text+json' | 'application/vnd.github.v3.diff' | 'image/vnd.djvu';
+interface OpenAPISchemaMediaType {
+  schema: any;
+  examples?: Record<string, OpenAPISchemaExample>;
+}
+//#endregion
+//#region src/openapi/response.d.ts
+interface OpenAPISchemaResponse {
+  description: string;
+  content: Record<OpenAPIMediaType, {
+    schema: any;
+    examples?: Record<string, any>;
+  }>;
+  headers?: OpenAPISchemaHeaders;
+}
+//#endregion
+//#region src/security/cryptography-options.d.ts
+/**
+ * @description Supported output encodings for cryptographic digest and MAC values.
+ */
+type CryptographyOutputEncoding = 'hex' | 'base64url';
+/**
+ * @description Supported digest algorithms.
+ */
+type DigestAlgorithm = 'sha256' | 'sha384' | 'sha512';
+/**
+ * @description Options for cryptographic digest generation.
+ */
+interface DigestOptions {
+  /**
+   * @description Digest algorithm.
+   */
+  algorithm: DigestAlgorithm;
+  /**
+   * @description Encoded output format.
+   */
+  outputEncoding: CryptographyOutputEncoding;
+}
+/**
+ * @description Supported message authentication code algorithms.
+ */
+type MacAlgorithm = 'hmac-sha256' | 'hmac-sha384' | 'hmac-sha512';
+/**
+ * @description Options for message authentication code generation and verification.
+ */
+interface MacOptions {
+  /**
+   * @description Message authentication code algorithm.
+   */
+  algorithm: MacAlgorithm;
+  /**
+   * @description Secret key used by the MAC algorithm.
+   */
+  secret: string;
+  /**
+   * @description Encoded output format.
+   */
+  outputEncoding: CryptographyOutputEncoding;
+}
+/**
+ * @description Supported password hash algorithms.
+ */
+type PasswordHashAlgorithm = 'argon2id';
+/**
+ * @description Options for password hashing.
+ */
+interface PasswordHashOptions {
+  /**
+   * @description Password hash algorithm.
+   */
+  algorithm: PasswordHashAlgorithm;
+  /**
+   * @description Argon2 memory cost in KiB.
+   */
+  memoryCost: number;
+  /**
+   * @description Argon2 iteration count.
+   */
+  timeCost: number;
+  /**
+   * @description Argon2 parallelism factor.
+   */
+  parallelism: number;
+}
+//#endregion
+//#region src/security/cryptography-controller.d.ts
+/**
+ * @description Generic cryptography primitives for Node runtime code.
+ */
+interface CryptographyController {
+  /**
+   * @description Generates a digest for a UTF-8 string value.
+   */
+  digest(value: string, options: DigestOptions): string;
+  /**
+   * @description Generates a message authentication code for a UTF-8 string value.
+   */
+  mac(value: string, options: MacOptions): string;
+  /**
+   * @description Verifies a message authentication code in constant time when lengths match.
+   */
+  verifyMac(value: string, expected: string, options: MacOptions): boolean;
+  /**
+   * @description Hashes a password using the selected password hashing algorithm.
+   */
+  hashPassword(password: string, options: PasswordHashOptions): Promise<string>;
+  /**
+   * @description Verifies a password against an encoded password hash.
+   */
+  verifyPassword(password: string, hash: string): Promise<boolean>;
+  /**
+   * @description Compares two strings in constant time when lengths match.
+   */
+  timingSafeEqual(left: string, right: string): boolean;
+}
+declare class CryptographyControllerImpl implements CryptographyController {
+  digest(value: string, options: DigestOptions): string;
+  mac(value: string, options: MacOptions): string;
+  verifyMac(value: string, expected: string, options: MacOptions): boolean;
+  hashPassword(password: string, options: PasswordHashOptions): Promise<string>;
+  verifyPassword(password: string, hash: string): Promise<boolean>;
+  timingSafeEqual(left: string, right: string): boolean;
+  private encode;
+  private resolveDigestAlgorithm;
+  private resolveMacAlgorithm;
+}
+//#endregion
+//#region src/security/token.d.ts
+declare class Token<T extends Record<string, unknown> = any> {
+  private readonly _value;
+  private readonly _payload;
+  constructor(value: string, payload: T);
+  get value(): string;
+  get payload(): T;
+  getField<K extends keyof T>(key: K): T[K] | undefined;
+}
+//#endregion
+//#region src/server/plugins/index.d.ts
+declare const FastifyPlugins: {
+  readonly basicAuth: import("fastify").FastifyPluginAsync<ServerPluginBaseOptions>;
+  readonly cookie: import("fastify").FastifyPluginAsync;
+  readonly cors: import("fastify").FastifyPluginAsync<ServerPluginBaseOptions>;
+  readonly health: import("fastify").FastifyPluginAsync<ServerPluginBaseOptions>;
+  readonly ip: import("fastify").FastifyPluginAsync;
+  readonly metrics: import("fastify").FastifyPluginAsync<ServerPluginBaseOptions>;
+  readonly multipart: import("fastify").FastifyPluginAsync<ServerPluginBaseOptions>;
+  readonly requestLogger: import("fastify").FastifyPluginAsync<ServerPluginBaseOptions>;
+  readonly requestMetadata: import("fastify").FastifyPluginAsync<ServerPluginBaseOptions>;
+  readonly requestScope: import("fastify").FastifyPluginAsync<ServerPluginBaseOptions>;
+  readonly staticFiles: import("fastify").FastifyPluginAsync<ServerPluginBaseOptions>;
+  readonly view: import("fastify").FastifyPluginAsync;
+};
+//#endregion
+//#region src/server/endpoint.d.ts
+interface Endpoint {
+  method: HttpMethod;
+  url: string;
+  schema(server: FastifyInstance): FastifySchema;
+  handle: (request: FastifyRequest) => Promise<HttpResponse>;
+}
+//#endregion
+//#region src/server/server-controller.d.ts
+interface ServerPluginBaseOptions {
+  i18nController: I18nController;
+  logger: Logger;
+  apikitController: ApiKitController;
+}
+type ServerPluginOptions<TExtras extends object = {}> = ServerPluginBaseOptions & TExtras;
+type ServerPluginExternalHook = (instance: FastifyInstance, options: ServerPluginOptions) => Promise<void>;
+interface ServerController {
+  get instance(): FastifyInstance;
+  preparePlugins(externalHook?: ServerPluginExternalHook): Promise<void>;
+  prepare(shutdownHook?: () => Promise<void>): Promise<void>;
+  start(): Promise<void>;
+}
+declare class ServerControllerImpl implements ServerController {
+  private i18n;
+  private logger;
+  private configuration;
+  private server;
+  constructor(i18n: I18nController, logger: Logger, configuration: ApiKitController);
+  get instance(): FastifyInstance;
+  preparePlugins(externalHook?: ServerPluginExternalHook): Promise<void>;
+  prepare(shutdownHook?: () => Promise<void>): Promise<void>;
+  start(): Promise<void>;
+  private configureErrorHandler;
+  private configureShutdownHandler;
+}
+//#endregion
+//#region src/server/request-controller.d.ts
+type HttpReplyPromise = (request: FastifyRequest, options: object) => Promise<HttpResponse>;
+type HttpOrVoidReplyPromise = (request: FastifyRequest, options?: object) => Promise<HttpResponse | void>;
+interface RequestController {
+  handler(controllerFn: HttpReplyPromise, options?: object): (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+  preHandler(controllerFn: HttpOrVoidReplyPromise, options?: object): (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+}
+declare class RequestControllerImpl implements RequestController {
+  private logger;
+  private responseController;
+  constructor(logger: Logger, responseController: ResponseController);
+  handler(controllerFn: HttpReplyPromise, options?: object): (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+  preHandler(controllerFn: HttpOrVoidReplyPromise, options?: object): (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+  private logError;
+}
+//#endregion
+//#region src/server/response-controller.d.ts
+interface ResponseController {
+  sendResponse(request: FastifyRequest, reply: FastifyReply, response: HttpResponse): Promise<void>;
+}
+declare class ResponseControllerImpl implements ResponseController {
+  private logger;
+  constructor(logger: Logger);
+  sendResponse(request: FastifyRequest, reply: FastifyReply, response: HttpResponse): Promise<void>;
+  private sendJSONResponse;
+  private sendFileResponse;
+  private createResponseHeaders;
+}
+//#endregion
+//#region src/validation/dto-validation-controller.d.ts
+interface DtoValidationController {
+  /**
+   * Synchronously parse & validate `data` with a Zod schema.
+   *
+   * - The return type is inferred from `schema` via `z.infer<S>`.
+   * - Callers do NOT need to pass any generics.
+   *
+   * @param schema  Zod schema to validate against.
+   * @param data    Raw input to validate.
+   * @returns       The parsed value typed as `z.infer<S>`.
+   * @throws        ApiError("Validation.INVALID_PROPERTIES") on validation failure.
+   *
+   * @example
+   * import { z } from 'zod';
+   *
+   * const LoginSchema = z.object({
+   *   email: z.string().email(),
+   *   password: z.string().min(6),
+   * });
+   *
+   * // Inferred type: { email: string; password: string }
+   * const login = validator.validate(LoginSchema, rawBody);
+   */
+  validate<S extends ZodType<any, any, any>>(schema: S, data: unknown): z.infer<S>;
+  /**
+   * Asynchronously parse & validate `data` with a Zod schema.
+   *
+   * - The return type is inferred from `schema` via `z.infer<S>`.
+   * - Callers do NOT need to pass any generics.
+   *
+   * @param schema  Zod schema to validate against.
+   * @param data    Raw input to validate.
+   * @returns       Promise resolving to `z.infer<S>`.
+   * @throws        ApiError("Validation.INVALID_PROPERTIES") on validation failure.
+   *
+   * @example
+   * import { z } from 'zod';
+   *
+   * const RegisterSchema = z.object({
+   *   username: z.string().min(1),
+   *   email: z.string().email(),
+   *   password: z.string().min(8),
+   * });
+   *
+   * // Inferred type: { username: string; email: string; password: string }
+   * const user = await validator.validateAsync(RegisterSchema, requestBody);
+   */
+  validateAsync<S extends ZodType<any, any, any>>(schema: S, data: unknown): Promise<z.infer<S>>;
+}
+declare class DtoValidationControllerImpl implements DtoValidationController {
+  private configuration;
+  private logger;
+  constructor(configuration: ApiKitController, logger: Logger);
+  validate<Output>(schema: ZodType<Output, any, any>, data: unknown): Output;
+  validateAsync<Output>(schema: ZodType<Output, any, any>, data: unknown): Promise<Output>;
+  private handleError;
+  private buildValidationDetails;
+  private buildValidationMessage;
+}
+//#endregion
+//#region src/validation/validation-controller.d.ts
+interface ValidationController {
+  isValidEmail(email?: string | null): boolean;
+  isValidEmailThrowing(email?: string | null): void;
+  isValidPhoneNumber(phoneNumber?: string | null, countryCode?: string): boolean;
+  isValidPhoneNumberThrowing(phoneNumber?: string | null, countryCode?: string): void;
+  isValidCode(code?: string | null): boolean;
+  isValidCodeThrowing(code?: string | null): void;
+  isEmail(input?: string | null): boolean;
+  isEmailThrowing(input?: string | null): void;
+  isPhoneNumber(input?: string | null): boolean;
+  isPhoneNumberThrowing(input?: string | null): void;
+  isNumber(input?: any): boolean;
+  isNumberThrowing(input?: any): void;
+  isString(input?: string | null): boolean;
+  isStringThrowing(input?: string | null): void;
+  isEmptyString(input?: string | null): boolean;
+  isEmptyStringThrowing(input?: string | null): void;
+  isNonEmptyString(input?: string | null): boolean;
+  isNonEmptyStringThrowing(input?: string | null): string;
+  isValidDate(dateString?: string | null): boolean;
+  isValidDateThrowing(dateString?: string | null): Date;
+}
+declare class ValidationControllerImpl implements ValidationController {
+  isValidEmail(email?: string | null): boolean;
+  isValidEmailThrowing(email?: string | null): void;
+  isValidPhoneNumber(phoneNumber?: string | null, countryCode?: string): boolean;
+  isValidPhoneNumberThrowing(phoneNumber?: string | null, countryCode?: string): void;
+  isValidCode(code?: string | null): boolean;
+  isValidCodeThrowing(code?: string | null): void;
+  isEmail(input?: string | null): boolean;
+  isEmailThrowing(input?: string | null): void;
+  isPhoneNumber(input?: string | null): boolean;
+  isPhoneNumberThrowing(input?: string | null): void;
+  isNumber(input?: any): boolean;
+  isNumberThrowing(input?: any): void;
+  isString(input?: string | null): boolean;
+  isStringThrowing(input?: string | null): void;
+  isEmptyString(input?: string | null): boolean;
+  isEmptyStringThrowing(input?: string | null): void;
+  isNonEmptyString(input?: string | null): boolean;
+  isNonEmptyStringThrowing(input?: string | null): string;
+  isValidDate(dateString?: string | null): boolean;
+  isValidDateThrowing(dateString?: string | null): Date;
+}
+//#endregion
+//#region src/index.d.ts
+declare function apikitAssembly(): Assembly[];
+//#endregion
+export { ApiError, ApiErrorCodes, ApiErrorDefinition, ApiErrorDetails, ApiErrorFactory, ApiErrorFactoryOptions, ApiErrorPath, ApiErrorProperties, ApiErrorTree, ApiKitConfig, ApiKitController, ApiKitControllerImpl, ApiKitL10n, ApiKitL10nResource, ApiKitSymbols, AuthorizationErrors, BaseEmailTemplate, BasicAuthAuthenticate, BasicAuthConfig, BasicAuthConfiguration, BuildConfig, BuildConfiguration, type BuildMetadata, CommonErrors, type ConfigurationContract, type ConfigurationField, type ConfigurationResolveContext, Cookie, CookieMutation, CookieOptions, CorsConfig, CorsConfiguration, CorsOptions, CryptographyController, CryptographyControllerImpl, CryptographyOutputEncoding, DEFAULT_GENERATE_STRING_OPTIONS, DefineApiKitInput, DigestAlgorithm, DigestOptions, DtoValidationController, DtoValidationControllerImpl, EmailConfig, EmailConfiguration, EmailController, EmailControllerImpl, EmailTemplate, EmailTemplateInput, Endpoint, type EnvironmentConfig, type EnvironmentDefinition, type EnvironmentRegistry, FastifyPlugins, FileHttpResponse, FormatErrors, FormatType, Formatter, FormatterController, FormatterControllerImpl, GenerateNumberOptions, GenerateStringOptions, HealthConfig, HealthConfiguration, HttpHeaderKey, HttpHeaderValues, HttpHeaders, HttpMethod, HttpResponse, I18nConfig, I18nConfiguration, I18nController, I18nControllerImpl, I18nDirectoryEntry, I18nFactory, I18nFactoryOptions, I18nFallbackLanguages, I18nFileEntry, I18nLoadMode, I18nOptions, I18nPreload, I18nProvider, IRequestScope, ImageErrors, ImageNormalizationController, ImageNormalizationControllerImpl, ImageOptions, type InferConfiguration, JSONHttpResponse, LimitErrors, LoadApiKitContextOptions, LoggerConfig, LoggerConfiguration, LoggerConfigurationValue, LoggerRequestOptions, MacAlgorithm, MacOptions, MetricsConfig, MetricsConfiguration, MetricsDefaultConfig, MetricsEndpoint, MetricsRouteConfig, MongoDbComparisonOperators, MongoDbFieldQuery, MongoDbFieldValue, MongoDbLogicalOperators, MongoDbQuery, MongoDbQueryFormatter, MongoDbQueryFormatterImpl, MongoDbUpdateOptions, MultipartConfig, MultipartConfiguration, MultipartFormatterController, MultipartFormatterControllerImpl, MultipartOptions, NormalizationController, NormalizationControllerImpl, NotificationChannel, NotificationChannelRequest, NotificationChannelsConfig, NotificationConfig, NotificationConfiguration, NotificationConfigurationValue, NotificationController, NotificationDeliveryResult, NotificationDeliveryStatus, NotificationMessage, NotificationRequest, NotificationResult, NotificationSendOptions, OpenAPIMediaType, OpenAPISchemaController, OpenAPISchemaControllerImpl, OpenAPISchemaExample, OpenAPISchemaHeader, OpenAPISchemaHeaders, OpenAPISchemaMediaType, OpenAPISchemaResponse, ParseLocaleOptions, PasswordHashAlgorithm, PasswordHashOptions, RANDOM_VALUE_GENERATOR_LIMITS, RandomValueAlphabet, RandomValueAlphabetPreset, RandomValueCustomAlphabet, RandomValueGenerator, RandomValueGeneratorImpl, RequestController, RequestControllerImpl, RequestLogMetadata, RequestMetadata, RequestScope, RequestScopeData, ResponseController, ResponseControllerImpl, ResponseType, ServerConfig, ServerConfiguration, ServerController, ServerControllerImpl, ServerErrors, ServerPluginBaseOptions, ServerPluginExternalHook, ServerPluginOptions, SharpFormat, SharpInstance, StaticFilesConfig, StaticFilesConfiguration, StaticFilesDotfilesMode, TelegramNotificationConfig, TelegramNotificationRequest, TemporaryFileRepository, TemporaryFileRepositoryImpl, Token, TrustProxy, ValidationController, ValidationControllerImpl, ValidationErrors, apikitAssembly, defineApiKit, defineConfiguration, defineEnvironments, defineErrors, defineSource, fastifyBasicAuth, fastifyCookie, fastifyCors, fastifyIp, fastifyMetrics, fastifyMultipart, fastifyStatic, fastifyUnderPressure, fastifyView, field, fp, isApiErrorDefinition, loadApiKitContext };