feat: add number base resolvers

dev/openapi-ts.config.ts

···
             },
           },
           '~resolvers': {
+            number: {
+              // base({ $, pipes, v }) {
+              //   return pipes.push($(v).attr('test').call());
+              // },
+              formats: {
+                // date: ({ $, pipes }) => pipes.push($('v').attr('isoDateTime').call()),
+                // 'date-time': ({ $, pipes }) => pipes.push($('v').attr('isoDateTime').call()),
+              },
+            },
             object: {
               // base({ $, additional, pipes, shape }) {
               //   if (additional === undefined) {

packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/valibot/default/valibot.gen.ts

···
 });
 
 export const vPageable = v.object({
-    page: v.optional(v.pipe(v.number(), v.integer(), v.minValue(-2147483648, 'Invalid value: Expected int32 to be >= -2147483648'), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'), v.minValue(0)), 0),
-    size: v.optional(v.pipe(v.number(), v.integer(), v.minValue(-2147483648, 'Invalid value: Expected int32 to be >= -2147483648'), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'), v.minValue(1))),
+    page: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647')), 0),
+    size: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'))),
     sort: v.optional(v.array(v.string()))
 });
 
···
         }), v.strictObject({
             bar: vNonAsciiStringæøåÆøÅöôêÊ字符串
         })]), v.object({
-        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint16 to be >= 0'), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535'), v.minValue(0)), v.null()]),
-        qux: v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint8 to be >= 0'), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'), v.minValue(0))
+        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535')), v.null()]),
+        qux: v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'))
     })]);
 
 export const vModelWithOneOfAndProperties = v.intersect([v.union([vSimpleParameter, vNonAsciiStringæøåÆøÅöôêÊ字符串]), v.object({
-        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint16 to be >= 0'), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535'), v.minValue(0)), v.null()]),
-        qux: v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint8 to be >= 0'), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'), v.minValue(0))
+        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535')), v.null()]),
+        qux: v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'))
     })]);
 
 /**

packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/valibot/default/valibot.gen.ts

···
 });
 
 export const vPageable = v.object({
-    page: v.optional(v.pipe(v.number(), v.integer(), v.minValue(-2147483648, 'Invalid value: Expected int32 to be >= -2147483648'), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'), v.minValue(0)), 0),
-    size: v.optional(v.pipe(v.number(), v.integer(), v.minValue(-2147483648, 'Invalid value: Expected int32 to be >= -2147483648'), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'), v.minValue(1))),
+    page: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647')), 0),
+    size: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(2147483647, 'Invalid value: Expected int32 to be <= 2147483647'))),
     sort: v.optional(v.array(v.string()))
 });
 
···
         }), v.strictObject({
             bar: vNonAsciiStringæøåÆøÅöôêÊ字符串
         })]), v.object({
-        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint16 to be >= 0'), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535'), v.minValue(0)), v.null()]),
-        qux: v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint8 to be >= 0'), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'), v.minValue(0))
+        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535')), v.null()]),
+        qux: v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'))
     })]);
 
 export const vModelWithOneOfAndProperties = v.intersect([v.union([vSimpleParameter, vNonAsciiStringæøåÆøÅöôêÊ字符串]), v.object({
-        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint16 to be >= 0'), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535'), v.minValue(0)), v.null()]),
-        qux: v.pipe(v.number(), v.integer(), v.minValue(0, 'Invalid value: Expected uint8 to be >= 0'), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'), v.minValue(0))
+        baz: v.union([v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(65535, 'Invalid value: Expected uint16 to be <= 65535')), v.null()]),
+        qux: v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(255, 'Invalid value: Expected uint8 to be <= 255'))
     })]);
 
 /**

packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/validators-bigint-min-max/valibot.gen.ts

···
         v.number(),
         v.string(),
         v.bigint()
-    ]), v.transform(x => BigInt(x)), v.minValue(BigInt('-9223372036854775808'), 'Invalid value: Expected int64 to be >= -9223372036854775808'), v.maxValue(BigInt('9223372036854775807'), 'Invalid value: Expected int64 to be <= 9223372036854775807'), v.minValue(BigInt(0)), v.maxValue(BigInt(100))))
+    ]), v.transform(x => BigInt(x)), v.minValue(BigInt(0)), v.maxValue(BigInt(100))))
 });

packages/openapi-ts-tests/zod/v3/__snapshots__/3.0.x/mini/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z._default(z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(0))), 0),
-    size: z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(1))),
+    page: z._default(z.optional(z.int().check(z.gte(0), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 0),
+    size: z.optional(z.int().check(z.gte(1), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 /**

packages/openapi-ts-tests/zod/v3/__snapshots__/3.0.x/v3/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0).optional().default(0),
-    size: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1).optional(),
+    page: z.number().int().gte(0).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional().default(0),
+    size: z.number().int().gte(1).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(),
     sort: z.array(z.string()).optional()
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v3/__snapshots__/3.0.x/v4/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0)).default(0),
-    size: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1)),
+    page: z.optional(z.int().gte(0).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(0),
+    size: z.optional(z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/mini/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z._default(z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(0))), 0),
-    size: z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(1))),
+    page: z._default(z.optional(z.int().check(z.gte(0), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 0),
+    size: z.optional(z.int().check(z.gte(1), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 /**

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/mini/validators-bigint-min-max/zod.gen.ts

···
 import * as z from 'zod/v4-mini';
 
 export const zFoo = z.object({
-    foo: z.optional(z.coerce.bigint().check(z.minimum(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }), z.maximum(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }), z.gte(BigInt(0)), z.lte(BigInt(100))))
+    foo: z.optional(z.coerce.bigint().check(z.gte(BigInt(0)), z.lte(BigInt(100))))
 });

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/v3/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0).optional().default(0),
-    size: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1).optional(),
+    page: z.number().int().gte(0).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional().default(0),
+    size: z.number().int().gte(1).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(),
     sort: z.array(z.string()).optional()
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/v3/validators-bigint-min-max/zod.gen.ts

···
 import { z } from 'zod';
 
 export const zFoo = z.object({
-    foo: z.coerce.bigint().min(BigInt('-9223372036854775808'), { message: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { message: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).gte(BigInt(0)).lte(BigInt(100)).optional()
+    foo: z.coerce.bigint().gte(BigInt(0)).lte(BigInt(100)).optional()
 });

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/v4/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0)).default(0),
-    size: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1)),
+    page: z.optional(z.int().gte(0).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(0),
+    size: z.optional(z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v3/__snapshots__/3.1.x/v4/validators-bigint-min-max/zod.gen.ts

···
 import { z } from 'zod/v4';
 
 export const zFoo = z.object({
-    foo: z.optional(z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).gte(BigInt(0)).lte(BigInt(100)))
+    foo: z.optional(z.coerce.bigint().gte(BigInt(0)).lte(BigInt(100)))
 });

packages/openapi-ts-tests/zod/v4/__snapshots__/3.0.x/mini/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z._default(z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(0))), 0),
-    size: z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(1))),
+    page: z._default(z.optional(z.int().check(z.gte(0), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 0),
+    size: z.optional(z.int().check(z.gte(1), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 /**

packages/openapi-ts-tests/zod/v4/__snapshots__/3.0.x/v3/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0).optional().default(0),
-    size: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1).optional(),
+    page: z.number().int().gte(0).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional().default(0),
+    size: z.number().int().gte(1).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(),
     sort: z.array(z.string()).optional()
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v4/__snapshots__/3.0.x/v4/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0)).default(0),
-    size: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1)),
+    page: z.optional(z.int().gte(0).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(0),
+    size: z.optional(z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/mini/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z._default(z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(0))), 0),
-    size: z.optional(z.int().check(z.minimum(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }), z.gte(1))),
+    page: z._default(z.optional(z.int().check(z.gte(0), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))), 0),
+    size: z.optional(z.int().check(z.gte(1), z.maximum(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }))),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint16 to be >= 0' }), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }), z.gte(0)),
+        z.int().check(z.gte(0), z.maximum(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' })),
         z.null()
     ]),
-    qux: z.int().check(z.minimum(0, { error: 'Invalid value: Expected uint8 to be >= 0' }), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }), z.gte(0))
+    qux: z.int().check(z.gte(0), z.maximum(255, { error: 'Invalid value: Expected uint8 to be <= 255' }))
 }));
 
 /**

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/mini/validators-bigint-min-max/zod.gen.ts

···
 import * as z from 'zod/mini';
 
 export const zFoo = z.object({
-    foo: z.optional(z.coerce.bigint().check(z.minimum(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }), z.maximum(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }), z.gte(BigInt(0)), z.lte(BigInt(100))))
+    foo: z.optional(z.coerce.bigint().check(z.gte(BigInt(0)), z.lte(BigInt(100))))
 });

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/v3/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0).optional().default(0),
-    size: z.number().int().min(-2147483648, { message: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1).optional(),
+    page: z.number().int().gte(0).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional().default(0),
+    size: z.number().int().gte(1).max(2147483647, { message: 'Invalid value: Expected int32 to be <= 2147483647' }).optional(),
     sort: z.array(z.string()).optional()
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.number().int().min(0, { message: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.number().int().gte(0).max(65535, { message: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.number().int().min(0, { message: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.number().int().gte(0).max(255, { message: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/v3/validators-bigint-min-max/zod.gen.ts

···
 import { z } from 'zod/v3';
 
 export const zFoo = z.object({
-    foo: z.coerce.bigint().min(BigInt('-9223372036854775808'), { message: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { message: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).gte(BigInt(0)).lte(BigInt(100)).optional()
+    foo: z.coerce.bigint().gte(BigInt(0)).lte(BigInt(100)).optional()
 });

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/v4/default/zod.gen.ts

···
 });
 
 export const zPageable = z.object({
-    page: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(0)).default(0),
-    size: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }).gte(1)),
+    page: z.optional(z.int().gte(0).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(0),
+    size: z.optional(z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })),
     sort: z.optional(z.array(z.string()))
 });
 
···
     })
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
     zNonAsciiStringæøåÆøÅöôêÊ字符串
 ]), z.object({
     baz: z.union([
-        z.int().min(0, { error: 'Invalid value: Expected uint16 to be >= 0' }).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }).gte(0),
+        z.int().gte(0).max(65535, { error: 'Invalid value: Expected uint16 to be <= 65535' }),
         z.null()
     ]),
-    qux: z.int().min(0, { error: 'Invalid value: Expected uint8 to be >= 0' }).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' }).gte(0)
+    qux: z.int().gte(0).max(255, { error: 'Invalid value: Expected uint8 to be <= 255' })
 }));
 
 /**

packages/openapi-ts-tests/zod/v4/__snapshots__/3.1.x/v4/validators-bigint-min-max/zod.gen.ts

···
 import { z } from 'zod';
 
 export const zFoo = z.object({
-    foo: z.optional(z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).gte(BigInt(0)).lte(BigInt(100)))
+    foo: z.optional(z.coerce.bigint().gte(BigInt(0)).lte(BigInt(100)))
 });

packages/openapi-ts/src/plugins/valibot/types.d.ts

···
    */
   pipes: Array<ReturnType<typeof $.call>>;
   plugin: ValibotPlugin['Instance'];
