express-zod-api 23.5.0 → 24.0.0-beta.2

package/dist/index.d.cts

@@ -1,5 +1,7 @@
-import * as zod from 'zod';
-import { z } from 'zod';
+import * as zod_v4 from 'zod/v4';
+import { z } from 'zod/v4';
+import * as zod_v4_core from 'zod/v4/core';
+import { $ZodType, $ZodShape, $ZodLooseShape, $ZodObjectConfig, JSONSchema } from 'zod/v4/core';
 import compression from 'compression';
 import * as express from 'express';
 import express__default, { Request, Response, NextFunction, RequestHandler, IRouter } from 'express';
@@ -86,10 +88,6 @@ declare class BuiltinLogger implements AbstractLogger {
     profile(options: ProfilerOptions): () => void;
 }
 
-/** @desc Accepts an object shape or a custom object schema */
-declare const form: <S extends z.ZodRawShape>(base: S | z.ZodObject<S>) => z.ZodBranded<z.ZodObject<S, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<S>, any> extends infer T ? { [k in keyof T]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<S>, any>[k]; } : never, z.baseObjectInputType<S> extends infer T_1 ? { [k_1 in keyof T_1]: z.baseObjectInputType<S>[k_1]; } : never>, symbol>;
-type FormSchema = ReturnType<typeof form>;
-
 type LogicalOr<T> = {
     or: T[];
 };
@@ -195,9 +193,10 @@ declare abstract class AbstractMiddleware {
         logger: ActualLogger;
     }): Promise<FlatObject>;
 }
