typed-bridge 2.0.14 → 2.1.0

package/dist/bridge/index.js

@@ -27,7 +27,8 @@ const createBridge = (bridge, port, path = '/bridge') => {
     app.use(express_1.default.json());
     app.use(express_1.default.urlencoded({ extended: true }));
     // Typed bridge middleware
-    let requestId = 1;
+    let requestId = 0;
+    let activeRequests = 0;
     app.use((req, res, next) => {
         const _req = req;
         const xForwardedFor = req.headers['x-forwarded-for'];
@@ -36,16 +37,17 @@ const createBridge = (bridge, port, path = '/bridge') => {
             : (xForwardedFor || '').split(', ')[0] || req.socket.remoteAddress || '';
         if (ip === '::1')
             ip = '127.0.0.1';
+        // Set typed bridge header
+        res.setHeader('X-Powered-By', 'typed-bridge');
+        requestId++;
+        activeRequests++;
         // Bind data
         _req.bind = {
-            id: 0,
+            id: requestId,
             ts: Date.now(),
             args: {},
             ip
         };
-        // Set typed bridge header
-        res.setHeader('X-Powered-By', 'typed-bridge');
-        requestId++;
         // Log request
         if (__1.tbConfig.logs.request) {
             console.log(chalk_1.default.blueBright(`REQ | ${new Date().toISOString()} | ${requestId} :: ${req.method} | ${req.path} | ${ip}`));
@@ -53,6 +55,7 @@ const createBridge = (bridge, port, path = '/bridge') => {
         // Log response
         const startTime = Date.now();
         res.on('finish', () => {
+            activeRequests--;
             const log = `RES | ${new Date().toISOString()} | ${requestId} :: ${res.statusCode} | ${Date.now() - startTime}ms`;
             if (__1.tbConfig.logs.response)
                 console.log(res.statusCode < 400 ? chalk_1.default.green(log) : chalk_1.default.red(log));
@@ -72,20 +75,26 @@ const createBridge = (bridge, port, path = '/bridge') => {
         app.use((req, res, next) => {
             setTimeout(next, __1.tbConfig.responseDelay);
         });
-    app.use(path, bridgeHandler(bridge));
     // Server health
     app.get(path_1.default.join(path, 'health'), (req, res) => {
-        res.status(200).json({ status: 'OK' });
+        res.status(200).json({
+            status: 'OK',
+            activeRequests: activeRequests - 1,
+            totalRequests: requestId,
+            timestamp: new Date().toISOString()
+        });
     });
+    app.use(path, bridgeHandler(bridge));
     const server = app.listen(port, () => (0, helpers_1.printStartLogs)(port));
     let shuttingDown = false;
     const shutdown = () => {
         if (shuttingDown)
             return;
         shuttingDown = true;
-        server.close();
-        (0, helpers_1.printStopLogs)();
-        shutdownCallback();
+        server.close(() => {
+            (0, helpers_1.printStopLogs)();
+            shutdownCallback();
+        });
     };
     process.on('SIGINT', () => shutdown());
     process.on('SIGTERM', () => shutdown());
@@ -108,14 +117,15 @@ const bridgeHandler = (bridge) => async (req, res) => {
             return res.status(404).json({ error });
         }
         context = {};
-        for (const middleware of middlewares) {
-            if ((0, helpers_1.matchesPattern)(path, middleware.pattern)) {
-                const result = await middleware.handler(req, res);
-                if (result?.next === false)
-                    return;
-                if (result?.context)
-                    context = { ...context, ...result.context };
-            }
+        const matchingMiddlewares = middlewares
+            .filter(m => (0, helpers_1.matchesPattern)(path, m.pattern))
+            .sort((a, b) => (0, helpers_1.getPatternSpecificity)(a.pattern) - (0, helpers_1.getPatternSpecificity)(b.pattern));
+        for (const middleware of matchingMiddlewares) {
+            const result = await middleware.handler(req, res);
+            if (result?.next === false)
+                return;
+            if (result?.context)
+                context = { ...context, ...result.context };
         }
         res.json((await serverFunction(args, context)) || {});
     }

package/dist/demo/bridge/index.d.ts

@@ -1,28 +1,198 @@
 import * as user from './user';
+import * as product from './product';
+import * as order from './order';
 declare const _default: {
-    'user.fetch': (args: import("zod").TypeOf<import("zod").ZodObject<{
+    'user.fetch': (args: import("zod").infer<import("zod").ZodObject<{
         id: import("zod").ZodNumber;
-    }, "strip", import("zod").ZodTypeAny, {
-        id: number;
-    }, {
-        id: number;
-    }>>, context: {
-        id: number;
-    }) => Promise<import("zod").TypeOf<import("zod").ZodObject<{
+    }, import("zod/v4/core").$strip>>, context: {
+        requestedAt: number;
+        userId: number;
+    }) => Promise<import("zod").infer<import("zod").ZodObject<{
         id: import("zod").ZodNumber;
         name: import("zod").ZodString;
-    }, "strip", import("zod").ZodTypeAny, {
-        id: number;
-        name: string;
-    }, {
-        id: number;
-        name: string;
-    }>>>;
+        email: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>;
+    'user.create': (args: import("zod").infer<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        email: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>, context: {
+        requestedAt: number;
+        userId: number;
+    }) => Promise<import("zod").infer<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+        name: import("zod").ZodString;
+        email: import("zod").ZodString;
+        createdAt: import("zod").ZodDate;
+    }, import("zod/v4/core").$strip>>>;
     'user.update': (args: {
         id: number;
         name?: string;
         email?: string;
+    }, context: {
+        requestedAt: number;
+        userId: number;
     }) => Promise<user.User>;
+    'user.remove': (args: {
+        id: number;
+    }, context: {
+        requestedAt: number;
+        userId: number;
+    } & {
+        isAdmin: boolean;
+    }) => Promise<{
+        success: boolean;
+    }>;
     'user.fetchAll': () => Promise<user.User[]>;
+    'product.fetch': (args: import("zod").infer<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>, context: {
+        requestedAt: number;
+        userId: number;
+    }) => Promise<import("zod").infer<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+        name: import("zod").ZodString;
+        price: import("zod").ZodNumber;
+        createdAt: import("zod").ZodDate;
+    }, import("zod/v4/core").$strip>>>;
+    'product.create': (args: import("zod").infer<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        price: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>, context: {
+        requestedAt: number;
+        userId: number;
+    }) => Promise<import("zod").infer<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+        name: import("zod").ZodString;
+        price: import("zod").ZodNumber;
+        createdAt: import("zod").ZodDate;
+    }, import("zod/v4/core").$strip>>>;
+    'product.list': () => Promise<product.Product[]>;
+    'order.create': (args: import("zod").infer<import("zod").ZodObject<{
+        customerId: import("zod").ZodNumber;
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+            productId: import("zod").ZodNumber;
+            quantity: import("zod").ZodNumber;
+            price: import("zod").ZodNumber;
+            notes: import("zod").ZodOptional<import("zod").ZodString>;
+            discount: import("zod").ZodNullable<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+        shippingAddress: import("zod").ZodObject<{
+            street: import("zod").ZodString;
+            city: import("zod").ZodString;
+            state: import("zod").ZodString;
+            zip: import("zod").ZodString;
+            country: import("zod").ZodDefault<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        billingAddress: import("zod").ZodNullable<import("zod").ZodObject<{
+            street: import("zod").ZodString;
+            city: import("zod").ZodString;
+            state: import("zod").ZodString;
+            zip: import("zod").ZodString;
+            country: import("zod").ZodDefault<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        couponCode: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        scheduledDate: import("zod").ZodOptional<import("zod").ZodDate>;
+        isGift: import("zod").ZodBoolean;
+        giftMessage: import("zod").ZodNullable<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>, context: {
+        requestedAt: number;
+        userId: number;
+    }) => Promise<import("zod").infer<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+        status: import("zod").ZodString;
+        total: import("zod").ZodNumber;
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+            productId: import("zod").ZodNumber;
+            quantity: import("zod").ZodNumber;
+            price: import("zod").ZodNumber;
+            notes: import("zod").ZodOptional<import("zod").ZodString>;
+            discount: import("zod").ZodNullable<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+        createdAt: import("zod").ZodDate;
+    }, import("zod/v4/core").$strip>>>;
+    'order.fetch': (args: import("zod").infer<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>, context: {
+        requestedAt: number;
+        userId: number;
+    }) => Promise<import("zod").infer<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+        customerId: import("zod").ZodNumber;
+        status: import("zod").ZodString;
+        total: import("zod").ZodNumber;
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+            productId: import("zod").ZodNumber;
+            quantity: import("zod").ZodNumber;
+            price: import("zod").ZodNumber;
+            notes: import("zod").ZodOptional<import("zod").ZodString>;
+            discount: import("zod").ZodNullable<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+        shippingAddress: import("zod").ZodObject<{
+            street: import("zod").ZodString;
+            city: import("zod").ZodString;
+            state: import("zod").ZodString;
+            zip: import("zod").ZodString;
+            country: import("zod").ZodDefault<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        billingAddress: import("zod").ZodNullable<import("zod").ZodObject<{
+            street: import("zod").ZodString;
+            city: import("zod").ZodString;
+            state: import("zod").ZodString;
+            zip: import("zod").ZodString;
+            country: import("zod").ZodDefault<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        isGift: import("zod").ZodBoolean;
+        giftMessage: import("zod").ZodNullable<import("zod").ZodString>;
+        createdAt: import("zod").ZodDate;
+        updatedAt: import("zod").ZodNullable<import("zod").ZodDate>;
+    }, import("zod/v4/core").$strip>>>;
+    'order.update': (args: import("zod").infer<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+        status: import("zod").ZodOptional<import("zod").ZodString>;
+        shippingAddress: import("zod").ZodOptional<import("zod").ZodObject<{
+            street: import("zod").ZodString;
+            city: import("zod").ZodString;
+            state: import("zod").ZodString;
+            zip: import("zod").ZodString;
+            country: import("zod").ZodDefault<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        giftMessage: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strip>>, context: {
+        requestedAt: number;
+        userId: number;
+    }) => Promise<import("zod").infer<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+        status: import("zod").ZodString;
+        updatedAt: import("zod").ZodDate;
+    }, import("zod/v4/core").$strip>>>;
+    'order.list': () => Promise<order.Order[]>;
+    'order.primitives': (args: import("zod").infer<import("zod").ZodObject<{
+        key: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>) => Promise<import("zod").infer<import("zod").ZodObject<{
+        str: import("zod").ZodString;
+        num: import("zod").ZodNumber;
+        bool: import("zod").ZodBoolean;
+        date: import("zod").ZodDate;
+        nul: import("zod").ZodNull;
+        undef: import("zod").ZodUndefined;
+        unk: import("zod").ZodUnknown;
+        whatever: import("zod").ZodAny;
+        optStr: import("zod").ZodOptional<import("zod").ZodString>;
+        nullStr: import("zod").ZodNullable<import("zod").ZodString>;
+        defStr: import("zod").ZodDefault<import("zod").ZodString>;
+        optNullStr: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        nullOptStr: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+        tags: import("zod").ZodArray<import("zod").ZodString>;
+        scores: import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodNumber>>;
+        optDates: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodDate>>;
+        nested: import("zod").ZodObject<{
+            a: import("zod").ZodNumber;
+            b: import("zod").ZodOptional<import("zod").ZodString>;
+            c: import("zod").ZodObject<{
+                d: import("zod").ZodBoolean;
+                e: import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>>>;
 };
 export default _default;

package/dist/demo/bridge/index.js

@@ -34,8 +34,20 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const user = __importStar(require("./user"));
+const product = __importStar(require("./product"));
+const order = __importStar(require("./order"));
 exports.default = {
     'user.fetch': user.fetch,
+    'user.create': user.create,
     'user.update': user.update,
-    'user.fetchAll': user.fetchAll
+    'user.remove': user.remove,
+    'user.fetchAll': user.fetchAll,
+    'product.fetch': product.fetch,
+    'product.create': product.create,
+    'product.list': product.list,
+    'order.create': order.create,
+    'order.fetch': order.fetch,
+    'order.update': order.update,
+    'order.list': order.list,
+    'order.primitives': order.primitives
 };

package/dist/demo/bridge/order/index.d.ts

@@ -0,0 +1,39 @@
+import { $z } from '../../..';
+import * as types from './types';
+export interface OrderItem {
+    productId: number;
+    quantity: number;
+    price: number;
+    notes?: string;
+    discount: number | null;
+}
+export interface Address {
+    street: string;
+    city: string;
+    state: string;
+    zip: string;
+    country: string;
+}
+export interface Order {
+    id: number;
+    customerId: number;
+    status: string;
+    total: number;
+    items: OrderItem[];
+    shippingAddress: Address;
+    billingAddress: Address | null;
+    isGift: boolean;
+    giftMessage: string | null;
+    createdAt: Date;
+    updatedAt: Date | null;
+}
+type Context = {
+    requestedAt: number;
+    userId: number;
+};
+export declare const create: (args: $z.infer<typeof types.create.args>, context: Context) => Promise<$z.infer<typeof types.create.res>>;
+export declare const fetch: (args: $z.infer<typeof types.fetch.args>, context: Context) => Promise<$z.infer<typeof types.fetch.res>>;
+export declare const update: (args: $z.infer<typeof types.update.args>, context: Context) => Promise<$z.infer<typeof types.update.res>>;
+export declare const list: () => Promise<Order[]>;
+export declare const primitives: (args: $z.infer<typeof types.primitives.args>) => Promise<$z.infer<typeof types.primitives.res>>;
+export {};

package/dist/demo/bridge/order/index.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primitives = exports.list = exports.update = exports.fetch = exports.create = void 0;
+const types = __importStar(require("./types"));
+let nextId = 1;
+const orders = [];
+const create = async (args, context) => {
+    args = types.create.args.parse(args);
+    const items = args.items.map(item => ({
+        ...item,
+        price: item.price,
+        discount: item.discount
+    }));
+    const order = {
+        id: nextId++,
+        customerId: args.customerId,
+        status: 'pending',
+        total: items.reduce((sum, i) => sum + i.price * i.quantity, 0),
+        items,
+        shippingAddress: { ...args.shippingAddress, country: args.shippingAddress.country ?? 'US' },
+        billingAddress: args.billingAddress ? { ...args.billingAddress, country: args.billingAddress.country ?? 'US' } : null,
+        isGift: args.isGift,
+        giftMessage: args.giftMessage,
+        createdAt: new Date(),
+        updatedAt: null
+    };
+    orders.push(order);
+    return {
+        id: order.id,
+        status: order.status,
+        total: order.total,
+        items: order.items,
+        createdAt: order.createdAt
+    };
+};
+exports.create = create;
+const fetch = async (args, context) => {
+    args = types.fetch.args.parse(args);
+    const order = orders.find(o => o.id === args.id);
+    if (!order)
+        throw new Error(`Order with ID ${args.id} not found`);
+    return order;
+};
+exports.fetch = fetch;
+const update = async (args, context) => {
+    args = types.update.args.parse(args);
+    const order = orders.find(o => o.id === args.id);
+    if (!order)
+        throw new Error(`Order with ID ${args.id} not found`);
+    if (args.status)
+        order.status = args.status;
+    if (args.shippingAddress)
+        order.shippingAddress = { ...args.shippingAddress, country: args.shippingAddress.country ?? 'US' };
+    if (args.giftMessage !== undefined)
+        order.giftMessage = args.giftMessage ?? null;
+    order.updatedAt = new Date();
+    return { id: order.id, status: order.status, updatedAt: order.updatedAt };
+};
+exports.update = update;
+const list = async () => {
+    return orders;
+};
+exports.list = list;
+const primitives = async (args) => {
+    args = types.primitives.args.parse(args);
+    return {
+        str: 'hello',
+        num: 42,
+        bool: true,
+        date: new Date(),
+        nul: null,
+        undef: undefined,
+        unk: { anything: true },
+        whatever: 'literally anything',
+        optStr: 'present',
+        nullStr: null,
+        defStr: 'default value',
+        optNullStr: null,
+        nullOptStr: undefined,
+        tags: ['a', 'b', 'c'],
+        scores: [1, 2, 3],
+        optDates: [new Date()],
+        nested: {
+            a: 1,
+            b: 'nested',
+            c: {
+                d: true,
+                e: ['deep']
+            }
+        }
+    };
+};
+exports.primitives = primitives;

package/dist/demo/bridge/order/types.d.ts

@@ -0,0 +1,130 @@
+import { $z } from '../../..';
+export declare const create: {
+    args: $z.ZodObject<{
+        customerId: $z.ZodNumber;
+        items: $z.ZodArray<$z.ZodObject<{
+            productId: $z.ZodNumber;
+            quantity: $z.ZodNumber;
+            price: $z.ZodNumber;
+            notes: $z.ZodOptional<$z.ZodString>;
+            discount: $z.ZodNullable<$z.ZodNumber>;
+        }, $z.core.$strip>>;
+        shippingAddress: $z.ZodObject<{
+            street: $z.ZodString;
+            city: $z.ZodString;
+            state: $z.ZodString;
+            zip: $z.ZodString;
+            country: $z.ZodDefault<$z.ZodString>;
+        }, $z.core.$strip>;
+        billingAddress: $z.ZodNullable<$z.ZodObject<{
+            street: $z.ZodString;
+            city: $z.ZodString;
+            state: $z.ZodString;
+            zip: $z.ZodString;
+            country: $z.ZodDefault<$z.ZodString>;
+        }, $z.core.$strip>>;
+        couponCode: $z.ZodOptional<$z.ZodNullable<$z.ZodString>>;
+        scheduledDate: $z.ZodOptional<$z.ZodDate>;
+        isGift: $z.ZodBoolean;
+        giftMessage: $z.ZodNullable<$z.ZodString>;
+    }, $z.core.$strip>;
+    res: $z.ZodObject<{
+        id: $z.ZodNumber;
+        status: $z.ZodString;
+        total: $z.ZodNumber;
+        items: $z.ZodArray<$z.ZodObject<{
+            productId: $z.ZodNumber;
+            quantity: $z.ZodNumber;
+            price: $z.ZodNumber;
+            notes: $z.ZodOptional<$z.ZodString>;
+            discount: $z.ZodNullable<$z.ZodNumber>;
+        }, $z.core.$strip>>;
+        createdAt: $z.ZodDate;
+    }, $z.core.$strip>;
+};
+export declare const fetch: {
+    args: $z.ZodObject<{
+        id: $z.ZodNumber;
+    }, $z.core.$strip>;
+    res: $z.ZodObject<{
+        id: $z.ZodNumber;
+        customerId: $z.ZodNumber;
+        status: $z.ZodString;
+        total: $z.ZodNumber;
+        items: $z.ZodArray<$z.ZodObject<{
+            productId: $z.ZodNumber;
+            quantity: $z.ZodNumber;
+            price: $z.ZodNumber;
+            notes: $z.ZodOptional<$z.ZodString>;
+            discount: $z.ZodNullable<$z.ZodNumber>;
+        }, $z.core.$strip>>;
+        shippingAddress: $z.ZodObject<{
+            street: $z.ZodString;
+            city: $z.ZodString;
+            state: $z.ZodString;
+            zip: $z.ZodString;
+            country: $z.ZodDefault<$z.ZodString>;
+        }, $z.core.$strip>;
+        billingAddress: $z.ZodNullable<$z.ZodObject<{
+            street: $z.ZodString;
+            city: $z.ZodString;
+            state: $z.ZodString;
+            zip: $z.ZodString;
+            country: $z.ZodDefault<$z.ZodString>;
+        }, $z.core.$strip>>;
+        isGift: $z.ZodBoolean;
+        giftMessage: $z.ZodNullable<$z.ZodString>;
+        createdAt: $z.ZodDate;
+        updatedAt: $z.ZodNullable<$z.ZodDate>;
+    }, $z.core.$strip>;
+};
+export declare const update: {
+    args: $z.ZodObject<{
+        id: $z.ZodNumber;
+        status: $z.ZodOptional<$z.ZodString>;
+        shippingAddress: $z.ZodOptional<$z.ZodObject<{
+            street: $z.ZodString;
+            city: $z.ZodString;
+            state: $z.ZodString;
+            zip: $z.ZodString;
+            country: $z.ZodDefault<$z.ZodString>;
+        }, $z.core.$strip>>;
+        giftMessage: $z.ZodOptional<$z.ZodNullable<$z.ZodString>>;
+    }, $z.core.$strip>;
+    res: $z.ZodObject<{
+        id: $z.ZodNumber;
+        status: $z.ZodString;
+        updatedAt: $z.ZodDate;
+    }, $z.core.$strip>;
+};
+export declare const primitives: {
+    args: $z.ZodObject<{
+        key: $z.ZodString;
+    }, $z.core.$strip>;
+    res: $z.ZodObject<{
+        str: $z.ZodString;
+        num: $z.ZodNumber;
+        bool: $z.ZodBoolean;
+        date: $z.ZodDate;
+        nul: $z.ZodNull;
+        undef: $z.ZodUndefined;
+        unk: $z.ZodUnknown;
+        whatever: $z.ZodAny;
+        optStr: $z.ZodOptional<$z.ZodString>;
+        nullStr: $z.ZodNullable<$z.ZodString>;
+        defStr: $z.ZodDefault<$z.ZodString>;
+        optNullStr: $z.ZodOptional<$z.ZodNullable<$z.ZodString>>;
+        nullOptStr: $z.ZodNullable<$z.ZodOptional<$z.ZodString>>;
+        tags: $z.ZodArray<$z.ZodString>;
+        scores: $z.ZodNullable<$z.ZodArray<$z.ZodNumber>>;
+        optDates: $z.ZodOptional<$z.ZodArray<$z.ZodDate>>;
+        nested: $z.ZodObject<{
+            a: $z.ZodNumber;
+            b: $z.ZodOptional<$z.ZodString>;
+            c: $z.ZodObject<{
+                d: $z.ZodBoolean;
+                e: $z.ZodNullable<$z.ZodArray<$z.ZodString>>;
+            }, $z.core.$strip>;
+        }, $z.core.$strip>;
+    }, $z.core.$strip>;
+};