+  v: Symbol;
 };
 
 export type FormatResolverArgs = SharedResolverArgs & {
···
   schema: IR.SchemaObject;
   shape: ReturnType<typeof $.object>;
 };
+
+type ResolverResult = boolean | number;
 
 export type ValidatorResolverArgs = SharedResolverArgs & {
   operation: IR.Operation;
   schema: Symbol;
-  v: Symbol;
 };
 
 type ValidatorResolver = (
···
    */
   number?: {
     /**
+     * Controls the base segment for number schemas.
+     *
+     * Returning `undefined` will execute the default resolver logic.
+     */
+    base?: (args: FormatResolverArgs) => ResolverResult | undefined;
+    /**
      * Resolvers for number formats (e.g., `float`, `double`, `int32`).
      *
      * Each key represents a specific format name with a custom
···
      */
     formats?: Record<
       string,
-      (args: FormatResolverArgs) => boolean | number | undefined
+      (args: FormatResolverArgs) => ResolverResult | undefined
     >;
   };
   /**
···
      *
      * Returning `undefined` will execute the default resolver logic.
      */
-    base?: (
-      args: ObjectBaseResolverArgs,
-    ) => ReturnType<typeof $.call> | undefined;
+    base?: (args: ObjectBaseResolverArgs) => ResolverResult | undefined;
   };
   /**
    * Resolvers for string schemas.
···
      */
     formats?: Record<
       string,