-declare class Middleware<OPT extends FlatObject, OUT extends FlatObject, SCO extends string, IN extends IOSchema<"strip"> = EmptySchema> extends AbstractMiddleware {
+declare class Middleware<OPT extends FlatObject, OUT extends FlatObject, SCO extends string, IN extends IOSchema = EmptySchema> extends AbstractMiddleware {
     #private;
-    constructor({ input, security, handler, }: {
+    constructor({ input, // @todo revisit
+    security, handler, }: {
         /**
          * @desc Input schema of the Middleware, combining properties from all the enabled input sources
          * @default z.object({})
@@ -225,27 +224,11 @@ declare class ExpressMiddleware<R extends Request, S extends Response, OUT exten
     });
 }
 
-declare const base: z.ZodObject<{
-    raw: z.ZodBranded<z.ZodType<Buffer<ArrayBufferLike>, z.ZodTypeDef, Buffer<ArrayBufferLike>>, symbol>;
-}, "strip", z.ZodTypeAny, {
-    raw: Buffer<ArrayBufferLike> & z.BRAND<symbol>;
-}, {
-    raw: Buffer<ArrayBufferLike>;
-}>;
-/** Shorthand for z.object({ raw: ez.file("buffer") }) */
-declare function raw(): z.ZodBranded<typeof base, symbol>;
-declare function raw<S extends z.ZodRawShape>(extra: S): z.ZodBranded<ReturnType<typeof base.extend<S>>, symbol>;
-type RawSchema = ReturnType<typeof raw>;
-
-type BaseObject<U extends z.UnknownKeysParam> = z.ZodObject<z.ZodRawShape, U>;
-interface ObjectBasedEffect<T extends z.ZodTypeAny> extends z.ZodEffects<T, FlatObject> {
-}
-type EffectsChain<U extends z.UnknownKeysParam> = ObjectBasedEffect<BaseObject<U> | EffectsChain<U>>;
-/**
- * @desc The type allowed on the top level of Middlewares and Endpoints
- * @param U — only "strip" is allowed for Middlewares due to intersection issue (Zod) #600
- * */
-type IOSchema<U extends z.UnknownKeysParam = z.UnknownKeysParam> = BaseObject<U> | EffectsChain<U> | RawSchema | FormSchema | z.ZodUnion<[IOSchema<U>, ...IOSchema<U>[]]> | z.ZodIntersection<IOSchema<U>, IOSchema<U>> | z.ZodDiscriminatedUnion<string, BaseObject<U>[]> | z.ZodPipeline<ObjectBasedEffect<BaseObject<U>>, BaseObject<U>>;
+type Base = object & {
+    [Symbol.iterator]?: never;
+};
+/** @desc The type allowed on the top level of Middlewares and Endpoints */
+type IOSchema = z.ZodType<Base>;
 
 declare const methods: ("get" | "post" | "put" | "delete" | "patch")[];
 type Method = (typeof methods)[number];
@@ -263,7 +246,7 @@ declare class ServeStatic {
 }
 
 /** @public this is the user facing configuration */
-interface ApiResponse<S extends z.ZodTypeAny> {
+interface ApiResponse<S extends z.ZodType> {
     schema: S;
     /** @default 200 for a positive and 400 for a negative response */
     statusCode?: number | [number, ...number[]];
@@ -279,25 +262,29 @@ interface ApiResponse<S extends z.ZodTypeAny> {
 }
 
 type ResultSchema<R extends Result> = R extends Result<infer S> ? S : never;
+type DiscriminatedResult = {
+    output: FlatObject;
+    error: null;
+} | {
+    output: null;
+    error: Error;
+};
 /**
  * @example InputValidationError —> BadRequest(400)
  * @example Error —> InternalServerError(500)
  * */
 declare const ensureHttpError: (error: Error) => HttpError;
 
-type Handler$1<RES = unknown> = (params: {
+type Handler$1<RES = unknown> = (params: DiscriminatedResult & {
     /** null in case of failure to parse or to find the matching endpoint (error: not found) */
     input: FlatObject | null;
-    /** null in case of errors or failures */
-    output: FlatObject | null;
     /** can be empty: check presence of the required property using "in" operator */
     options: FlatObject;
-    error: Error | null;
     request: Request;
     response: Response<RES>;
     logger: ActualLogger;
 }) => void | Promise<void>;
-type Result<S extends z.ZodTypeAny = z.ZodTypeAny> = S | ApiResponse<S> | ApiResponse<S>[];
+type Result<S extends z.ZodType = z.ZodType> = S | ApiResponse<S> | ApiResponse<S>[];
 type LazyResult<R extends Result, A extends unknown[] = []> = (...args: A) => R;
 declare abstract class AbstractResultHandler {
     #private;
@@ -318,38 +305,18 @@ declare class ResultHandler<POS extends Result, NEG extends Result> extends Abst
 declare const defaultResultHandler: ResultHandler<z.ZodObject<{
     status: z.ZodLiteral<"success">;
     data: IOSchema;
-}, "strip", z.ZodTypeAny, {
-    status: "success";
-    data?: unknown;
-}, {
-    status: "success";
-    data?: unknown;
-}>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     status: z.ZodLiteral<"error">;
     error: z.ZodObject<{
         message: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        message: string;
-    }, {
-        message: string;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    error: {
-        message: string;
-    };
-    status: "error";
-}, {
-    error: {
-        message: string;
-    };
-    status: "error";
-}>>;
+    }, z.core.$strip>;
+}, z.core.$strip>>;
 /**
  * @deprecated Resist the urge of using it: this handler is designed only to simplify the migration of legacy APIs.
  * @desc Responding with array is a bad practice keeping your endpoints from evolving without breaking changes.
  * @desc This handler expects your endpoint to have the property 'items' in the output object schema
  * */
-declare const arrayResultHandler: ResultHandler<z.ZodArray<z.ZodTypeAny, "many">, z.ZodString>;
+declare const arrayResultHandler: ResultHandler<z.ZodArray<z.core.$ZodType<unknown, unknown>> | z.ZodArray<z.ZodAny>, z.ZodString>;
 
 /** @desc Returns child logger for the given request (if configured) or the configured logger otherwise */
 type GetLogger = (request?: Request) => ActualLogger;
@@ -575,8 +542,8 @@ declare function createConfig(config: ServerConfig): ServerConfig;
 declare function createConfig(config: AppConfig): AppConfig;
 
 /** @desc this type does not allow props assignment, but it works for reading them when merged with another interface */
-type EmptyObject = Record<string, never>;
-type EmptySchema = z.ZodObject<EmptyObject, "strip">;
+type EmptyObject = z.output<EmptySchema>;
+type EmptySchema = z.ZodRecord<z.ZodString, z.ZodNever>;
 type FlatObject = Record<string, unknown>;
 /** @link https://stackoverflow.com/a/65492934 */
 type NoNever<T, F> = [T] extends [never] ? F : T;
@@ -589,35 +556,6 @@ interface TagOverrides {
 }
 type Tag = NoNever<keyof TagOverrides, string>;
 declare const getMessageFromError: (error: Error) => string;
-declare const getExamples: <T extends z.ZodType, V extends "original" | "parsed" | undefined>({ schema, variant, validate, pullProps, }: {
-    schema: T;
-    /**
-     * @desc examples variant: original or parsed
-     * @example "parsed" — for the case when possible schema transformations should be applied
-     * @default "original"
-     * @override validate: variant "parsed" activates validation as well
-     * */
-    variant?: V;
-    /**
-     * @desc filters out the examples that do not match the schema
-     * @default variant === "parsed"
-     * */
-    validate?: boolean;
-    /**
-     * @desc should pull examples from properties — applicable to ZodObject only
-     * @default false
-     * */
-    pullProps?: boolean;
-}) => ReadonlyArray<V extends "parsed" ? z.output<T> : z.input<T>>;
-
-declare const metaSymbol: unique symbol;
-interface Metadata {
-    examples: unknown[];
-    /** @override ZodDefault::_def.defaultValue() in depictDefault */
-    defaultLabel?: string;
-    brand?: string | number | symbol;
-    isDeprecated?: boolean;
-}
 
 /**
  * @fileoverview Mapping utils for Zod Runtime Plugin (remap)
@@ -636,29 +574,32 @@ type Intact<T, U> = {
     [K in Exclude<keyof T, keyof U>]: T[K];
 };
 
-declare module "zod" {
-    interface ZodTypeDef {
-        [metaSymbol]?: Metadata;
+declare module "zod/v4/core" {
+    interface GlobalMeta {
+        deprecated?: boolean;
+        default?: unknown;
     }
+}
+declare module "zod/v4" {
     interface ZodType {
-        /** @desc Add an example value (before any transformations, can be called multiple times) */
-        example(example: this["_input"]): this;
+        /** @desc Shorthand for .meta({examples}), it can be called multiple times */
+        example(example: z.output<this>): this;
         deprecated(): this;
     }
-    interface ZodDefault<T extends z.ZodTypeAny> {
-        /** @desc Change the default value in the generated Documentation to a label */
+    interface ZodDefault<T extends $ZodType = $ZodType> extends ZodType {
+        /** @desc Change the default value in the generated Documentation to a label, alias for .meta({ default }) */
         label(label: string): this;
     }
-    interface ZodObject<T extends z.ZodRawShape, UnknownKeys extends z.UnknownKeysParam = z.UnknownKeysParam, Catchall extends z.ZodTypeAny = z.ZodTypeAny, Output = z.objectOutputType<T, Catchall, UnknownKeys>, Input = z.objectInputType<T, Catchall, UnknownKeys>> {
+    interface ZodObject<out Shape extends $ZodShape = $ZodLooseShape, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends ZodType {
         remap<V extends string, U extends {
-            [P in keyof T]?: V;
-        }>(mapping: U): z.ZodPipeline<z.ZodEffects<this, FlatObject>, // internal type simplified
-        z.ZodObject<Remap<T, U, V> & Intact<T, U>, UnknownKeys>>;
-        remap<U extends z.ZodRawShape>(mapper: (subject: T) => U): z.ZodPipeline<z.ZodEffects<this, FlatObject>, z.ZodObject<U>>;
+            [P in keyof Shape]?: V;
+        }>(mapping: U): z.ZodPipe<z.ZodPipe<this, z.ZodTransform<FlatObject, FlatObject>>, z.ZodObject<Remap<Shape, U, V> & Intact<Shape, U>, Config>>;
+        remap<U extends $ZodShape>(mapper: (subject: Shape) => U): z.ZodPipe<z.ZodPipe<this, z.ZodTransform<FlatObject, FlatObject>>, // internal type simplified
+        z.ZodObject<U>>;
     }
 }
 
-interface BuildProps<IN extends IOSchema, OUT extends IOSchema | z.ZodVoid, MIN extends IOSchema<"strip">, OPT extends FlatObject, SCO extends string> {
+interface BuildProps<IN extends IOSchema, OUT extends IOSchema | z.ZodVoid, MIN extends IOSchema, OPT extends FlatObject, SCO extends string> {
     /**
      * @desc Input schema of the Endpoint, combining properties from all the enabled input sources (path params, headers)
      * @default z.object({})
@@ -694,29 +635,30 @@ interface BuildProps<IN extends IOSchema, OUT extends IOSchema | z.ZodVoid, MIN
     /** @desc Marks the operation deprecated in the generated Documentation */
     deprecated?: boolean;
 }
-declare class EndpointsFactory<IN extends IOSchema<"strip"> = EmptySchema, OUT extends FlatObject = EmptyObject, SCO extends string = string> {
+declare class EndpointsFactory<IN extends IOSchema = EmptySchema, OUT extends FlatObject = EmptyObject, SCO extends string = string> {
     #private;
     protected resultHandler: AbstractResultHandler;
     protected middlewares: AbstractMiddleware[];
     constructor(resultHandler: AbstractResultHandler);
-    addMiddleware<AOUT extends FlatObject, ASCO extends string, AIN extends IOSchema<"strip"> = EmptySchema>(subject: Middleware<OUT, AOUT, ASCO, AIN> | ConstructorParameters<typeof Middleware<OUT, AOUT, ASCO, AIN>>[0]): EndpointsFactory<z.ZodIntersection<IN, AIN>, OUT & AOUT, SCO & ASCO>;
-    use: <R extends Request, S extends Response, AOUT extends FlatObject = EmptyObject>(nativeMw: (request: R, response: S, next: express.NextFunction) => void | Promise<void>, params_1?: {
+    addMiddleware<AOUT extends FlatObject, ASCO extends string, AIN extends IOSchema = EmptySchema>(subject: Middleware<OUT, AOUT, ASCO, AIN> | ConstructorParameters<typeof Middleware<OUT, AOUT, ASCO, AIN>>[0]): EndpointsFactory<z.ZodIntersection<IN, AIN>, OUT & AOUT, SCO & ASCO>;
+    use: <R extends Request, S extends Response, AOUT extends FlatObject = Record<string, never>>(nativeMw: (request: R, response: S, next: express.NextFunction) => void | Promise<void>, params_1?: {
         provider?: ((request: R, response: S) => AOUT | Promise<AOUT>) | undefined;
         transformer?: (err: Error) => Error;
     } | undefined) => EndpointsFactory<IN, OUT & AOUT, SCO>;
     addExpressMiddleware<R extends Request, S extends Response, AOUT extends FlatObject = EmptyObject>(...params: ConstructorParameters<typeof ExpressMiddleware<R, S, AOUT>>): EndpointsFactory<IN, OUT & AOUT, SCO>;
     addOptions<AOUT extends FlatObject>(getOptions: () => Promise<AOUT>): EndpointsFactory<IN, OUT & AOUT, SCO>;
-    build<BOUT extends IOSchema, BIN extends IOSchema = EmptySchema>({ input, output: outputSchema, operationId, scope, tag, method, ...rest }: BuildProps<BIN, BOUT, IN, OUT, SCO>): Endpoint<z.ZodIntersection<IN, BIN>, BOUT, OUT>;
+    build<BOUT extends IOSchema, BIN extends IOSchema = EmptySchema>({ input, // @todo revisit
+    output: outputSchema, operationId, scope, tag, method, ...rest }: BuildProps<BIN, BOUT, IN, OUT, SCO>): Endpoint<z.ZodIntersection<IN, BIN>, BOUT, OUT>;
     /** @desc shorthand for returning {} while having output schema z.object({}) */
-    buildVoid<BIN extends IOSchema = EmptySchema>({ handler, ...rest }: Omit<BuildProps<BIN, z.ZodVoid, IN, OUT, SCO>, "output">): Endpoint<z.ZodIntersection<IN, BIN>, z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, OUT>;
+    buildVoid<BIN extends IOSchema = EmptySchema>({ handler, ...rest }: Omit<BuildProps<BIN, z.ZodVoid, IN, OUT, SCO>, "output">): Endpoint<z.ZodIntersection<IN, BIN>, z.ZodObject<{}, z.core.$strip>, OUT>;
 }
-declare const defaultEndpointsFactory: EndpointsFactory<EmptySchema, EmptyObject, string>;
+declare const defaultEndpointsFactory: EndpointsFactory<EmptySchema, Record<string, never>, string>;
 /**
  * @deprecated Resist the urge of using it: this factory is designed only to simplify the migration of legacy APIs.
  * @desc Responding with array is a bad practice keeping your endpoints from evolving without breaking changes.
  * @desc The result handler of this factory expects your endpoint to have the property 'items' in the output schema
  */
-declare const arrayEndpointsFactory: EndpointsFactory<EmptySchema, EmptyObject, string>;
+declare const arrayEndpointsFactory: EndpointsFactory<EmptySchema, Record<string, never>, string>;
 
 declare const attachRouting: (config: AppConfig, routing: Routing) => {
     notFoundHandler: express__default.RequestHandler<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>;
@@ -728,47 +670,21 @@ declare const createServer: (config: ServerConfig, routing: Routing) => Promise<
     servers: (http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | https.Server<typeof http.IncomingMessage, typeof http.ServerResponse>)[];
 }>;
 
-declare const variants: {
-    buffer: () => z.ZodBranded<z.ZodType<Buffer<ArrayBufferLike>, z.ZodTypeDef, Buffer<ArrayBufferLike>>, symbol>;
-    string: () => z.ZodBranded<z.ZodString, symbol>;
-    binary: () => z.ZodBranded<z.ZodUnion<[z.ZodType<Buffer<ArrayBufferLike>, z.ZodTypeDef, Buffer<ArrayBufferLike>>, z.ZodString]>, symbol>;
-    base64: () => z.ZodBranded<z.ZodString, symbol>;
-};
-type Variants = typeof variants;
-type Variant = keyof Variants;
-declare function file(): ReturnType<Variants["string"]>;
-declare function file<K extends Variant>(variant: K): ReturnType<Variants[K]>;
-
-declare const ez: {
-    dateIn: () => zod.ZodBranded<zod.ZodPipeline<zod.ZodEffects<zod.ZodUnion<[zod.ZodString, zod.ZodString, zod.ZodString]>, Date, string>, zod.ZodEffects<zod.ZodDate, Date, Date>>, symbol>;
-    dateOut: () => zod.ZodBranded<zod.ZodEffects<zod.ZodEffects<zod.ZodDate, Date, Date>, string, Date>, symbol>;
-    form: <S extends zod.ZodRawShape>(base: S | zod.ZodObject<S>) => zod.ZodBranded<zod.ZodObject<S, zod.UnknownKeysParam, zod.ZodTypeAny, zod.objectUtil.addQuestionMarks<zod.baseObjectOutputType<S>, any> extends infer T ? { [k in keyof T]: zod.objectUtil.addQuestionMarks<zod.baseObjectOutputType<S>, any>[k]; } : never, zod.baseObjectInputType<S> extends infer T_1 ? { [k_1 in keyof T_1]: zod.baseObjectInputType<S>[k_1]; } : never>, symbol>;
-    file: typeof file;
-    upload: () => zod.ZodBranded<zod.ZodType<express_fileupload.UploadedFile, zod.ZodTypeDef, express_fileupload.UploadedFile>, symbol>;
-    raw: typeof raw;
-};
-
-interface NextHandlerInc<U> {
-    next: (schema: z.ZodTypeAny) => U;
-}
-interface PrevInc<U> {
-    prev: U;
-}
-type SchemaHandler<U, Context extends FlatObject = EmptyObject, Variant extends "regular" | "each" | "last" = "regular"> = (schema: any, // eslint-disable-line @typescript-eslint/no-explicit-any -- for assignment compatibility
-ctx: Context & (Variant extends "regular" ? NextHandlerInc<U> : Variant extends "each" ? PrevInc<U> : Context)) => U;
-type HandlingRules<U, Context extends FlatObject = EmptyObject, K extends string | symbol = string | symbol> = Partial<Record<K, SchemaHandler<U, Context>>>;
-
-type NumericRange = Record<"integer" | "float", [number, number]>;
-interface OpenAPIContext extends FlatObject {
-    isResponse: boolean;
-    makeRef: (schema: z.ZodTypeAny, subject: SchemaObject | ReferenceObject | (() => SchemaObject | ReferenceObject), name?: string) => ReferenceObject;
-    numericRange?: NumericRange | null;
+interface ReqResCommons {
+    makeRef: (key: object, subject: SchemaObject | ReferenceObject, name?: string) => ReferenceObject;
     path: string;
     method: Method;
 }
-type Depicter = SchemaHandler<SchemaObject | ReferenceObject, OpenAPIContext>;
+interface OpenAPIContext extends ReqResCommons {
+    isResponse: boolean;
+}
+type Depicter = (zodCtx: {
+    zodSchema: $ZodType;
+    jsonSchema: JSONSchema.BaseSchema;
+}, oasCtx: OpenAPIContext) => JSONSchema.BaseSchema | SchemaObject;
 /** @desc Using defaultIsHeader when returns null or undefined */
 type IsHeader = (name: string, method: Method, path: string) => boolean | null | undefined;
+type BrandHandling = Record<string | symbol, Depicter>;
 declare const depictTags: (tags: Partial<Record<Tag, string | {
     description: string;
     url?: string;
@@ -793,21 +709,15 @@ interface DocumentationParams {
     descriptions?: Partial<Record<Component, Descriptor>>;
     /** @default true */
     hasSummaryFromDescription?: boolean;
-    /**
-     * @desc Acceptable limits of z.number() that API can handle (default: the limits of JavaScript engine)
-     * @default {integer:[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER], float:[-Number.MAX_VALUE, Number.MAX_VALUE]}
-     * @example null — to disable the feature
-     * @see depictNumber */
-    numericRange?: NumericRange | null;
     /** @default inline */
     composition?: "inline" | "components";
     /**
      * @desc Handling rules for your own branded schemas.
      * @desc Keys: brands (recommended to use unique symbols).
      * @desc Values: functions having schema as first argument that you should assign type to, second one is a context.
-     * @example { MyBrand: ( schema: typeof myBrandSchema, { next } ) => ({ type: "object" })
+     * @example { MyBrand: ( { zodSchema, jsonSchema } ) => ({ type: "object" })
      */
-    brandHandling?: HandlingRules<SchemaObject | ReferenceObject, OpenAPIContext>;
+    brandHandling?: BrandHandling;
     /**
      * @desc Ability to configure recognition of headers among other input data
      * @desc Only applicable when "headers" is present within inputSources config option
@@ -824,7 +734,7 @@ interface DocumentationParams {
 }
 declare class Documentation extends OpenApiBuilder {
     #private;
-    constructor({ routing, config, title, version, serverUrl, descriptions, brandHandling, tags, isHeader, numericRange, hasSummaryFromDescription, composition, }: DocumentationParams);
+    constructor({ routing, config, title, version, serverUrl, descriptions, brandHandling, tags, isHeader, hasSummaryFromDescription, composition, }: DocumentationParams);
 }
 
 /** @desc An error related to the wrong Routing declaration */
@@ -917,13 +827,19 @@ declare abstract class IntegrationBase {
     protected constructor(serverUrl: string);
 }
 
+interface NextHandlerInc<U> {
+    next: (schema: $ZodType) => U;
+}
+interface PrevInc<U> {
+    prev: U;
+}
+type SchemaHandler<U, Context extends FlatObject = EmptyObject, Variant extends "regular" | "each" | "last" = "regular"> = (schema: any, // eslint-disable-line @typescript-eslint/no-explicit-any -- for assignment compatibility
+ctx: Context & (Variant extends "regular" ? NextHandlerInc<U> : Variant extends "each" ? PrevInc<U> : Context)) => U;
+type HandlingRules<U, Context extends FlatObject = EmptyObject, K extends string | symbol = string | symbol> = Partial<Record<K, SchemaHandler<U, Context>>>;
+
 interface ZTSContext extends FlatObject {
     isResponse: boolean;
-    makeAlias: (schema: z.ZodTypeAny, produce: () => ts.TypeNode) => ts.TypeNode;
-    optionalPropStyle: {
-        withQuestionMark?: boolean;
-        withUndefined?: boolean;
-    };
+    makeAlias: (key: object, produce: () => ts.TypeNode) => ts.TypeNode;
 }
 type Producer = SchemaHandler<ts.TypeNode, ZTSContext>;
 
@@ -945,27 +861,11 @@ interface IntegrationParams {
      * @default https://example.com
      * */
     serverUrl?: string;
-    /**
-     * @desc configures the style of object's optional properties
-     * @default { withQuestionMark: true, withUndefined: true }
-     */
-    optionalPropStyle?: {
-        /**
-         * @desc add question mark to the optional property definition
-         * @example { someProp?: boolean }
-         * */
-        withQuestionMark?: boolean;
-        /**
-         * @desc add undefined to the property union type
-         * @example { someProp: boolean | undefined }
-         */
-        withUndefined?: boolean;
-    };
     /**
      * @desc The schema to use for responses without body such as 204
      * @default z.undefined()
      * */
-    noContent?: z.ZodTypeAny;
+    noContent?: z.ZodType;
     /**
      * @desc Handling rules for your own branded schemas.
      * @desc Keys: brands (recommended to use unique symbols).
@@ -985,12 +885,12 @@ interface FormattedPrintingOptions {
 }
 declare class Integration extends IntegrationBase {
     #private;
-    constructor({ routing, brandHandling, variant, clientClassName, subscriptionClassName, serverUrl, optionalPropStyle, noContent, }: IntegrationParams);
+    constructor({ routing, brandHandling, variant, clientClassName, subscriptionClassName, serverUrl, noContent, }: IntegrationParams);
     print(printerOptions?: ts.PrinterOptions): string;
     printFormatted({ printerOptions, format: userDefined, }?: FormattedPrintingOptions): Promise<string>;
 }
 
-type EventsMap = Record<string, z.ZodTypeAny>;
+type EventsMap = Record<string, z.ZodType>;
 interface Emitter<E extends EventsMap> extends FlatObject {
     /** @desc Returns true when the connection was closed or terminated */
     isClosed: () => boolean;
@@ -1001,4 +901,44 @@ declare class EventStreamFactory<E extends EventsMap> extends EndpointsFactory<E
     constructor(events: E);
 }
 
-export { type ApiResponse, type AppConfig, type BasicSecurity, type BearerSecurity, BuiltinLogger, type CommonConfig, type CookieSecurity, DependsOnMethod, type Depicter, Documentation, DocumentationError, EndpointsFactory, EventStreamFactory, type FlatObject, type HeaderSecurity, type IOSchema, type InputSecurity, InputValidationError, Integration, type LoggerOverrides, type Method, Middleware, MissingPeerError, type OAuth2Security, type OpenIdSecurity, OutputValidationError, type Producer, ResultHandler, type Routing, RoutingError, ServeStatic, type ServerConfig, type TagOverrides, arrayEndpointsFactory, arrayResultHandler, attachRouting, createConfig, createServer, defaultEndpointsFactory, defaultResultHandler, ensureHttpError, ez, getExamples, getMessageFromError, testEndpoint, testMiddleware };
+declare const variants: {
+    buffer: () => z.core.$ZodBranded<z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, symbol>;
+    string: () => z.core.$ZodBranded<z.ZodString, symbol>;
+    binary: () => z.core.$ZodBranded<z.ZodUnion<[z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, z.ZodString]>, symbol>;
+    base64: () => z.core.$ZodBranded<z.ZodBase64, symbol>;
+};
+type Variants = typeof variants;
+type Variant = keyof Variants;
+declare function file(): ReturnType<Variants["string"]>;
+declare function file<K extends Variant>(variant: K): ReturnType<Variants[K]>;
+
+declare const base: z.ZodObject<{
+    raw: z.core.$ZodBranded<z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, symbol>;
+}, z.core.$strip>;
+declare const extended: <S extends $ZodShape>(extra: S) => z.core.$ZodBranded<z.ZodObject<("raw" & keyof S extends never ? {
+    raw: z.core.$ZodBranded<z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, symbol>;
+} & S : ({
+    raw: z.core.$ZodBranded<z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, symbol>;
+} extends infer T_2 extends z.core.util.SomeObject ? { [K in keyof T_2 as K extends keyof S ? never : K]: {
+    raw: z.core.$ZodBranded<z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, symbol>;
+}[K]; } : never) & { [K_1 in keyof S]: S[K_1]; }) extends infer T ? { [k in keyof T]: ("raw" & keyof S extends never ? {
+    raw: z.core.$ZodBranded<z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, symbol>;
+} & S : ({
+    raw: z.core.$ZodBranded<z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, symbol>;
+} extends infer T_1 extends z.core.util.SomeObject ? { [K in keyof T_1 as K extends keyof S ? never : K]: {
+    raw: z.core.$ZodBranded<z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, symbol>;
+}[K]; } : never) & { [K_1 in keyof S]: S[K_1]; })[k]; } : never, z.core.$strip>, symbol>;
+/** Shorthand for z.object({ raw: ez.file("buffer") }) */
+declare function raw(): ReturnType<typeof base.brand<symbol>>;
+declare function raw<S extends $ZodShape>(extra: S): ReturnType<typeof extended<S>>;
+
+declare const ez: {
+    dateIn: () => zod_v4_core.$ZodBranded<zod_v4.ZodPipe<zod_v4.ZodPipe<zod_v4.ZodUnion<[zod_v4.ZodString, zod_v4.ZodString, zod_v4.ZodString]>, zod_v4.ZodTransform<Date, string>>, zod_v4.ZodDate>, symbol>;
+    dateOut: () => zod_v4_core.$ZodBranded<zod_v4.ZodPipe<zod_v4.ZodDate, zod_v4.ZodTransform<string, Date>>, symbol>;
+    form: <S extends zod_v4_core.$ZodShape>(base: S | zod_v4.ZodObject<S>) => zod_v4_core.$ZodBranded<zod_v4.ZodObject<{ -readonly [P in keyof S]: S[P]; }, zod_v4_core.$strip>, symbol>;
+    file: typeof file;
+    upload: () => zod_v4_core.$ZodBranded<zod_v4.ZodCustom<express_fileupload.UploadedFile, express_fileupload.UploadedFile>, symbol>;
+    raw: typeof raw;
+};
+
+export { type ApiResponse, type AppConfig, type BasicSecurity, type BearerSecurity, BuiltinLogger, type CommonConfig, type CookieSecurity, DependsOnMethod, type Depicter, Documentation, DocumentationError, EndpointsFactory, EventStreamFactory, type FlatObject, type HeaderSecurity, type IOSchema, type InputSecurity, InputValidationError, Integration, type LoggerOverrides, type Method, Middleware, MissingPeerError, type OAuth2Security, type OpenIdSecurity, OutputValidationError, type Producer, ResultHandler, type Routing, RoutingError, ServeStatic, type ServerConfig, type TagOverrides, arrayEndpointsFactory, arrayResultHandler, attachRouting, createConfig, createServer, defaultEndpointsFactory, defaultResultHandler, ensureHttpError, ez, getMessageFromError, testEndpoint, testMiddleware };