@luckystack/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1128 @@
+import { a7 as ErrorParam, a8 as ErrorResponseInput, a9 as NormalizedErrorResponse, b as AuthProps, B as BaseSessionLayout } from './pageRouteValidation-CxZJVwZh.js';
+export { A as ApiMethodMap, a as AppConfig, aa as AuthConfig, ab as CorsConfig, D as DEFAULT_PAGE_ROUTE_RULES, ac as DEFAULT_PROJECT_CONFIG, ad as DevConfig, ae as HttpConfig, H as HttpMethodLiteral, af as HttpStreamConfig, ag as INVALID_ERROR_RESPONSE_CODE, L as Logger, c as LoggerContext, d as LoggingConfig, N as Notifier, e as NotifyInput, f as NotifyParam, ah as OfflineQueueConfig, P as PagePathValidationResult, g as PageRouteRules, ai as PasswordPolicyConfig, aj as PathsConfig, h as ProjectConfig, ak as ProjectConfigInput, R as RateLimitingConfig, S as SOCKETSTATUS, al as SecurityHeadersConfig, am as ServiceRouteParseError, an as ServiceRouteParseResult, ao as ServiceRouteParseSuccess, i as SessionConfig, j as SessionLocation, ap as SocketConfig, aq as SyncConfig, ar as SyncStreamThrottleConfig, as as TransportRouteParseError, at as TransportRouteParseResult, au as TransportRouteParseSuccess, k as buildApiResponseEventName, l as buildApiStreamEventName, m as buildGetJoinedRoomsResponseEventName, n as buildJoinRoomResponseEventName, o as buildLeaveRoomResponseEventName, p as buildSyncProgressEventName, q as buildSyncResponseEventName, r as clearCsrfToken, av as createDevLogger, aw as defaultHttpStatusForResponse, s as enqueueApiRequest, t as enqueueSyncRequest, u as flushApiQueue, v as flushSyncQueue, w as getApiQueueSize, x as getCsrfToken, y as getLogger, z as getNotifier, C as getProjectConfig, ax as getProjectName, E as getRegisteredApiMethod, F as getSyncQueueSize, G as httpFetch, I as incrementResponseIndex, J as isApiMethodMapRegistered, ay as isErrorParamArray, az as isLoggerRegistered, K as isOnline, M as isProjectConfigRegistered, O as normalizeErrorResponseCore, Q as notify, T as parseServiceRouteName, aA as parseTransportRouteName, U as registerApiMethodMap, V as registerLogger, W as registerNotifier, X as registerProjectConfig, Y as removeApiQueueItem, Z as removeApiQueueItemsByKey, _ as removeSyncQueueItem, aB as resetLoggerForTests, $ as setSocket, a0 as sleep, a1 as socket, a2 as socketEventNames, a3 as statusContent, a4 as tryCatch, a5 as validatePagePath, a6 as waitForSocket } from './pageRouteValidation-CxZJVwZh.js';
+export { ApiTypeMap, StreamPayload, SyncTypeMap } from './apiTypeStubs.js';
+import { Server, Socket } from 'socket.io';
+import { z } from 'zod';
+import * as _prisma_client_runtime_library from '@prisma/client/runtime/library';
+import * as _prisma_client from '@prisma/client';
+import { PrismaClient } from '@prisma/client';
+import Redis, { Redis as Redis$1 } from 'ioredis';
+import { ServerResponse, IncomingMessage } from 'node:http';
+import 'socket.io-client';
+
+type LanguageCode = string;
+interface TranslateInput {
+    language: LanguageCode;
+    key: string;
+    params?: ErrorParam[];
+}
+type TranslateFunction = (input: TranslateInput) => string;
+interface NormalizeErrorResponseInput {
+    response: ErrorResponseInput;
+    preferredLocale?: string | null;
+    userLanguage?: string | null;
+    fallbackHttpStatus?: number;
+}
+interface LocalizedNormalizer {
+    normalizeErrorResponse: (input: NormalizeErrorResponseInput) => NormalizedErrorResponse;
+    resolveErrorMessage: (input: {
+        errorCode: string;
+        errorParams?: ErrorParam[];
+        preferredLocale?: string | null;
+        userLanguage?: string | null;
+    }) => string;
+    extractLanguageFromHeader: (header?: string | string[]) => LanguageCode | null;
+}
+interface CreateLocalizedNormalizerInput {
+    translate: TranslateFunction;
+    /**
+     * Language the framework falls back to when the caller provides no
+     * language hints. Defaults to 'en'.
+     */
+    defaultLanguage?: LanguageCode;
+    /**
+     * Decide whether a given string is an acceptable language code. Defaults
+     * to accepting any non-empty short-form code (ISO 639-1 style). Projects
+     * that only support a closed set should pass a narrower predicate.
+     */
+    isSupportedLanguage?: (code: string) => boolean;
+}
+declare const createLocalizedNormalizer: (input: CreateLocalizedNormalizerInput) => LocalizedNormalizer;
+declare const registerLocalizedNormalizer: (normalizer: LocalizedNormalizer) => void;
+declare const getLocalizedNormalizer: () => LocalizedNormalizer;
+declare const isLocalizedNormalizerRegistered: () => boolean;
+declare const normalizeErrorResponse: (input: NormalizeErrorResponseInput) => NormalizedErrorResponse;
+declare const resolveErrorMessage: (input: {
+    errorCode: string;
+    errorParams?: ErrorParam[];
+    preferredLocale?: string | null;
+    userLanguage?: string | null;
+}) => string;
+declare const extractLanguageFromHeader: (header?: string | string[]) => LanguageCode | null;
+
+interface ErrorFormatterContext {
+    /** Resolved route name (`api/billing/getInvoice/v1`, `sync/...`). */
+    routeName: string;
+    /** Transport that triggered the error. */
+    transport: 'socket' | 'http';
+    /** Session id when available. */
+    userId?: string | null;
+}
+type ErrorFormatter = (error: {
+    status: 'error';
+    errorCode?: string;
+    message?: string;
+    httpStatus?: number;
+    [key: string]: unknown;
+}, ctx: ErrorFormatterContext) => Record<string, unknown>;
+/**
+ * Register a global error-response formatter. Receives the normalized
+ * error envelope + context; return a (possibly extended) object that the
+ * framework will emit. Pass `null` to unregister.
+ *
+ * For per-endpoint overrides, export `errorFormatter` from your
+ * `_api/foo_v1.ts` file directly — the api/sync handler imports + invokes
+ * it through `applyErrorFormatter`.
+ */
+declare const registerErrorFormatter: (formatter: ErrorFormatter | null) => void;
+/** Read the active global formatter (or null). */
+declare const getErrorFormatter: () => ErrorFormatter | null;
+/**
+ * Apply per-route → global → identity formatter chain to a normalized
+ * error envelope. Returns the envelope unchanged when `status !== 'error'`
+ * so it's safe to wrap every emit call. Errors thrown inside a formatter
+ * are caught and logged; the un-formatted envelope is returned in that
+ * case to keep the error path crash-resistant.
+ */
+declare const applyErrorFormatter: (input: {
+    response: Record<string, unknown> & {
+        status?: string;
+    };
+    routeName: string;
+    transport: "socket" | "http";
+    userId?: string | null;
+    perRouteFormatter?: ErrorFormatter | undefined | null;
+}) => Record<string, unknown>;
+
+interface apiMessage {
+    name: string;
+    data: object;
+    responseIndex: number;
+}
+interface syncMessage {
+    name: string;
+    data: object;
+    cb: string;
+    receiver: string;
+    responseIndex?: number;
+    ignoreSelf?: boolean;
+}
+declare const setIoInstance: (io: Server | null) => void;
+declare const getIoInstance: () => Server | null;
+
+type RuntimeMapRecord = Record<string, unknown>;
+interface RuntimeApiMapsResult {
+    apisObject: RuntimeMapRecord;
+    functionsObject: RuntimeMapRecord;
+}
+interface RuntimeSyncMapsResult {
+    syncObject: RuntimeMapRecord;
+    functionsObject: RuntimeMapRecord;
+}
+interface RuntimeMapsProvider {
+    getRuntimeApiMaps: () => Promise<RuntimeApiMapsResult>;
+    getRuntimeSyncMaps: () => Promise<RuntimeSyncMapsResult>;
+}
+declare const registerRuntimeMapsProvider: (provider: RuntimeMapsProvider) => void;
+declare const isRuntimeMapsProviderRegistered: () => boolean;
+declare const getRuntimeApiMaps: () => Promise<RuntimeApiMapsResult>;
+declare const getRuntimeSyncMaps: () => Promise<RuntimeSyncMapsResult>;
+
+interface EmailMessage {
+    to: string | string[];
+    subject: string;
+    html: string;
+    text?: string;
+    from?: string;
+    replyTo?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+}
+type EmailResult = {
+    ok: true;
+    id: string;
+} | {
+    ok: false;
+    reason: string;
+    cause?: unknown;
+};
+interface EmailSender {
+    /** Adapter identifier for logs + diagnostics ("console", "resend", "smtp", etc.). */
+    name: string;
+    send: (message: EmailMessage) => Promise<EmailResult>;
+}
+/**
+ * Registry keyed by adapter-slot name. Reserved slots used by the
+ * framework:
+ *
+ *  - `'default'` — fallback when no specific slot matches.
+ *  - `'transactional'` — login password-reset, account-confirmation,
+ *    invoice-receipt, security-critical emails.
+ *  - `'marketing'` — newsletters, announcements; consumers MAY route
+ *    bulk sends here.
+ *  - `'diagnostics'` — diagnostic-test endpoints (e.g. playground).
+ *
+ * Custom slot names ('billing', 'support', etc.) are allowed; consumers
+ * resolve them explicitly via `sendEmail({ adapter: 'billing', ... })`.
+ */
+type EmailSenderRegistry = Partial<Record<string, EmailSender>>;
+/**
+ * Register a single global email sender. Kept for backwards compatibility.
+ * For new code, prefer `registerEmailSenders({ ... })` which lets the
+ * framework route transactional vs. marketing through different adapters.
+ */
+declare const registerEmailSender: (sender: EmailSender) => void;
+/**
+ * Register multiple named email senders. Replaces the entire registry
+ * (last-write-wins). Use this when your app routes different message
+ * types through different adapters — e.g. Resend for marketing and SMTP
+ * for transactional. The framework picks adapter slots by convention
+ * (see `EmailSenderRegistry`); consumer code can pick explicitly via
+ * `sendEmail({ adapter: 'foo', ... })`.
+ */
+declare const registerEmailSenders: (senders: EmailSenderRegistry) => void;
+/** Read the legacy single sender (or the `default` slot of the registry). */
+declare const getEmailSender: () => EmailSender | null;
+/**
+ * Read a specific named sender. Falls back to the legacy single sender
+ * when the requested slot is absent. Returns null when neither exists.
+ * Pass the convention-based slots (`'transactional'`, `'marketing'`,
+ * `'diagnostics'`, `'default'`) or any custom slot you registered.
+ */
+declare const getEmailSenderByName: (name: string) => EmailSender | null;
+/** Read every registered slot name. */
+declare const listEmailSenderNames: () => string[];
+declare const isEmailSenderRegistered: () => boolean;
+
+interface DeployResourceShape {
+    type: 'redis' | 'mongo';
+    urlEnvKey: string;
+    synchronizedEnvKeys?: string[];
+}
+interface DeployEnvironmentShape {
+    redis: string;
+    mongo: string;
+    fallback?: string;
+    bindings: Record<string, string>;
+}
+interface DeployRoutingShape {
+    onMissingService?: 'hard-error' | 'proxy-fallback';
+    missingServiceErrorCode?: string;
+    enableUnhealthyFallback?: boolean;
+    strictBootHandshake?: boolean;
+    /** Default port the router listens on when ROUTER_PORT env var is unset (default 4000). */
+    defaultRouterPort?: number;
+    /** Default ms between health polls when not specified per-call (default 5000). */
+    defaultHealthPollMs?: number;
+    /** ms before the fallback `/_health` probe times out (default 3000). */
+    healthProbeTimeoutMs?: number;
+    /** Seconds the boot-UUID Redis key lives for (default 3600 = 1h). */
+    bootKeyTtlSeconds?: number;
+}
+interface DeployDevelopmentShape {
+    enableFallbackRouting?: boolean;
+    healthPollMs?: number;
+    switchNewTrafficToLocalWhenHealthy?: boolean;
+}
+interface DeployConfigShape {
+    resources: Record<string, DeployResourceShape>;
+    environments?: Record<string, DeployEnvironmentShape>;
+    routing?: DeployRoutingShape;
+    development?: DeployDevelopmentShape;
+}
+declare const registerDeployConfig: (config: DeployConfigShape) => DeployConfigShape;
+declare const getDeployConfig: () => DeployConfigShape;
+declare const isDeployConfigRegistered: () => boolean;
+
+interface ServiceDefinition {
+    /** 'root' -> reserved for the system service. Otherwise a folder name under srcDir. */
+    source: 'root' | string;
+}
+interface PresetDefinition {
+    description?: string;
+    /** Services that are bundled together into one backend artifact. */
+    services: string[];
+}
+interface ServicesConfigShape {
+    services: Record<string, ServiceDefinition>;
+    presets: Record<string, PresetDefinition>;
+}
+declare const registerServicesConfig: (config: ServicesConfigShape) => ServicesConfigShape;
+declare const getServicesConfig: () => ServicesConfigShape;
+declare const isServicesConfigRegistered: () => boolean;
+
+type LocaleReloader = () => void | Promise<void>;
+declare const registerLocaleReloader: (reloader: LocaleReloader) => LocaleReloader;
+declare const getLocaleReloader: () => LocaleReloader | null;
+
+interface SentryInstance {
+    captureException: (exception: unknown, ...args: unknown[]) => string;
+    captureMessage: (message: string, ...args: unknown[]) => string;
+    setUser: (user: unknown) => void;
+    setContext: (key: string, context: unknown) => void;
+    startInactiveSpan?: (context: unknown) => unknown;
+}
+declare const initSharedSentry: (instance: SentryInstance) => void;
+declare const captureException: (error: unknown, context?: Record<string, unknown>) => void;
+declare const captureMessage: (message: string, level?: "info" | "warning" | "error" | "fatal", context?: Record<string, unknown>) => void;
+declare const setSentryUser: (user: {
+    id?: string;
+    email?: string;
+    username?: string;
+} | null) => void;
+declare const startSpan: (name: string, op: string) => unknown;
+
+type ErrorTrackerContext = Record<string, unknown>;
+interface ErrorTrackerUser {
+    id?: string;
+    email?: string;
+    username?: string;
+    [key: string]: unknown;
+}
+interface ErrorTrackerEvent {
+    /** When false, the adapter must not forward this event (beforeSend opt-out). */
+    forwarded: boolean;
+    kind: 'exception' | 'message';
+    payload: Record<string, unknown>;
+}
+type SpanResult<T> = T;
+interface ErrorTracker {
+    /** Human-readable identifier (logs, diagnostics). */
+    name: string;
+    captureException: (error: unknown, context?: ErrorTrackerContext) => void;
+    captureMessage: (message: string, level: 'info' | 'warning' | 'error' | 'fatal', context?: ErrorTrackerContext) => void;
+    setUser: (user: ErrorTrackerUser | null) => void;
+    setContext?: (key: string, context: ErrorTrackerContext | null) => void;
+    startSpan?: <T>(name: string, op: string, fn: () => T) => T;
+    recordMetric?: (name: string, value: number, tags?: Record<string, string>) => void;
+    beforeSend?: (event: ErrorTrackerEvent) => ErrorTrackerEvent | null;
+}
+declare const registerErrorTracker: (tracker: ErrorTracker) => void;
+declare const registerErrorTrackers: (trackers: ErrorTracker[]) => void;
+declare const getActiveErrorTrackers: () => ErrorTracker[];
+declare const captureExceptionAcrossTrackers: (error: unknown, context?: ErrorTrackerContext) => void;
+declare const captureMessageAcrossTrackers: (message: string, level: "info" | "warning" | "error" | "fatal", context?: ErrorTrackerContext) => void;
+declare const setErrorTrackerUser: (user: ErrorTrackerUser | null) => void;
+declare const recordMetricAcrossTrackers: (name: string, value: number, tags?: Record<string, string>) => void;
+declare const startSpanAcrossTrackers: <T>(name: string, op: string, fn: () => T) => T;
+
+declare const EnvSchema: z.ZodObject<{
+    NODE_ENV: z.ZodDefault<z.ZodEnum<{
+        development: "development";
+        production: "production";
+        test: "test";
+    }>>;
+    SERVER_IP: z.ZodDefault<z.ZodString>;
+    SERVER_PORT: z.ZodDefault<z.ZodString>;
+    SECURE: z.ZodDefault<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+    DNS: z.ZodDefault<z.ZodString>;
+    REDIS_HOST: z.ZodDefault<z.ZodString>;
+    REDIS_PORT: z.ZodDefault<z.ZodString>;
+    PROJECT_NAME: z.ZodDefault<z.ZodString>;
+}, z.core.$loose>;
+type RuntimeEnv = z.infer<typeof EnvSchema>;
+declare const DEFAULT_ENV_FILES: string[];
+declare const getEnvFiles: () => string[];
+declare const loadEnvFiles: () => void;
+declare const bootstrapEnv: () => RuntimeEnv;
+declare const env: {
+    [x: string]: unknown;
+    NODE_ENV: "development" | "production" | "test";
+    SERVER_IP: string;
+    SERVER_PORT: string;
+    SECURE: "true" | "false";
+    DNS: string;
+    REDIS_HOST: string;
+    REDIS_PORT: string;
+    PROJECT_NAME: string;
+};
+declare const isProduction: boolean;
+
+declare global {
+    var __luckystackPrisma: PrismaClient | undefined;
+}
+declare const prisma: PrismaClient<_prisma_client.Prisma.PrismaClientOptions, never, _prisma_client_runtime_library.DefaultArgs>;
+
+interface RedisConnectionOptions {
+    host: string;
+    port: number;
+    username?: string;
+    password?: string;
+}
+declare const getRedisConnectionOptions: () => RedisConnectionOptions;
+declare const redis: Redis;
+
+type RedisKeyFormatter = (namespace: string, suffix: string) => string;
+declare const defaultRedisKeyFormatter: RedisKeyFormatter;
+declare const registerRedisKeyFormatter: (fn: RedisKeyFormatter) => void;
+declare const getRedisKeyFormatter: () => RedisKeyFormatter;
+declare const resetRedisKeyFormatterForTests: () => void;
+declare const formatKey: (namespace: string, suffix?: string) => string;
+declare const applyStrayKeyPrefix: (key: string) => string;
+
+/**
+ * Acquire an exclusive lease named `name` for `ttlMs` milliseconds. Returns an
+ * opaque owner token on success, or `null` when another owner already holds it.
+ * `SET key token PX ttl NX` is atomic, so concurrent acquirers race safely.
+ * Keep the returned token to `renewLease` / `releaseLease`.
+ */
+declare const acquireLease: (name: string, ttlMs: number) => Promise<string | null>;
+/**
+ * Extend a held lease by `ttlMs` (sliding ownership). Returns true when the
+ * supplied `token` still owns the lease and the TTL was applied, false
+ * otherwise (lost ownership, expired, or Redis error).
+ */
+declare const renewLease: (name: string, token: string, ttlMs: number) => Promise<boolean>;
+/**
+ * Release a held lease. Owner-checked: only succeeds (returns true) when
+ * `token` is the current holder. Returns false on mismatch or Redis error.
+ */
+declare const releaseLease: (name: string, token: string) => Promise<boolean>;
+
+declare const DEFAULT_CLIENT_KEY = "default";
+declare const registerPrismaClient: (client: PrismaClient, key?: string) => PrismaClient;
+declare const registerRedisClient: (client: Redis$1, key?: string) => Redis$1;
+declare const isPrismaClientRegistered: () => boolean;
+declare const isRedisClientRegistered: () => boolean;
+declare const getPrismaClientKeys: () => string[];
+declare const getRedisClientKeys: () => string[];
+declare const getPrismaClientFor: (key?: string) => PrismaClient;
+declare const getRedisClientFor: (key?: string) => Redis$1;
+declare const getPrismaClient: () => PrismaClient;
+declare const getRedisClient: () => Redis$1;
+declare const resetClientsForTests: () => void;
+
+declare const attachSocketRedisAdapter: (io: Server) => void;
+
+declare const BOOT_KEY_PREFIX = "luckystack:boot:";
+declare const resolveEnvKey: () => string;
+declare const writeBootUuid: (envKey?: string) => Promise<string>;
+declare const readBootUuid: (envKey?: string) => Promise<string | null>;
+
+declare const collectSynchronizedEnvKeys: () => string[];
+declare const computeSynchronizedEnvHashes: () => Record<string, string | null>;
+declare const hashSynchronizedValue: (value: string) => string;
+
+declare const initConsolelog: () => void;
+
+declare const registerRedactedLogKeys: (keys: readonly string[]) => void;
+declare const getRedactedLogKeys: () => readonly string[];
+declare const isRedactedLogKey: (key: string) => boolean;
+declare const resetRedactedLogKeysForTests: () => void;
+
+declare const getCookieValue: (cookieHeader: string | undefined, cookieName: string) => string | null;
+declare const hasCookie: (cookieHeader: string | undefined, cookieName: string) => boolean;
+
+/**
+ * HTTP API Utilities
+ *
+ * Helpers for HTTP API request handling including:
+ * - Smart HTTP method detection based on API name
+ * - Method validation
+ */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+/**
+ * Infer the HTTP method from an API name based on common naming conventions.
+ *
+ * - Names starting with "get" → GET
+ * - Names starting with "delete" or "remove" → DELETE
+ * - Names starting with "update" or "edit" → PUT
+ * - Everything else → POST (create operations, actions)
+ *
+ * @example
+ * ```typescript
+ * inferHttpMethod('getUserData')   // → 'GET'
+ * inferHttpMethod('deleteAccount') // → 'DELETE'
+ * inferHttpMethod('updateProfile') // → 'PUT'
+ * inferHttpMethod('createUser')    // → 'POST'
+ * inferHttpMethod('sendEmail')     // → 'POST'
+ * ```
+ */
+declare const inferHttpMethod: (apiName: string) => HttpMethod;
+/**
+ * Get the effective HTTP method for an API.
+ * Uses explicit export if available, otherwise infers from name.
+ */
+declare const getEffectiveHttpMethod: (apiConfig: {
+    httpMethod?: HttpMethod;
+}, apiName: string) => HttpMethod;
+/**
+ * Check if an HTTP method is valid for an API.
+ *
+ * @param requestMethod - The method from the HTTP request
+ * @param allowedMethod - The method the API accepts
+ * @returns true if the method matches or if it's a preflight OPTIONS request
+ */
+declare const isMethodAllowed: (requestMethod: string, allowedMethod: HttpMethod) => boolean;
+
+declare const ROOT_DIR: string;
+declare const getSrcDir: () => string;
+declare const getServerDir: () => string;
+declare const getSharedDir: () => string;
+declare const getUploadsDir: () => string;
+declare const getPublicDir: () => string;
+declare const getServerFunctionDirs: () => string[];
+/**
+ * @deprecated Use `getServerFunctionDirs()` instead. Returns the first
+ * directory from the array, or `'functions'` resolved against the workspace
+ * root when no directories are configured.
+ */
+declare const getServerFunctionsDir: () => string;
+declare const getGeneratedSocketTypesPath: () => string;
+declare const getGeneratedApiSchemasPath: () => string;
+declare const getGeneratedApiDocsPath: () => string;
+declare const SRC_DIR: string;
+/** @deprecated use `getServerDir()` instead. */
+declare const SERVER_DIR: string;
+/** @deprecated use `getSharedDir()` instead. */
+declare const SHARED_DIR: string;
+/** @deprecated use `getUploadsDir()` instead. */
+declare const UPLOADS_DIR: string;
+/** @deprecated use `getPublicDir()` instead. */
+declare const PUBLIC_DIR: string;
+/** @deprecated use `getServerFunctionsDir()` instead. */
+declare const SERVER_FUNCTIONS_DIR: string;
+/** @deprecated use `getGeneratedSocketTypesPath()` instead. */
+declare const GENERATED_SOCKET_TYPES_PATH: string;
+/** @deprecated use `getGeneratedApiSchemasPath()` instead. */
+declare const GENERATED_API_SCHEMAS_PATH: string;
+/** @deprecated use `getGeneratedApiDocsPath()` instead. */
+declare const GENERATED_API_DOCS_PATH: string;
+declare const TSCONFIG_ALIAS_FILES: string[];
+declare const resolveFromRoot: (...segments: string[]) => string;
+
+type SocketMiddleware = (socket: Socket, next: (err?: Error) => void) => void;
+/**
+ * Register a Socket.io middleware that will be wired via `io.use(...)` when
+ * the framework boots the socket server. Multiple middlewares can be
+ * registered — they run in registration order before any `connect`
+ * handler fires.
+ */
+declare const registerSocketMiddleware: (mw: SocketMiddleware) => void;
+/** Read the registered middleware list (read-only view). */
+declare const getSocketMiddlewares: () => readonly SocketMiddleware[];
+/** Test-only / hot-reload helper. Drops every registered middleware. */
+declare const clearSocketMiddlewares: () => void;
+/**
+ * Wire every registered middleware into the running Socket.io server.
+ * Called by `@luckystack/server`'s `loadSocket` after the `SocketIOServer`
+ * is constructed and before any `connect` handler is attached, so custom
+ * middlewares run before framework handlers see the socket.
+ */
+declare const applySocketMiddlewares: (io: Server) => void;
+
+interface CsrfCookieOptions {
+    sameSite?: 'strict' | 'lax' | 'none';
+    secure?: boolean;
+    /**
+     * MUST be false for CSRF cookies — the client needs to read the value
+     * with JS to attach it as a request header. The framework reads the
+     * value from the session record (Redis-side) rather than the cookie,
+     * so this flag is documentation/intent only.
+     */
+    httpOnly?: boolean;
+    path?: string;
+    maxAgeMs?: number;
+}
+interface CsrfConfig {
+    /** Cookie name used to deliver the CSRF token to the browser. */
+    cookieName: string;
+    /** Request-header name the client attaches on state-changing requests. */
+    headerName: string;
+    /** Length in bytes of the random token minted by the session layer. */
+    tokenLength: number;
+    cookieOptions: CsrfCookieOptions;
+}
+declare const DEFAULT_CSRF_CONFIG: CsrfConfig;
+/**
+ * Override one or more CSRF settings. Merges shallowly with the current
+ * config; `cookieOptions` is deep-merged so a partial override of (say)
+ * `sameSite` does not clobber `path` / `maxAgeMs`. Last-write-wins.
+ */
+declare const registerCsrfConfig: (input: Partial<CsrfConfig>) => void;
+/** Read the active config at call time (never at module load). */
+declare const getCsrfConfig: () => CsrfConfig;
+/** Test-only — restore defaults between scenarios. */
+declare const resetCsrfConfigForTests: () => void;
+
+declare const serveAvatar: ({ routePath, res, }: {
+    routePath: string;
+    res: ServerResponse;
+}) => Promise<void>;
+
+interface ProcessUploadInput {
+    /** User the upload is associated with. */
+    userId: string;
+    /** Content type from the source (e.g. parsed from a data URL prefix). */
+    contentType: string;
+    /** Raw upload bytes — used for `sizeBytes` and passed to the encoder. */
+    buffer: Buffer;
+    /** Identifier for the upload category. Defaults to `'avatar'`. */
+    uploadKind?: string;
+    /** Final file name written to disk (used in the `onUploadComplete` payload). */
+    fileName: string;
+    /**
+     * Project-supplied encode + write step. Receives the raw buffer, does
+     * whatever encoding/resizing the installer wants (sharp, ffmpeg, raw fs
+     * write, S3 upload, etc.), and returns the final byte size on disk —
+     * pass through `buffer.byteLength` if you don't have a meaningful
+     * post-encode size.
+     */
+    encodeAndSave: (buffer: Buffer) => Promise<number>;
+}
+type ProcessUploadResult = {
+    status: 'success';
+    sizeBytes: number;
+} | {
+    status: 'rejected';
+    errorCode: string;
+} | {
+    status: 'error';
+    reason: string;
+    cause?: unknown;
+};
+/**
+ * Run a project-side upload through the framework's hook contract.
+ *
+ * Order of operations:
+ *   1. Dispatch `onUploadStart` — handlers may return a stop signal to reject
+ *      the upload (content moderation, virus scanner, quota check).
+ *   2. Run the project-supplied `encodeAndSave` callback (wrapped in tryCatch).
+ *   3. Dispatch `onUploadComplete` with the final `sizeBytes`.
+ *
+ * Returns one of three statuses so the caller can map to its own response
+ * envelope without inspecting hook internals.
+ */
+declare const processUpload: (input: ProcessUploadInput) => Promise<ProcessUploadResult>;
+
+interface BindAddress {
+    ip: string;
+    port: number;
+}
+declare const registerBindAddress: (address: BindAddress) => void;
+declare const getBindAddress: () => {
+    ip: string;
+    port: string;
+};
+
+interface AvatarConfig {
+    /**
+     * File format(s) the framework will look for on disk, in order. The first
+     * one that exists wins. Each entry is `{ extension, contentType }` so the
+     * `Content-Type` response header matches what the file actually is.
+     * Default: `[{ extension: 'webp', contentType: 'image/webp' }]`.
+     */
+    formats: {
+        extension: string;
+        contentType: string;
+    }[];
+    /**
+     * `Cache-Control` value sent with the avatar response.
+     * Default: `'public, max-age=86400'` (24 hours).
+     */
+    cacheControl: string;
+}
+declare const DEFAULT_AVATAR_CONFIG: AvatarConfig;
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object | undefined ? DeepPartial<NonNullable<T[K]>> : T[K];
+};
+type AvatarConfigInput = DeepPartial<AvatarConfig>;
+declare const registerAvatarConfig: (config: AvatarConfigInput) => void;
+declare const getAvatarConfig: () => AvatarConfig;
+
+interface getParamsType {
+    method: string;
+    req: IncomingMessage;
+    res: ServerResponse;
+    queryString?: string;
+}
+declare function getParams({ method, req, res: _res, queryString }: getParamsType): Promise<Record<string, unknown> | null>;
+
+/**
+ * Extract the authentication token from a Socket.io connection.
+ *
+ * Checks `config.sessionBasedToken` to determine where to look:
+ * - `true`: Token is in `socket.handshake.auth.token` (sessionStorage on client)
+ * - `false`: Token is in cookies via `socket.handshake.headers.cookie`
+ *
+ * @param socket - The Socket.io socket instance
+ * @returns The token string or null if not found
+ */
+declare const extractTokenFromSocket: (socket: Pick<Socket, "handshake">) => string | null;
+
+/**
+ * Extract the authentication token from an HTTP request.
+ *
+ * Supports tokens from:
+ * - `Authorization: Bearer <token>` header
+ * - the configured session cookie
+ *
+ * @param req - The HTTP incoming message
+ * @returns The token string or null if not found
+ */
+declare const extractTokenFromRequest: (req: IncomingMessage) => string | null;
+
+/**
+ * Shared validation utilities for API and Sync request handlers.
+ * Extracted to avoid code duplication between handleApiRequest and handleSyncRequest.
+ */
+
+/**
+ * Check if a value is falsy (false, 0, 0n, '', null, undefined, or NaN)
+ */
+declare const isFalsy: (value: unknown) => boolean;
+interface ValidationResult$1 {
+    status: 'success' | 'error';
+    errorCode?: string;
+    errorParams?: {
+        key: string;
+        value: string | number | boolean;
+    }[];
+    httpStatus?: number;
+}
+/**
+ * Validate a request against authentication requirements.
+ *
+ * Multiple constraints on a single `additional` entry are AND'd: every
+ * specified field (`nullish`, `type`, `value`, `mustBeFalsy`) must pass
+ * for that entry to validate. Each entry across the array is also AND'd:
+ * the request must pass every entry to succeed.
+ *
+ * Constraint semantics:
+ *   - `nullish: true`     — `val` must be `null` or `undefined`.
+ *   - `nullish: false`    — `val` must NOT be `null` or `undefined`.
+ *   - `type: 'string'`    — `typeof val === 'string'` (skipped when val is null/undefined).
+ *   - `value: <x>`        — strict equality `val === x`. Omit the field entirely if you
+ *                           don't want this check; setting `value: undefined`
+ *                           explicitly means "val must be undefined".
+ *   - `mustBeFalsy: true`  — `isFalsy(val)`.
+ *   - `mustBeFalsy: false` — `!isFalsy(val)`.
+ */
+declare const validateRequest: ({ auth, user }: {
+    auth: AuthProps;
+    user: BaseSessionLayout;
+}) => ValidationResult$1;
+
+/**
+ * Rate Limiter
+ *
+ * The framework's rate-limit dispatch is pluggable via
+ * `registerRateLimitStrategy()`. The built-in `defaultRateLimitStrategy`
+ * implements in-memory counters with optional Redis backing for
+ * multi-instance deployments. Consumers can plug in alternative strategies
+ * (token-bucket, sliding-window, per-user tiers, edge-KV-backed, etc.) by
+ * implementing the `RateLimitStrategy` interface.
+ */
+interface CheckRateLimitParams {
+    /** Unique key for rate limiting (e.g., "user:123:api:getData") */
+    key: string;
+    /** Maximum requests allowed in window */
+    limit: number;
+    /** Time window in milliseconds (default: 60_000 = 1 minute) */
+    windowMs?: number;
+}
+interface RateLimitResult {
+    /** Whether the request is allowed */
+    allowed: boolean;
+    /** Remaining requests in current window */
+    remaining: number;
+    /** Seconds until rate limit resets */
+    resetIn: number;
+}
+/**
+ * Pluggable rate-limit backend. The framework calls these methods through
+ * the active strategy slot. Default implementation is memory + Redis.
+ * Replace via `registerRateLimitStrategy(...)` at boot.
+ */
+interface RateLimitStrategy {
+    /** Human-readable identifier (used in logs/diagnostics). */
+    name: string;
+    /** Increment the counter for `key` and return whether the request is allowed. */
+    check(params: CheckRateLimitParams): Promise<RateLimitResult>;
+    /** Read current status without incrementing — useful for response headers. */
+    getStatus(key: string, limit: number): Promise<RateLimitResult>;
+    /** Reset the counter for a single key. */
+    clear(key: string): Promise<void>;
+    /** Reset all counters under this strategy's namespace. */
+    clearAll(): Promise<void>;
+}
+/**
+ * Built-in strategy: in-memory counters with optional Redis backing for
+ * multi-instance deployments. Mode is controlled by
+ * `projectConfig.rateLimiting.store` (`'memory'` or `'redis'`). When `redis`
+ * mode fails (e.g. Redis disconnect), the strategy silently degrades to
+ * in-memory and logs a one-shot warning.
+ */
+declare const defaultRateLimitStrategy: RateLimitStrategy;
+/**
+ * Replace the active rate-limit backend. Pass a strategy that implements
+ * `RateLimitStrategy`. Common use cases:
+ *
+ *  - Token-bucket / sliding-window algorithms for smoother burst handling.
+ *  - Per-user tier limits (premium accounts get higher caps).
+ *  - Cloudflare-Workers-KV or upstash-rest-backed counters for edge.
+ *  - No-op strategy for test environments.
+ *
+ * Call this once at boot (typically from `luckystack/server/index.ts`)
+ * BEFORE the first request lands. Subsequent calls overwrite the previous
+ * registration (last-write-wins).
+ */
+declare const registerRateLimitStrategy: (strategy: RateLimitStrategy) => void;
+/** Read the currently-active strategy (defaults to the built-in). */
+declare const getRateLimitStrategy: () => RateLimitStrategy;
+/**
+ * Check if a request is allowed under rate limiting rules.
+ * Increments the counter for the key if allowed.
+ */
+declare const checkRateLimit: (params: CheckRateLimitParams) => Promise<RateLimitResult>;
+/**
+ * Get current rate limit status without incrementing counter.
+ * Useful for rate limit headers in responses.
+ */
+declare const getRateLimitStatus: (key: string, limit: number) => Promise<RateLimitResult>;
+/**
+ * Clear rate limit for a specific key.
+ * Useful for admin overrides or testing.
+ */
+declare const clearRateLimit: (key: string) => Promise<void>;
+/**
+ * Clear all rate limits.
+ * Useful for testing or server restart.
+ */
+declare const clearAllRateLimits: () => Promise<void>;
+
+type ValidationResult = {
+    status: 'success';
+} | {
+    status: 'error';
+    message: string;
+};
+declare const validateInputByType: ({ typeText, value, rootKey, filePath, }: {
+    typeText?: string;
+    value: unknown;
+    rootKey: string;
+    filePath?: string;
+}) => Promise<ValidationResult>;
+
+declare const allowedOrigin: (origin: string) => boolean;
+
+declare const registerSyncAbortController: (socketId: string, cb: string, controller: AbortController) => string;
+declare const unregisterSyncAbortController: (key: string) => void;
+declare const abortSyncByCb: (socketId: string, cb: string) => boolean;
+declare const registerApiAbortController: (socketId: string, responseIndex: number | string, controller: AbortController) => string;
+declare const unregisterApiAbortController: (key: string) => void;
+declare const abortApiByResponseIndex: (socketId: string, responseIndex: number | string) => boolean;
+declare const abortAllForSocket: (socketId: string) => void;
+
+/**
+ * Core hook contract: framework-generic payload shapes + augmentable registry.
+ *
+ * Feature packages (login/sync/api/presence/...) extend `HookPayloads` via
+ * TypeScript module augmentation:
+ *
+ * ```ts
+ * // packages/<feature>/src/hookPayloads.ts
+ * declare module '@luckystack/core' {
+ *   interface HookPayloads {
+ *     myFeatureHook: { ... };
+ *   }
+ * }
+ * export {};
+ * ```
+ *
+ * Module-augmentation files MUST be in a tsconfig `include` path for TS to
+ * pick up the merge; a side-effect import from the package's `index.ts`
+ * (`import './hookPayloads';`) guarantees this.
+ */
+
+/**
+ * Minimal session shape used inside core-owned hook payloads. Defined here
+ * (instead of imported from `@luckystack/login`) so `@luckystack/core` stays
+ * independent of login. Any concrete session type (`BaseSessionLayout`,
+ * project-level `SessionLayout` extending Prisma User, etc.) is structurally
+ * assignable to this shape.
+ */
+interface HookSessionShape {
+    id: string;
+    token: string;
+    email?: string | null;
+    name?: string | null;
+    avatar?: string | null;
+    avatarFallback?: string | null;
+    admin?: boolean | null;
+    language?: string | null;
+    roomCodes?: string[];
+}
+interface HookStopSignal {
+    stop: true;
+    errorCode: string;
+    httpStatus?: number;
+}
+/** Handlers return undefined / void to continue, or a stop signal to abort the main flow. */
+type HookResult = void | undefined | HookStopSignal;
+type HookHandler<TPayload> = (payload: TPayload) => Promise<HookResult> | HookResult;
+interface PreApiValidatePayload {
+    routeName: string;
+    data: Record<string, unknown>;
+    user: HookSessionShape | null;
+    /**
+     * Optional transport tag — populated by the framework's socket/HTTP API
+     * handlers so hook subscribers can branch on it (e.g. open span with a
+     * different op name). Optional so consumer-side dispatchers don't have to
+     * set it explicitly.
+     */
+    transport?: 'socket' | 'http';
+}
+interface PostApiValidatePayload extends PreApiValidatePayload {
+    validation: {
+        status: 'success';
+    } | {
+        status: 'error';
+        message: string;
+    };
+}
+interface PreApiExecutePayload {
+    routeName: string;
+    data: Record<string, unknown>;
+    user: HookSessionShape | null;
+    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
+    transport?: 'socket' | 'http';
+}
+interface PostApiExecutePayload {
+    routeName: string;
+    data: Record<string, unknown>;
+    user: HookSessionShape | null;
+    result: unknown;
+    error: Error | null;
+    durationMs: number;
+    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
+    transport?: 'socket' | 'http';
+}
+interface ApiResponseEnvelope {
+    status: 'success' | 'error';
+    httpStatus?: number;
+    errorCode?: string;
+    message?: string;
+    [key: string]: unknown;
+}
+interface PreApiRespondPayload {
+    routeName: string;
+    user: HookSessionShape | null;
+    response: ApiResponseEnvelope;
+    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
+    transport?: 'socket' | 'http';
+}
+interface PostApiRespondPayload {
+    routeName: string;
+    user: HookSessionShape | null;
+    response: ApiResponseEnvelope;
+    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
+    transport?: 'socket' | 'http';
+}
+interface PreSyncAuthorizePayload {
+    routeName: string;
+    /** Raw (un-validated) data payload. May be reshape-able by the consumer. */
+    data: Record<string, unknown>;
+    user: HookSessionShape | null;
+    /** Room code / receiver token — the sync's intended audience. */
+    receiver: string;
+    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
+    transport?: 'socket' | 'http';
+}
+interface PostSyncAuthorizePayload {
+    routeName: string;
+    data: Record<string, unknown>;
+    user: HookSessionShape | null;
+    receiver: string;
+    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
+    transport?: 'socket' | 'http';
+}
+interface PreSyncFanoutPayload {
+    routeName: string;
+    data: Record<string, unknown>;
+    user: HookSessionShape | null;
+    receiver: string;
+    serverOutput: unknown;
+    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
+    transport?: 'socket' | 'http';
+}
+interface PostSyncFanoutPayload extends PreSyncFanoutPayload {
+    recipientCount: number;
+}
+interface PreSyncStreamPayload {
+    routeName: string;
+    /** Stream chunk being sent (already serialised by the framework). */
+    chunk: unknown;
+    /** Final recipient — socket id when known, room code otherwise. */
+    recipient: string;
+}
+interface PostSyncStreamPayload extends PreSyncStreamPayload {
+    /** Total chunks streamed so far in this sync invocation. */
+    chunkIndex: number;
+}
+interface ApiErrorPayload {
+    route: string;
+    method?: string;
+    requestId?: string;
+    user?: HookSessionShape | null;
+    error: Error;
+}
+interface SyncErrorPayload {
+    route: string;
+    method?: string;
+    requestId?: string;
+    user?: HookSessionShape | null;
+    error: Error;
+}
+interface RateLimitExceededPayload {
+    /** Where the limit was hit — IP, user, or route. */
+    scope: 'ip' | 'user' | 'route' | 'auth';
+    /** The key that exceeded its limit (sanitized — no tokens). */
+    key: string;
+    /** Configured limit count for this key. */
+    limit: number;
+    /** Window in milliseconds. */
+    windowMs: number;
+    /** Current bucket count after the rejected request. */
+    count: number;
+    /** Optional route or transport context. */
+    route?: string;
+    ip?: string;
+    userId?: string;
+}
+interface CorsRejectedPayload {
+    /** Origin header sent by the client. */
+    origin: string;
+    /** Origin after framework normalization (scheme + host[:port]). */
+    normalizedOrigin: string;
+    /** Effective allowed-origins set at the time of rejection. */
+    allowedOrigins: string[];
+    /** Whether `allowLocalhost` was on. */
+    allowLocalhost: boolean;
+    /** Optional route the rejected request was for. */
+    route?: string;
+}
+interface PreSessionRefreshPayload {
+    token: string;
+    userId: string | null;
+    oldTtl: number | null;
+    newTtl: number;
+}
+interface PostSessionRefreshPayload {
+    token: string;
+    userId: string | null;
+    oldTtl: number | null;
+    newTtl: number;
+    /** True if Redis EXPIRE succeeded; false on failure or non-existent key. */
+    applied: boolean;
+}
+interface OnUploadStartPayload {
+    userId: string;
+    contentType: string;
+    sizeBytes: number;
+    uploadKind: 'avatar' | string;
+}
+interface OnUploadCompletePayload {
+    userId: string;
+    fileName: string;
+    sizeBytes: number;
+    uploadKind: 'avatar' | string;
+}
+interface CsrfMismatchPayload {
+    /** Path of the rejected request. */
+    route: string;
+    /** HTTP method of the rejected request. */
+    method?: string;
+    /** Request id (X-Request-Id) for log correlation. */
+    requestId?: string;
+    /** User id from the session that the request claimed, if any. */
+    userId?: string;
+    /** Whether a token was provided in `x-csrf-token` (presence only — never the value). */
+    providedToken: boolean;
+}
+interface PreHttpRequestPayload {
+    /** HTTP method (always uppercase: GET/POST/...). */
+    method: string;
+    /** Request URL (path + query). */
+    url: string;
+    /** Caller-supplied or framework-generated `X-Request-Id`. */
+    requestId: string;
+    /** Origin header value (or empty string when absent). */
+    origin: string;
+    /**
+     * Subset of headers — `authorization`, `cookie`, etc. are NOT included
+     * to keep payloads safe for logging. Use the full request object via
+     * a custom route if you need raw access.
+     */
+    headers: Record<string, string>;
+}
+interface HookPayloads {
+    preHttpRequest: PreHttpRequestPayload;
+    preApiValidate: PreApiValidatePayload;
+    postApiValidate: PostApiValidatePayload;
+    preApiExecute: PreApiExecutePayload;
+    postApiExecute: PostApiExecutePayload;
+    preApiRespond: PreApiRespondPayload;
+    transformApiResponse: PreApiRespondPayload;
+    postApiRespond: PostApiRespondPayload;
+    preSyncAuthorize: PreSyncAuthorizePayload;
+    postSyncAuthorize: PostSyncAuthorizePayload;
+    preSyncFanout: PreSyncFanoutPayload;
+    postSyncFanout: PostSyncFanoutPayload;
+    preSyncStream: PreSyncStreamPayload;
+    postSyncStream: PostSyncStreamPayload;
+    apiError: ApiErrorPayload;
+    syncError: SyncErrorPayload;
+    rateLimitExceeded: RateLimitExceededPayload;
+    corsRejected: CorsRejectedPayload;
+    csrfMismatch: CsrfMismatchPayload;
+    preSessionRefresh: PreSessionRefreshPayload;
+    postSessionRefresh: PostSessionRefreshPayload;
+    onUploadStart: OnUploadStartPayload;
+    onUploadComplete: OnUploadCompletePayload;
+}
+interface PreErrorNormalizePayload {
+    response: ErrorResponseInput;
+    preferredLocale?: string | null;
+    userLanguage?: string | null;
+    fallbackHttpStatus?: number;
+}
+interface PostErrorNormalizePayload {
+    normalized: NormalizedErrorResponse;
+    preferredLocale?: string | null;
+    userLanguage?: string | null;
+}
+interface SyncHookPayloads {
+    preErrorNormalize: PreErrorNormalizePayload;
+    postErrorNormalize: PostErrorNormalizePayload;
+}
+type SyncHookName = keyof SyncHookPayloads;
+type SyncHookHandler<TPayload> = (payload: TPayload) => void;
+type HookName = keyof HookPayloads;
+
+type DispatchResult = {
+    stopped: false;
+} | {
+    stopped: true;
+    signal: HookStopSignal;
+};
+declare const registerHook: <TName extends HookName>(name: TName, handler: HookHandler<HookPayloads[TName]>) => void;
+declare const dispatchHook: <TName extends HookName>(name: TName, payload: HookPayloads[TName]) => Promise<DispatchResult>;
+declare const clearAllHooks: () => void;
+declare const registerSyncHook: <TName extends SyncHookName>(name: TName, handler: SyncHookHandler<SyncHookPayloads[TName]>) => void;
+declare const dispatchSyncHook: <TName extends SyncHookName>(name: TName, payload: SyncHookPayloads[TName]) => void;
+
+export { type ApiErrorPayload, type ApiResponseEnvelope, AuthProps, type AvatarConfig, type AvatarConfigInput, BOOT_KEY_PREFIX, BaseSessionLayout, type CheckRateLimitParams, type CorsRejectedPayload, type CreateLocalizedNormalizerInput, type CsrfConfig, type CsrfCookieOptions, type CsrfMismatchPayload, DEFAULT_AVATAR_CONFIG, DEFAULT_CLIENT_KEY, DEFAULT_CSRF_CONFIG, DEFAULT_ENV_FILES, type DeployConfigShape, type DeployDevelopmentShape, type DeployEnvironmentShape, type DeployResourceShape, type DeployRoutingShape, type DispatchResult, type EmailMessage, type EmailResult, type EmailSender, type EmailSenderRegistry, type ErrorFormatter, type ErrorFormatterContext, ErrorParam, ErrorResponseInput, type ErrorTracker, type ErrorTrackerContext, type ErrorTrackerEvent, type ErrorTrackerUser, GENERATED_API_DOCS_PATH, GENERATED_API_SCHEMAS_PATH, GENERATED_SOCKET_TYPES_PATH, type HookHandler, type HookName, type HookPayloads, type HookResult, type HookSessionShape, type HookStopSignal, type HttpMethod, type LanguageCode, type LocaleReloader, type LocalizedNormalizer, type NormalizeErrorResponseInput, NormalizedErrorResponse, type OnUploadCompletePayload, type OnUploadStartPayload, PUBLIC_DIR, type PostApiExecutePayload, type PostApiRespondPayload, type PostApiValidatePayload, type PostErrorNormalizePayload, type PostSessionRefreshPayload, type PostSyncFanoutPayload, type PreApiExecutePayload, type PreApiRespondPayload, type PreApiValidatePayload, type PreErrorNormalizePayload, type PreSessionRefreshPayload, type PreSyncAuthorizePayload, type PreSyncFanoutPayload, type PresetDefinition, type ProcessUploadInput, type ProcessUploadResult, ROOT_DIR, type RateLimitExceededPayload, type RateLimitResult, type RateLimitStrategy, type RedisConnectionOptions, type RedisKeyFormatter, type RuntimeApiMapsResult, type RuntimeEnv, type RuntimeMapsProvider, type RuntimeSyncMapsResult, SERVER_DIR, SERVER_FUNCTIONS_DIR, SHARED_DIR, SRC_DIR, type ServiceDefinition, type ServicesConfigShape, type SocketMiddleware, type SpanResult, type SyncErrorPayload, type SyncHookHandler, type SyncHookName, type SyncHookPayloads, TSCONFIG_ALIAS_FILES, type TranslateFunction, type TranslateInput, UPLOADS_DIR, type ValidationResult$1 as ValidationResult, abortAllForSocket, abortApiByResponseIndex, abortSyncByCb, acquireLease, allowedOrigin, type apiMessage, applyErrorFormatter, applySocketMiddlewares, applyStrayKeyPrefix, attachSocketRedisAdapter, bootstrapEnv, captureException, captureExceptionAcrossTrackers, captureMessage, captureMessageAcrossTrackers, checkRateLimit, clearAllHooks, clearAllRateLimits, clearRateLimit, clearSocketMiddlewares, collectSynchronizedEnvKeys, computeSynchronizedEnvHashes, createLocalizedNormalizer, defaultRateLimitStrategy, defaultRedisKeyFormatter, dispatchHook, dispatchSyncHook, env, extractLanguageFromHeader, extractTokenFromRequest, extractTokenFromSocket, formatKey, getActiveErrorTrackers, getAvatarConfig, getBindAddress, getCookieValue, getCsrfConfig, getDeployConfig, getEffectiveHttpMethod, getEmailSender, getEmailSenderByName, getEnvFiles, getErrorFormatter, getGeneratedApiDocsPath, getGeneratedApiSchemasPath, getGeneratedSocketTypesPath, getIoInstance, getLocaleReloader, getLocalizedNormalizer, getParams, getPrismaClient, getPrismaClientFor, getPrismaClientKeys, getPublicDir, getRateLimitStatus, getRateLimitStrategy, getRedactedLogKeys, getRedisClient, getRedisClientFor, getRedisClientKeys, getRedisConnectionOptions, getRedisKeyFormatter, getRuntimeApiMaps, getRuntimeSyncMaps, getServerDir, getServerFunctionDirs, getServerFunctionsDir, getServicesConfig, getSharedDir, getSocketMiddlewares, getSrcDir, getUploadsDir, hasCookie, hashSynchronizedValue, inferHttpMethod, initConsolelog, initSharedSentry, isDeployConfigRegistered, isEmailSenderRegistered, isFalsy, isLocalizedNormalizerRegistered, isMethodAllowed, isPrismaClientRegistered, isProduction, isRedactedLogKey, isRedisClientRegistered, isRuntimeMapsProviderRegistered, isServicesConfigRegistered, listEmailSenderNames, loadEnvFiles, normalizeErrorResponse, prisma, processUpload, readBootUuid, recordMetricAcrossTrackers, redis, registerApiAbortController, registerAvatarConfig, registerBindAddress, registerCsrfConfig, registerDeployConfig, registerEmailSender, registerEmailSenders, registerErrorFormatter, registerErrorTracker, registerErrorTrackers, registerHook, registerLocaleReloader, registerLocalizedNormalizer, registerPrismaClient, registerRateLimitStrategy, registerRedactedLogKeys, registerRedisClient, registerRedisKeyFormatter, registerRuntimeMapsProvider, registerServicesConfig, registerSocketMiddleware, registerSyncAbortController, registerSyncHook, releaseLease, renewLease, resetClientsForTests, resetCsrfConfigForTests, resetRedactedLogKeysForTests, resetRedisKeyFormatterForTests, resolveEnvKey, resolveErrorMessage, resolveFromRoot, serveAvatar, setErrorTrackerUser, setIoInstance, setSentryUser, startSpan, startSpanAcrossTrackers, type syncMessage, unregisterApiAbortController, unregisterSyncAbortController, validateInputByType, validateRequest, writeBootUuid };