-      (args: FormatResolverArgs) => boolean | number | undefined
+      (args: FormatResolverArgs) => ResolverResult | undefined
     >;
   };
   /**

packages/openapi-ts/src/plugins/valibot/v1/toAst/number.ts

···
 
 import { pipesToAst } from '../../shared/pipesToAst';
 import type { IrSchemaToAstOptions } from '../../shared/types';
+import type { FormatResolverArgs } from '../../types';
 import { identifiers } from '../constants';
 
-export const numberToAst = ({
-  plugin,
+const defaultBaseResolver = ({
+  pipes,
   schema,
-}: IrSchemaToAstOptions & {
-  schema: SchemaWithType<'integer' | 'number'>;
-}) => {
-  const v = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'valibot.v',
-  });
-
-  if (schema.const !== undefined) {
-    return $(v)
-      .attr(identifiers.schemas.literal)
-      .call(maybeBigInt(schema.const, schema.format));
-  }
-
-  const pipes: Array<ReturnType<typeof $.call>> = [];
-
+  v,
+}: FormatResolverArgs): boolean | number => {
   if (shouldCoerceToBigInt(schema.format)) {
     pipes.push(
       $(v)
···
       pipes.push($(v).attr(identifiers.actions.integer).call());
     }
   }
+
+  return true;
+};
+
+export const numberToAst = ({
+  plugin,
+  schema,
+}: IrSchemaToAstOptions & {
+  schema: SchemaWithType<'integer' | 'number'>;
+}) => {
+  const v = plugin.referenceSymbol({
+    category: 'external',
+    resource: 'valibot.v',
+  });
+
+  if (schema.const !== undefined) {
+    return $(v)
+      .attr(identifiers.schemas.literal)
+      .call(maybeBigInt(schema.const, schema.format));
+  }
+
+  const pipes: Array<ReturnType<typeof $.call>> = [];
+
+  const args: FormatResolverArgs = { $, pipes, plugin, schema, v };
+  const resolver = plugin.config['~resolvers']?.number?.base;
+  if (!resolver?.(args)) defaultBaseResolver(args);
 
   let hasLowerBound = false;
   let hasUpperBound = false;

packages/openapi-ts/src/plugins/valibot/v1/toAst/object.ts

···
 import { identifiers } from '../constants';
 import { irSchemaToAst } from '../plugin';
 
-function defaultObjectBaseResolver({
+function defaultBaseResolver({
   additional,
   pipes,
-  plugin,
   shape,
+  v,
 }: ObjectBaseResolverArgs): number {
-  const v = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'valibot.v',
-  });
-
   // Handle `additionalProperties: { type: 'never' }` → v.strictObject()
   if (additional === null) {
     return pipes.push($(v).attr(identifiers.schemas.strictObject).call(shape));
···
 }: IrSchemaToAstOptions & {
   schema: SchemaWithType<'object'>;
 }): Omit<Ast, 'typeName'> => {
+  const v = plugin.referenceSymbol({
+    category: 'external',
+    resource: 'valibot.v',
+  });
+
   const result: Partial<Omit<Ast, 'typeName'>> = {};
   const pipes: Array<ReturnType<typeof $.call>> = [];
 
···
     plugin,
     schema,
     shape,
+    v,
   };
   const resolver = plugin.config['~resolvers']?.object?.base;
-  if (!resolver?.(args)) defaultObjectBaseResolver(args);
+  if (!resolver?.(args)) defaultBaseResolver(args);
 
   result.pipes = [pipesToAst(pipes, plugin)];
   return result as Omit<Ast, 'typeName'>;

packages/openapi-ts/src/plugins/valibot/v1/toAst/string.ts

···
 
 const defaultFormatResolver = ({
   pipes,
-  plugin,
   schema,
+  v,
 }: FormatResolverArgs): boolean | number => {
-  const v = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'valibot.v',
-  });
-
   switch (schema.format) {
     case 'date':
       return pipes.push($(v).attr(identifiers.actions.isoDate).call());
···
   const pipes = [$(v).attr(identifiers.schemas.string).call()];
 
   if (schema.format) {
-    const args: FormatResolverArgs = { $, pipes, plugin, schema };
+    const args: FormatResolverArgs = { $, pipes, plugin, schema, v };
     const resolver =
       plugin.config['~resolvers']?.string?.formats?.[schema.format];
     if (!resolver?.(args)) defaultFormatResolver(args);

packages/openapi-ts/src/plugins/zod/mini/api.ts

···
   });
   if (!symbol) return;
 
+  const z = plugin.referenceSymbol({
+    category: 'external',
+    resource: 'zod.z',
+  });
   const args: ValidatorResolverArgs = {
     $,
     chain: undefined,
     operation,
     plugin,
     schema: symbol,
+    z,
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
···
   });
   if (!symbol) return;
 
+  const z = plugin.referenceSymbol({
+    category: 'external',
+    resource: 'zod.z',
+  });
   const args: ValidatorResolverArgs = {
     $,
     chain: undefined,
     operation,
     plugin,
     schema: symbol,
+    z,
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =

packages/openapi-ts/src/plugins/zod/mini/toAst/object.ts

···
 import type { ObjectBaseResolverArgs } from '../../types';
 import { irSchemaToAst } from '../plugin';
 
-function defaultObjectBaseResolver({
+function defaultBaseResolver({
   additional,
-  plugin,
   shape,
+  z,
 }: ObjectBaseResolverArgs): ReturnType<typeof $.call> {
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-
   if (additional) {
     return $(z)
       .attr(identifiers.record)
···
 }: IrSchemaToAstOptions & {
   schema: SchemaWithType<'object'>;
 }): Omit<Ast, 'typeName'> => {
+  const z = plugin.referenceSymbol({
+    category: 'external',
+    resource: 'zod.z',
+  });
+
   const result: Partial<Omit<Ast, 'typeName'>> = {};
 
   // TODO: parser - handle constants
···
     plugin,
     schema,
     shape,
+    z,
   };
   const resolver = plugin.config['~resolvers']?.object?.base;
-  const chain = resolver?.(args) ?? defaultObjectBaseResolver(args);
+  const chain = resolver?.(args) ?? defaultBaseResolver(args);
   result.expression = chain;
 
   return result as Omit<Ast, 'typeName'>;

packages/openapi-ts/src/plugins/zod/mini/toAst/string.ts

···
   chain = $(z).attr(identifiers.string).call();
 
   if (schema.format) {
-    const args: FormatResolverArgs = { $, chain, plugin, schema };
+    const args: FormatResolverArgs = { $, chain, plugin, schema, z };
     const resolver =
       plugin.config['~resolvers']?.string?.formats?.[schema.format];
     chain = resolver?.(args) ?? defaultFormatResolver(args);

packages/openapi-ts/src/plugins/zod/types.d.ts

···
    */
   chain?: ReturnType<typeof $.call>;
   plugin: ZodPlugin['Instance'];
