@tiangong-lca/tidas-sdk 0.1.0

package/dist/core/zod-factories.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * TIDAS-specific factory functions using ZodProxy for true property access
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessSchema = exports.FlowSchema = exports.ContactSchema = void 0;
+exports.createZodContact = createZodContact;
+exports.createZodFlow = createZodFlow;
+exports.createZodProcess = createZodProcess;
+exports.createZodSource = createZodSource;
+exports.createZodFlowProperty = createZodFlowProperty;
+exports.createZodUnitGroup = createZodUnitGroup;
+exports.createZodLCIAMethod = createZodLCIAMethod;
+exports.createZodLifeCycleModel = createZodLifeCycleModel;
+exports.createZodTidasProxy = createZodTidasProxy;
+const zod_proxy_1 = require("./zod-proxy");
+// Import existing Zod schemas (we'll need to check what's available)
+// For now, let's create basic schemas as examples
+/**
+ * Basic Contact schema for demonstration
+ */
+const index_1 = require("../schemas/index");
+Object.defineProperty(exports, "ContactSchema", { enumerable: true, get: function () { return index_1.ContactSchema; } });
+Object.defineProperty(exports, "FlowSchema", { enumerable: true, get: function () { return index_1.FlowSchema; } });
+Object.defineProperty(exports, "ProcessSchema", { enumerable: true, get: function () { return index_1.ProcessSchema; } });
+/**
+ * Create enhanced proxy with TIDAS-specific functionality
+ */
+function createTidasProxy(schema, options = {}) {
+    const defaultOptions = {
+        enableLogging: true,
+        throwOnValidationError: false,
+        autoCreateArrays: true,
+        autoGenerateUUID: false,
+        autoGenerateTimestamp: false,
+        defaultLanguage: 'en',
+        ...options,
+    };
+    const zodProxy = (0, zod_proxy_1.createZodProxy)(schema, defaultOptions);
+    // Helper function to generate UUID
+    const generateUUID = () => {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            const r = (Math.random() * 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    };
+    // Helper function to get current timestamp
+    const getCurrentTimestamp = () => {
+        return new Date().toISOString();
+    };
+    // Helper function to set multi-language text
+    const setMultiLangText = (path, text, lang = defaultOptions.defaultLanguage || 'en') => {
+        const multiLangValue = {
+            '@xml:lang': lang,
+            '#text': text,
+        };
+        // Access the proxy through the path and set the value
+        const pathParts = path.split('.');
+        let current = zodProxy.proxy;
+        for (let i = 0; i < pathParts.length - 1; i++) {
+            const part = pathParts[i];
+            if (!current[part]) {
+                current[part] = {};
+            }
+            current = current[part];
+        }
+        const lastPart = pathParts[pathParts.length - 1];
+        current[lastPart] = multiLangValue;
+    };
+    // Helper function to get multi-language text
+    const getMultiLangText = (path, lang = defaultOptions.defaultLanguage || 'en') => {
+        const pathParts = path.split('.');
+        let current = zodProxy.proxy;
+        try {
+            for (const part of pathParts) {
+                current = current[part];
+                if (!current)
+                    return '';
+            }
+            if (Array.isArray(current)) {
+                const found = current.find((item) => item['@xml:lang'] === lang);
+                return found ? found['#text'] : '';
+            }
+            else if (current && typeof current === 'object') {
+                return current['@xml:lang'] === lang ? current['#text'] || '' : '';
+            }
+            return String(current || '');
+        }
+        catch {
+            return '';
+        }
+    };
+    // Helper function to generate UUID at path
+    const generateUUIDAtPath = (path) => {
+        const pathParts = path.split('.');
+        let current = zodProxy.proxy;
+        for (let i = 0; i < pathParts.length - 1; i++) {
+            const part = pathParts[i];
+            if (!current[part]) {
+                current[part] = {};
+            }
+            current = current[part];
+        }
+        const lastPart = pathParts[pathParts.length - 1];
+        current[lastPart] = generateUUID();
+    };
+    // Helper function to set current timestamp at path
+    const setCurrentTimestampAtPath = (path) => {
+        const pathParts = path.split('.');
+        let current = zodProxy.proxy;
+        for (let i = 0; i < pathParts.length - 1; i++) {
+            const part = pathParts[i];
+            if (!current[part]) {
+                current[part] = {};
+            }
+            current = current[part];
+        }
+        const lastPart = pathParts[pathParts.length - 1];
+        current[lastPart] = getCurrentTimestamp();
+    };
+    return {
+        ...zodProxy,
+        setMultiLangText,
+        getMultiLangText,
+        generateUUID: generateUUIDAtPath,
+        setCurrentTimestamp: setCurrentTimestampAtPath,
+    };
+}
+/**
+ * Create a Contact proxy with type-safe property access
+ */
+function createZodContact(options = {}) {
+    return createTidasProxy(index_1.ContactSchema, options);
+}
+/**
+ * Create a Flow proxy with type-safe property access
+ */
+function createZodFlow(options = {}) {
+    return createTidasProxy(index_1.FlowSchema, options);
+}
+/**
+ * Create a Process proxy with type-safe property access
+ */
+function createZodProcess(options = {}) {
+    return createTidasProxy(index_1.ProcessSchema, options);
+}
+function createZodSource(options = {}) {
+    return createTidasProxy(index_1.SourceSchema, options);
+}
+function createZodFlowProperty(options = {}) {
+    return createTidasProxy(index_1.FlowPropertySchema, options);
+}
+function createZodUnitGroup(options = {}) {
+    return createTidasProxy(index_1.UnitGroupSchema, options);
+}
+function createZodLCIAMethod(options = {}) {
+    return createTidasProxy(index_1.LCIAMethodSchema, options);
+}
+function createZodLifeCycleModel(options = {}) {
+    return createTidasProxy(index_1.LifeCycleModelSchema, options);
+}
+/**
+ * Utility function to create a proxy from any schema
+ */
+function createZodTidasProxy(schema, options = {}) {
+    return createTidasProxy(schema, options);
+}
+//# sourceMappingURL=zod-factories.js.map

package/dist/core/zod-factories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-factories.js","sourceRoot":"","sources":["../../src/core/zod-factories.ts"],"names":[],"mappings":"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"}

package/dist/core/zod-proxy.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Zod Proxy implementation for true property access with Schema validation
+ * Based on the advanced Zod Proxy approach from docs/zod-proxy.md
+ */
+import { z } from 'zod';
+/**
+ * Path information for complex path parsing
+ */
+export interface PathInfo {
+    segments: string[];
+    arrayIndices: number[];
+    fullPath: string;
+    isArrayAccess: boolean;
+}
+/**
+ * Access log entry for debugging and tracking
+ */
+export interface AccessLogEntry {
+    type: 'get' | 'set' | 'push' | 'delete';
+    path: string;
+    value?: any;
+    timestamp: number;
+}
+/**
+ * Configuration options for ZodProxy
+ */
+export interface ZodProxyOptions {
+    enableLogging?: boolean;
+    throwOnValidationError?: boolean;
+    autoCreateArrays?: boolean;
+}
+/**
+ * Result of ZodProxy validation
+ */
+export interface ZodProxyValidationResult<T> {
+    success: boolean;
+    data?: T;
+    error?: z.ZodError;
+}
+/**
+ * Main ZodProxy class for creating proxies with Schema validation
+ */
+export declare class ZodProxy<T extends z.ZodSchema> {
+    private schema;
+    private options;
+    private accessLog;
+    private values;
+    private arrayLengths;
+    constructor(schema: T, options?: ZodProxyOptions);
+    /**
+     * Log access for debugging
+     */
+    private log;
+    /**
+     * Validate value against schema at specific path
+     */
+    private validateValue;
+    /**
+     * Ensure array path has correct length
+     */
+    private ensureArrayPath;
+    /**
+     * Create the main proxy object
+     */
+    createProxy(currentPath?: string[]): any;
+    /**
+     * Build final object from all set values
+     */
+    buildObject(): any;
+    /**
+     * Validate the complete object against schema
+     */
+    validate(): ZodProxyValidationResult<z.infer<T>>;
+    /**
+     * Get access log for debugging
+     */
+    getAccessLog(): AccessLogEntry[];
+    /**
+     * Get all stored values
+     */
+    getValues(): Record<string, any>;
+    /**
+     * Get array lengths
+     */
+    getArrayLengths(): Record<string, number>;
+    /**
+     * Debug information
+     */
+    debug(): {
+        values: Record<string, any>;
+        arrayLengths: Record<string, number>;
+        accessLog: AccessLogEntry[];
+        builtObject: any;
+    };
+}
+/**
+ * Factory function to create a ZodProxy with convenient API
+ */
+export declare function createZodProxy<T extends z.ZodSchema>(schema: T, options?: ZodProxyOptions): {
+    proxy: z.infer<T>;
+    getAccessLog: () => AccessLogEntry[];
+    getValues: () => Record<string, any>;
+    getArrayLengths: () => Record<string, number>;
+    buildObject: () => any;
+    validate: () => ZodProxyValidationResult<z.infer<T>>;
+    debug: () => any;
+};
+//# sourceMappingURL=zod-proxy.d.ts.map

package/dist/core/zod-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-proxy.d.ts","sourceRoot":"","sources":["../../src/core/zod-proxy.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB,CAAC,CAAC;IACzC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,KAAK,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC;CACpB;AAiID;;GAEG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;IACzC,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,SAAS,CAAwB;IACzC,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,YAAY,CAA6B;gBAErC,MAAM,EAAE,CAAC,EAAE,OAAO,GAAE,eAAoB;IAUpD;;OAEG;IACH,OAAO,CAAC,GAAG;IAeX;;OAEG;IACH,OAAO,CAAC,aAAa;IAsBrB;;OAEG;IACH,OAAO,CAAC,eAAe;IASvB;;OAEG;IACH,WAAW,CAAC,WAAW,GAAE,MAAM,EAAO,GAAG,GAAG;IA6I5C;;OAEG;IACH,WAAW,IAAI,GAAG;IAmBlB;;OAEG;IACH,QAAQ,IAAI,wBAAwB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAUhD;;OAEG;IACH,YAAY,IAAI,cAAc,EAAE;IAIhC;;OAEG;IACH,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIhC;;OAEG;IACH,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAIzC;;OAEG;IACH,KAAK,IAAI;QACP,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC5B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACrC,SAAS,EAAE,cAAc,EAAE,CAAC;QAC5B,WAAW,EAAE,GAAG,CAAC;KAClB;CAQF;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,EAClD,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,eAAoB,GAC5B;IACD,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,YAAY,EAAE,MAAM,cAAc,EAAE,CAAC;IACrC,SAAS,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACrC,eAAe,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C,WAAW,EAAE,MAAM,GAAG,CAAC;IACvB,QAAQ,EAAE,MAAM,wBAAwB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACrD,KAAK,EAAE,MAAM,GAAG,CAAC;CAClB,CAaA"}

package/dist/core/zod-proxy.js

@@ -0,0 +1,382 @@
+"use strict";
+/**
+ * Zod Proxy implementation for true property access with Schema validation
+ * Based on the advanced Zod Proxy approach from docs/zod-proxy.md
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodProxy = void 0;
+exports.createZodProxy = createZodProxy;
+const zod_1 = require("zod");
+/**
+ * Parse array path like "posts[0].comments[1].text"
+ */
+function parseArrayPath(path) {
+    const segments = [];
+    const arrayIndices = [];
+    let isArrayAccess = false;
+    // Parse path, e.g., "posts[0].comments[1].replies[2].text"
+    const parts = path.split(/[.[\]]/).filter((part) => part !== '');
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (/^\d+$/.test(part)) {
+            // This is an array index
+            arrayIndices.push(parseInt(part));
+            isArrayAccess = true;
+        }
+        else {
+            // This is a property name
+            segments.push(part);
+        }
+    }
+    return {
+        segments,
+        arrayIndices,
+        fullPath: path,
+        isArrayAccess,
+    };
+}
+/**
+ * Get schema at a specific path within the main schema
+ */
+function getSchemaAtPath(currentSchema, pathSegments) {
+    let schema = currentSchema;
+    for (const segment of pathSegments) {
+        if (schema instanceof zod_1.z.ZodObject) {
+            const shape = schema.shape;
+            if (shape[segment]) {
+                schema = shape[segment];
+            }
+            else {
+                return null;
+            }
+        }
+        else if (schema instanceof zod_1.z.ZodArray) {
+            // If it's an array, get element type
+            schema = schema.element;
+            // Continue processing remaining path after array access
+            continue;
+        }
+        else {
+            return null;
+        }
+    }
+    return schema;
+}
+/**
+ * Set nested property in an object using path segments
+ */
+function setNestedProperty(obj, path, value) {
+    let current = obj;
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        if (!(key in current)) {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    current[path[path.length - 1]] = value;
+}
+/**
+ * Set nested array property using complex path like "posts[0].comments[1].text"
+ */
+function setNestedArrayProperty(obj, fullPath, value) {
+    // Parse complex path like "posts[0].comments[1].text"
+    const parts = fullPath.split(/[.[\]]/).filter((part) => part !== '');
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (/^\d+$/.test(part)) {
+            // Array index
+            const index = parseInt(part);
+            if (!Array.isArray(current)) {
+                current = [];
+            }
+            if (!current[index]) {
+                current[index] = {};
+            }
+            current = current[index];
+        }
+        else {
+            // Property name
+            if (!(part in current)) {
+                // Check if next part is array index
+                const nextPart = parts[i + 1];
+                if (nextPart && /^\d+$/.test(nextPart)) {
+                    current[part] = [];
+                }
+                else {
+                    current[part] = {};
+                }
+            }
+            current = current[part];
+        }
+    }
+    const lastPart = parts[parts.length - 1];
+    if (/^\d+$/.test(lastPart)) {
+        const index = parseInt(lastPart);
+        if (!Array.isArray(current)) {
+            current = [];
+        }
+        current[index] = value;
+    }
+    else {
+        current[lastPart] = value;
+    }
+}
+/**
+ * Main ZodProxy class for creating proxies with Schema validation
+ */
+class ZodProxy {
+    constructor(schema, options = {}) {
+        this.accessLog = [];
+        this.values = new Map();
+        this.arrayLengths = new Map();
+        this.schema = schema;
+        this.options = {
+            enableLogging: true,
+            throwOnValidationError: false,
+            autoCreateArrays: true,
+            ...options,
+        };
+    }
+    /**
+     * Log access for debugging
+     */
+    log(type, path, value) {
+        if (this.options.enableLogging) {
+            this.accessLog.push({
+                type,
+                path,
+                value,
+                timestamp: Date.now(),
+            });
+        }
+    }
+    /**
+     * Validate value against schema at specific path
+     */
+    validateValue(path, value) {
+        const pathInfo = parseArrayPath(path);
+        try {
+            // Get schema for this path
+            const targetSchema = getSchemaAtPath(this.schema, pathInfo.segments);
+            if (targetSchema) {
+                targetSchema.parse(value);
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            if (this.options.throwOnValidationError) {
+                throw error;
+            }
+            console.error(`Validation failed for ${path}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Ensure array path has correct length
+     */
+    ensureArrayPath(path, index) {
+        const arrayPath = path;
+        const currentLength = this.arrayLengths.get(arrayPath) || 0;
+        if (index >= currentLength) {
+            this.arrayLengths.set(arrayPath, index + 1);
+        }
+    }
+    /**
+     * Create the main proxy object
+     */
+    createProxy(currentPath = []) {
+        return new Proxy({}, {
+            get: (_target, prop) => {
+                if (typeof prop === 'symbol') {
+                    return undefined;
+                }
+                const newPath = [...currentPath, prop];
+                const pathStr = newPath.join('.');
+                // Handle special array properties
+                if (prop === 'length' && currentPath.length > 0) {
+                    const arrayPath = currentPath.join('.');
+                    const length = this.arrayLengths.get(arrayPath) || 0;
+                    this.log('get', `${arrayPath}.length`, length);
+                    return length;
+                }
+                if (prop === 'push') {
+                    return (...items) => {
+                        const arrayPath = currentPath.join('.');
+                        const currentLength = this.arrayLengths.get(arrayPath) || 0;
+                        items.forEach((item, index) => {
+                            const itemPath = `${arrayPath}[${currentLength + index}]`;
+                            if (this.validateValue(itemPath, item)) {
+                                this.values.set(itemPath, item);
+                                this.log('push', itemPath, item);
+                            }
+                        });
+                        const newLength = currentLength + items.length;
+                        this.arrayLengths.set(arrayPath, newLength);
+                        return newLength;
+                    };
+                }
+                if (prop === 'pop') {
+                    return () => {
+                        const arrayPath = currentPath.join('.');
+                        const currentLength = this.arrayLengths.get(arrayPath) || 0;
+                        if (currentLength > 0) {
+                            const lastIndex = currentLength - 1;
+                            const itemPath = `${arrayPath}[${lastIndex}]`;
+                            const value = this.values.get(itemPath);
+                            this.values.delete(itemPath);
+                            this.arrayLengths.set(arrayPath, lastIndex);
+                            this.log('delete', itemPath, value);
+                            return value;
+                        }
+                        return undefined;
+                    };
+                }
+                // Handle array index access
+                if (/^\d+$/.test(prop)) {
+                    const index = parseInt(prop);
+                    const arrayPath = currentPath.join('.');
+                    const itemPath = `${arrayPath}[${index}]`;
+                    this.ensureArrayPath(arrayPath, index);
+                    this.log('get', itemPath);
+                    if (this.values.has(itemPath)) {
+                        const value = this.values.get(itemPath);
+                        // If value is object, return proxy
+                        if (typeof value === 'object' && value !== null) {
+                            return this.createProxy([...currentPath, prop]);
+                        }
+                        return value;
+                    }
+                    return this.createProxy([...currentPath, prop]);
+                }
+                this.log('get', pathStr);
+                if (this.values.has(pathStr)) {
+                    return this.values.get(pathStr);
+                }
+                return this.createProxy(newPath);
+            },
+            set: (_target, prop, value) => {
+                if (typeof prop !== 'string') {
+                    return false;
+                }
+                const newPath = [...currentPath, prop];
+                const pathStr = newPath.join('.');
+                // Handle array index assignment
+                if (/^\d+$/.test(prop)) {
+                    const index = parseInt(prop);
+                    const arrayPath = currentPath.join('.');
+                    const itemPath = `${arrayPath}[${index}]`;
+                    if (this.validateValue(itemPath, value)) {
+                        this.values.set(itemPath, value);
+                        this.ensureArrayPath(arrayPath, index);
+                        this.log('set', itemPath, value);
+                        return true;
+                    }
+                    return false;
+                }
+                if (this.validateValue(pathStr, value)) {
+                    this.values.set(pathStr, value);
+                    this.log('set', pathStr, value);
+                    return true;
+                }
+                return false;
+            },
+            has: (_target, prop) => {
+                const newPath = [...currentPath, prop];
+                const pathStr = newPath.join('.');
+                return this.values.has(pathStr);
+            },
+            deleteProperty: (_target, prop) => {
+                const newPath = [...currentPath, prop];
+                const pathStr = newPath.join('.');
+                const existed = this.values.has(pathStr);
+                this.values.delete(pathStr);
+                if (existed) {
+                    this.log('delete', pathStr);
+                }
+                return true;
+            },
+        });
+    }
+    /**
+     * Build final object from all set values
+     */
+    buildObject() {
+        const result = {};
+        // Process all values
+        for (const [path, value] of this.values.entries()) {
+            const pathInfo = parseArrayPath(path);
+            if (!pathInfo.isArrayAccess) {
+                // Simple property path
+                setNestedProperty(result, pathInfo.segments, value);
+            }
+            else {
+                // Array path
+                setNestedArrayProperty(result, path, value);
+            }
+        }
+        return result;
+    }
+    /**
+     * Validate the complete object against schema
+     */
+    validate() {
+        try {
+            const obj = this.buildObject();
+            const result = this.schema.parse(obj);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            return { success: false, error: error };
+        }
+    }
+    /**
+     * Get access log for debugging
+     */
+    getAccessLog() {
+        return [...this.accessLog];
+    }
+    /**
+     * Get all stored values
+     */
+    getValues() {
+        return Object.fromEntries(this.values.entries());
+    }
+    /**
+     * Get array lengths
+     */
+    getArrayLengths() {
+        return Object.fromEntries(this.arrayLengths.entries());
+    }
+    /**
+     * Debug information
+     */
+    debug() {
+        return {
+            values: this.getValues(),
+            arrayLengths: this.getArrayLengths(),
+            accessLog: this.accessLog.slice(-10), // Last 10 entries
+            builtObject: this.buildObject(),
+        };
+    }
+}
+exports.ZodProxy = ZodProxy;
+/**
+ * Factory function to create a ZodProxy with convenient API
+ */
+function createZodProxy(schema, options = {}) {
+    const zodProxy = new ZodProxy(schema, options);
+    const proxy = zodProxy.createProxy();
+    return {
+        proxy,
+        getAccessLog: () => zodProxy.getAccessLog(),
+        getValues: () => zodProxy.getValues(),
+        getArrayLengths: () => zodProxy.getArrayLengths(),
+        buildObject: () => zodProxy.buildObject(),
+        validate: () => zodProxy.validate(),
+        debug: () => zodProxy.debug(),
+    };
+}
+//# sourceMappingURL=zod-proxy.js.map