+  z: Symbol;
 };
 
 export type FormatResolverArgs = Required<SharedResolverArgs> & {
···
   schema: IR.SchemaObject;
   shape: ReturnType<typeof $.object>;
 };
+
+type ResolverResult = boolean | number;
 
 export type ValidatorResolverArgs = SharedResolverArgs & {
   operation: IR.Operation;
···
    */
   number?: {
     /**
+     * Controls the base segment for number schemas.
+     *
+     * Returning `undefined` will execute the default resolver logic.
+     */
+    base?: (args: FormatResolverArgs) => ResolverResult | undefined;
+    /**
      * Resolvers for number formats (e.g., `float`, `double`, `int32`).
      *
      * Each key represents a specific format name with a custom
···
      */
     formats?: Record<
       string,
-      (args: FormatResolverArgs) => boolean | number | undefined
+      (args: FormatResolverArgs) => ResolverResult | undefined
     >;
   };
   /**

packages/openapi-ts/src/plugins/zod/v3/api.ts

···
   });
   if (!symbol) return;
 
+  const z = plugin.referenceSymbol({
+    category: 'external',
+    resource: 'zod.z',
+  });
   const args: ValidatorResolverArgs = {
     $,
     chain: undefined,
     operation,
     plugin,
     schema: symbol,
+    z,
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
···
   });
   if (!symbol) return;
 
+  const z = plugin.referenceSymbol({
+    category: 'external',
+    resource: 'zod.z',
+  });
   const args: ValidatorResolverArgs = {
     $,
     chain: undefined,
     operation,
     plugin,
     schema: symbol,
+    z,
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =

packages/openapi-ts/src/plugins/zod/v3/toAst/object.ts

···
 import type { ObjectBaseResolverArgs } from '../../types';
 import { irSchemaToAst } from '../plugin';
 
-function defaultObjectBaseResolver({
+function defaultBaseResolver({
   additional,
-  plugin,
   shape,
+  z,
 }: ObjectBaseResolverArgs): ReturnType<typeof $.call> {
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-
   if (additional) {
     return $(z).attr(identifiers.record).call(additional);
   }
···
 }): Omit<Ast, 'typeName'> & {
   anyType?: string;
 } => {
+  const z = plugin.referenceSymbol({
+    category: 'external',
+    resource: 'zod.z',
+  });
+
   let hasLazyExpression = false;
 
   // TODO: parser - handle constants
···
     plugin,
     schema,
     shape,
+    z,
   };
   const resolver = plugin.config['~resolvers']?.object?.base;
-  const chain = resolver?.(args) ?? defaultObjectBaseResolver(args);
+  const chain = resolver?.(args) ?? defaultBaseResolver(args);
   result.expression = chain;
 
   return {

packages/openapi-ts/src/plugins/zod/v3/toAst/string.ts

···
   chain = $(z).attr(identifiers.string).call();
 
   if (schema.format) {
-    const args: FormatResolverArgs = { $, chain, plugin, schema };
+    const args: FormatResolverArgs = { $, chain, plugin, schema, z };
     const resolver =
       plugin.config['~resolvers']?.string?.formats?.[schema.format];
     chain = resolver?.(args) ?? defaultFormatResolver(args);

packages/openapi-ts/src/plugins/zod/v4/api.ts

···
   });
   if (!symbol) return;
 
+  const z = plugin.referenceSymbol({
+    category: 'external',
+    resource: 'zod.z',
+  });
   const args: ValidatorResolverArgs = {
     $,
     chain: undefined,
     operation,
     plugin,
     schema: symbol,
+    z,
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =
···
   });
   if (!symbol) return;
 
+  const z = plugin.referenceSymbol({
+    category: 'external',
+    resource: 'zod.z',
+  });
   const args: ValidatorResolverArgs = {
     $,
     chain: undefined,
     operation,
     plugin,
     schema: symbol,
+    z,
   };
   const validator = plugin.config['~resolvers']?.validator;
   const resolver =

packages/openapi-ts/src/plugins/zod/v4/toAst/object.ts

···
 import type { ObjectBaseResolverArgs } from '../../types';
 import { irSchemaToAst } from '../plugin';
 
-function defaultObjectBaseResolver({
+function defaultBaseResolver({
   additional,
-  plugin,
   shape,
+  z,
 }: ObjectBaseResolverArgs): ReturnType<typeof $.call> {
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-
   if (additional) {
     return $(z)
       .attr(identifiers.record)
···
 }: IrSchemaToAstOptions & {
   schema: SchemaWithType<'object'>;
 }): Omit<Ast, 'typeName'> => {
+  const z = plugin.referenceSymbol({
+    category: 'external',
+    resource: 'zod.z',
+  });
+
   const result: Partial<Omit<Ast, 'typeName'>> = {};
 
   // TODO: parser - handle constants
···
     plugin,
     schema,
     shape,
+    z,
   };
   const resolver = plugin.config['~resolvers']?.object?.base;
-  const chain = resolver?.(args) ?? defaultObjectBaseResolver(args);
+  const chain = resolver?.(args) ?? defaultBaseResolver(args);
   result.expression = chain;
 
   // Return with typeName for circular references

packages/openapi-ts/src/plugins/zod/v4/toAst/string.ts

···
   chain,
   plugin,
   schema,
+  z,
 }: FormatResolverArgs): ReturnType<typeof $.call> => {
-  const z = plugin.referenceSymbol({
-    category: 'external',
-    resource: 'zod.z',
-  });
-
   switch (schema.format) {
     case 'date':
       return $(z).attr(identifiers.iso).attr(identifiers.date).call();
···
   chain = $(z).attr(identifiers.string).call();
 
   if (schema.format) {
-    const args: FormatResolverArgs = { $, chain, plugin, schema };
+    const args: FormatResolverArgs = { $, chain, plugin, schema, z };
     const resolver =
       plugin.config['~resolvers']?.string?.formats?.[schema.format];
     chain = resolver?.(args) ?? defaultFormatResolver(args);