@finsys/core 1.1.0 → 1.3.0

package/dist/form-spec.js

@@ -1,278 +0,0 @@
-import { FormFieldCategory } from "./form-field-category.js";
-import FormField from "./form-field.js";
-import { validateFormConfig } from "./validator.js";
-import semver from "semver";
-export class FormSpec {
-    constructor(displayName, categories, fields, pages = [], templateIcon, schemaVersion = FormSpec.MAX_PARSER_SCHEMA_VERSION) {
-        this._categories = [];
-        this._fields = [];
-        this._pages = [];
-        this._displayName = displayName;
-        this._templateIcon = templateIcon;
-        this._categories = categories;
-        this._fields = fields;
-        this._pages = pages;
-        this._schemaVersion = schemaVersion;
-    }
-    get fieldNames() {
-        let names = [];
-        this.fields.forEach((field) => {
-            names = names.concat(field.getFieldNames());
-        });
-        return names;
-    }
-    get schemaVersion() {
-        return this._schemaVersion;
-    }
-    get requiresUpgrade() {
-        return semver.lt(this._schemaVersion, FormSpec.MAX_PARSER_SCHEMA_VERSION);
-    }
-    upgradeToV2() {
-        this._schemaVersion = FormSpec.MAX_PARSER_SCHEMA_VERSION;
-    }
-    get displayName() {
-        return this._displayName;
-    }
-    set displayName(newDisplayName) {
-        this._displayName = newDisplayName;
-    }
-    get templateIcon() {
-        return this._templateIcon;
-    }
-    set templateIcon(value) {
-        this._templateIcon = value;
-    }
-    get categories() {
-        return this._categories;
-    }
-    set categories(categories) {
-        this._categories = categories;
-    }
-    get fields() {
-        return this._fields;
-    }
-    set fields(fields) {
-        this._fields = fields;
-    }
-    get pages() {
-        return this._pages;
-    }
-    set pages(value) {
-        this._pages = value;
-    }
-    addField(field) {
-        this._fields.push(field);
-    }
-    updateField(field) {
-        const index = this._fields.findIndex((f) => f.name === field.name);
-        if (index !== -1) {
-            this._fields[index] = field;
-        }
-        else {
-            throw new Error(`${field.name} not found. Form Spec of ${this._displayName} cannot update ${field.name}`);
-        }
-    }
-    removeField(fieldName) {
-        const fieldIndex = this._fields.findIndex((f) => f.name === fieldName);
-        if (fieldIndex !== -1) {
-            this._fields.splice(fieldIndex, 1);
-            this._pages.forEach((page) => {
-                page.fields = page.fields.filter((fieldRef) => {
-                    let refName;
-                    if (typeof fieldRef === 'string') {
-                        refName = fieldRef;
-                    }
-                    else if ('ref' in fieldRef) {
-                        refName = fieldRef.ref;
-                    }
-                    else if ('definition' in fieldRef) {
-                        refName = fieldRef.definition.name;
-                    }
-                    return refName !== fieldName;
-                });
-            });
-        }
-    }
-    getFieldsByCategory(categoryName) {
-        const foundCategory = this.categories.find((category) => category.name === categoryName);
-        if (!foundCategory) {
-            return [];
-        }
-        return this._fields.filter((field) => field.categoryId === foundCategory.id);
-    }
-    validate() {
-        const config = this.toJSON();
-        const result = validateFormConfig(config);
-        const errors = [];
-        if (result.errors) {
-            result.errors.forEach((err) => {
-                let path = err.instancePath || err.dataPath || '';
-                path = path.replace(/^\//, '').replace(/\//g, '.');
-                const prefix = path ? `${path}: ` : '';
-                errors.push({
-                    message: `${prefix}${err.message}`,
-                    path: path,
-                });
-            });
-        }
-        if (!this._displayName || this._displayName.trim() === '') {
-            errors.push({
-                message: 'displayName: Form display name is required',
-                path: 'displayName',
-            });
-        }
-        const categoryIds = new Set(this._categories.map((c) => String(c.id)));
-        this._fields.forEach((field) => {
-            if (field.categoryId && !categoryIds.has(String(field.categoryId))) {
-                errors.push({
-                    message: `fields.${field.name}.category: references non-existent category '${field.categoryId}'`,
-                    path: `fields.${field.name}.category`,
-                });
-            }
-        });
-        const fieldNames = new Set(this._fields.map((f) => f.name));
-        this._pages.forEach((page, pageIndex) => {
-            page.fields.forEach((fieldRef, fieldIndex) => {
-                let refName;
-                if (typeof fieldRef === 'string') {
-                    refName = fieldRef;
-                }
-                else if (fieldRef && fieldRef.ref) {
-                    refName = fieldRef.ref;
-                }
-                else if (fieldRef && fieldRef.definition) {
-                    refName = fieldRef.definition.name;
-                }
-                if (refName && !fieldNames.has(refName)) {
-                    errors.push({
-                        message: `pages.${pageIndex}.fields.${fieldIndex}: references non-existent field '${refName}'`,
-                        path: `pages.${pageIndex}.fields.${fieldIndex}`,
-                    });
-                }
-            });
-        });
-        return {
-            valid: result.valid && errors.length === (result.errors?.length || 0),
-            errors: errors.length > 0 ? errors : undefined,
-        };
-    }
-    cleanObject(obj) {
-        if (obj === null || obj === undefined)
-            return obj;
-        let target = obj;
-        if (typeof obj.toJSON === 'function' && obj !== this) {
-            target = obj.toJSON();
-        }
-        if (Array.isArray(target)) {
-            return target.map((v) => (typeof v === 'object' ? this.cleanObject(v) : v));
-        }
-        if (typeof target !== 'object')
-            return target;
-        const cleaned = {};
-        Object.keys(target).forEach((key) => {
-            const value = target[key];
-            if (value !== null && value !== undefined && value !== '') {
-                if (typeof value === 'object') {
-                    cleaned[key] = this.cleanObject(value);
-                }
-                else {
-                    cleaned[key] = value;
-                }
-            }
-        });
-        return cleaned;
-    }
-    toJSON() {
-        const fieldsMap = {};
-        this._fields.forEach((field) => {
-            fieldsMap[field.name] = field.toJSON();
-            delete fieldsMap[field.name].name;
-        });
-        return this.cleanObject({
-            $schema: '../../../node_modules/@finsys/core/dist/schema/unified-form.schema.json',
-            schemaVersion: this._schemaVersion,
-            displayName: this._displayName,
-            templateIcon: this._templateIcon,
-            categories: this._categories,
-            fields: fieldsMap,
-            pages: this._pages,
-        });
-    }
-    static fromJSON(jsonString) {
-        let jsonData;
-        try {
-            jsonData = JSON.parse(jsonString);
-        }
-        catch (error) {
-            console.error(`Error parsing JSON for Loantype with string: ${jsonString}`);
-            throw error;
-        }
-        if (!jsonData.schemaVersion) {
-            throw new Error('Invalid JSON: schemaVersion is missing or invalid');
-        }
-        if (semver.lt(jsonData.schemaVersion, FormSpec.MIN_PARSER_SCHEMA_VERSION)) {
-            throw new Error(`This form spec file is using an outdated schema version ${jsonData.schemaVersion}. Minimum supported version is ${FormSpec.MIN_PARSER_SCHEMA_VERSION}`);
-        }
-        if (!jsonData.displayName) {
-            throw new Error('Invalid JSON: displayName is missing or invalid');
-        }
-        if (!jsonData.categories) {
-            throw new Error('Invalid JSON: categories is missing or invalid');
-        }
-        if (!jsonData.fields) {
-            throw new Error('Invalid JSON: fields is missing or invalid');
-        }
-        if (!jsonData.pages || jsonData.pages.length === 0) {
-            if (semver.satisfies(jsonData.schemaVersion, '>=2.0.0')) {
-                console.warn(`v2.0.0 template ${jsonData.displayName} is missing pages. Generating default pages.`);
-            }
-        }
-        let fieldObjects = [];
-        if (Array.isArray(jsonData.fields)) {
-            fieldObjects = jsonData.fields;
-        }
-        else if (typeof jsonData.fields === 'object' && jsonData.fields !== null) {
-            fieldObjects = Object.entries(jsonData.fields).map(([name, data]) => {
-                return {
-                    name,
-                    ...data,
-                };
-            });
-        }
-        fieldObjects.forEach((f) => {
-            if (f.categoryId && !f.category) {
-                f.category = String(f.categoryId);
-            }
-            else if (f.category) {
-                f.category = String(f.category);
-            }
-        });
-        const categories = (jsonData.categories || []).map((cat) => {
-            return new FormFieldCategory(String(cat.id), cat.name);
-        });
-        const fields = fieldObjects.map((fieldObject) => {
-            return FormField.fromObject(fieldObject);
-        });
-        let pages = jsonData.pages || [];
-        if (pages.length === 0) {
-            const categoriesMap = {};
-            fields.forEach((f) => {
-                const catId = f.categoryId;
-                if (!categoriesMap[catId]) {
-                    categoriesMap[catId] = [];
-                }
-                categoriesMap[catId].push(f.name);
-            });
-            pages = categories
-                .map((cat) => ({
-                id: `page-${cat.id}`,
-                title: cat.name,
-                fields: categoriesMap[cat.id] || [],
-            }))
-                .filter((p) => p.fields.length > 0);
-        }
-        return new FormSpec(jsonData.displayName, categories, fields, pages, jsonData.templateIcon, jsonData.schemaVersion);
-    }
-}
-FormSpec.MIN_PARSER_SCHEMA_VERSION = 'v1.0.0';
-FormSpec.MAX_PARSER_SCHEMA_VERSION = 'v2.0.0';

package/dist/form-spec.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/form-spec.test.js

@@ -1,322 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { FormSpec } from "./form-spec.js";
-import { FormFieldCategory } from "./form-field-category.js";
-import FormField from "./form-field.js";
-describe("FormSpec", () => {
-    it("manages display name", () => {
-        const spec = new FormSpec("Spec", [], [], []);
-        expect(spec.displayName).toBe("Spec");
-        spec.displayName = "New Spec";
-        expect(spec.displayName).toBe("New Spec");
-    });
-    it("manages template icon", () => {
-        const spec = new FormSpec("Spec", [], [], []);
-        expect(spec.templateIcon).toBeUndefined();
-        spec.templateIcon = "icon";
-        expect(spec.templateIcon).toBe("icon");
-    });
-    it("manages categories", () => {
-        const spec = new FormSpec("Spec", [], [], []);
-        spec.categories = [new FormFieldCategory("c1", "C1")];
-        expect(spec.categories.length).toBe(1);
-    });
-    it("manages fields", () => {
-        const spec = new FormSpec("Spec", [], [], []);
-        spec.fields = [
-            FormField.fromObject({ name: "f1", displayName: "F1", type: "text", category: "c1" }),
-        ];
-        expect(spec.fields.length).toBe(1);
-    });
-    it("manages pages", () => {
-        const spec = new FormSpec("Spec", [], [], []);
-        spec.pages = [{ id: "p1", title: "P1", fields: ["f1"] }];
-        expect(spec.pages.length).toBe(1);
-    });
-    it("adds field", () => {
-        const cat1 = new FormFieldCategory("cat1", "Category 1");
-        const field1 = FormField.fromObject({ name: "f1", displayName: "F1", type: "text", category: "cat1" });
-        const spec = new FormSpec("Spec", [cat1], [field1], []);
-        const field2 = FormField.fromObject({ name: "f2", displayName: "F2", type: "text", category: "cat1" });
-        spec.addField(field2);
-        expect(spec.fields.length).toBe(2);
-    });
-    it("updates existing field", () => {
-        const field1 = FormField.fromObject({ name: "f1", displayName: "F1", type: "text", category: "cat1" });
-        const spec = new FormSpec("Spec", [], [field1], []);
-        spec.updateField(FormField.fromObject({ name: "f1", displayName: "F1 Updated", type: "text", category: "cat1" }));
-        expect(spec.fields[0].displayName).toBe("F1 Updated");
-    });
-    it("throws when updating non-existent field", () => {
-        const spec = new FormSpec("Spec", [], [], []);
-        expect(() => spec.updateField(FormField.fromObject({ name: "missing", displayName: "Err", type: "text", category: "cat1" }))).toThrow(/not found/);
-    });
-    it("removes field", () => {
-        const field1 = FormField.fromObject({ name: "f1", displayName: "F1", type: "text", category: "cat1" });
-        const field2 = FormField.fromObject({ name: "f2", displayName: "F2", type: "text", category: "cat1" });
-        const spec = new FormSpec("Spec", [], [field1, field2], []);
-        spec.removeField("f1");
-        expect(spec.fields.length).toBe(1);
-        spec.removeField("f2");
-        expect(spec.fields.length).toBe(0);
-    });
-    it("removes field from pages", () => {
-        const field1 = FormField.fromObject({ name: "f1", displayName: "F1", type: "text", category: "cat1" });
-        const pages = [
-            {
-                id: "p1",
-                title: "P1",
-                fields: ["f1", { ref: "f1" }, { definition: { name: "f1" } }, "f2"],
-            },
-        ];
-        const spec = new FormSpec("Spec", [], [field1], pages);
-        spec.removeField("f1");
-        expect(spec.pages[0].fields).toEqual(["f2"]);
-    });
-    it("gets fields by category", () => {
-        const cat1 = new FormFieldCategory("cat1", "Category 1");
-        const field1 = FormField.fromObject({ name: "f1", displayName: "F1", type: "text", category: "cat1" });
-        const field2 = FormField.fromObject({ name: "f2", displayName: "F2", type: "text", category: "cat1" });
-        const spec = new FormSpec("Spec", [cat1], [field1, field2], []);
-        expect(spec.getFieldsByCategory("Category 1").length).toBe(2);
-        expect(spec.getFieldsByCategory("Missing").length).toBe(0);
-    });
-    it("gets fieldNames", () => {
-        const field1 = FormField.fromObject({ name: "f1", displayName: "F1", type: "text", category: "cat1" });
-        const field2 = FormField.fromObject({ name: "f2", displayName: "F2", type: "text", category: "cat1" });
-        const spec = new FormSpec("Spec", [], [field1, field2], []);
-        expect(spec.fieldNames).toEqual(["f1", "f2"]);
-    });
-});
-describe("FormSpec schema version", () => {
-    it("detects requiresUpgrade", () => {
-        const spec = new FormSpec("Spec", [], [], [], undefined, "v1.0.0");
-        expect(spec.requiresUpgrade).toBe(true);
-    });
-    it("upgrades to v2", () => {
-        const spec = new FormSpec("Spec", [], [], [], undefined, "v1.0.0");
-        spec.upgradeToV2();
-        expect(spec.schemaVersion).toBe("v2.0.0");
-        expect(spec.requiresUpgrade).toBe(false);
-    });
-});
-describe("FormSpec toJSON", () => {
-    it("serializes correctly", () => {
-        const field = FormField.fromObject({ name: "f1", displayName: "F1", type: "text", category: "c1" });
-        const spec = new FormSpec("Valid", [], [field], []);
-        const json = spec.toJSON();
-        expect(json.displayName).toBe("Valid");
-        expect(json.$schema).toBeDefined();
-        expect(json.fields.f1).toBeDefined();
-        expect(json.fields.f1.name).toBeUndefined();
-    });
-    it("cleans null and empty optional fields", () => {
-        const categories = [new FormFieldCategory("personal", "Personal Information")];
-        const fieldObj = {
-            name: "age",
-            displayName: "Age",
-            type: "number",
-            category: "personal",
-            visibleIf: null,
-            min: "",
-            max: undefined,
-        };
-        const fields = [FormField.fromObject(fieldObj)];
-        const pages = [{ id: "p1", title: "P1", fields: ["age"] }];
-        const spec = new FormSpec("Form", categories, fields, pages);
-        const json = spec.toJSON();
-        const ageField = json.fields.age;
-        expect(ageField.visibleIf).toBeUndefined();
-        expect(ageField.min).toBeUndefined();
-        expect(ageField.max).toBeUndefined();
-    });
-    it("persists defaultValue", () => {
-        const categories = [new FormFieldCategory("personal", "Personal Information")];
-        const fields = [
-            FormField.fromObject({
-                name: "amount",
-                displayName: "Loan Amount",
-                type: "number",
-                category: "personal",
-                defaultValue: "5000",
-            }),
-        ];
-        const pages = [{ id: "p1", title: "P1", fields: ["amount"] }];
-        const spec = new FormSpec("Form", categories, fields, pages);
-        const json = spec.toJSON();
-        expect(json.fields.amount.defaultValue).toBe("5000");
-    });
-});
-describe("FormSpec validate", () => {
-    it("valid form spec passes", () => {
-        const categories = [new FormFieldCategory("personal", "Personal Information")];
-        const fields = [
-            FormField.fromObject({ name: "full_name", displayName: "Full Name", type: "text", category: "personal" }),
-        ];
-        const pages = [{ id: "page1", title: "Step 1", fields: ["full_name"] }];
-        const spec = new FormSpec("Valid Form", categories, fields, pages);
-        const result = spec.validate();
-        expect(result.valid).toBe(true);
-    });
-    it("missing display name fails", () => {
-        const categories = [new FormFieldCategory("personal", "Personal Information")];
-        const fields = [
-            FormField.fromObject({ name: "full_name", displayName: "Full Name", type: "text", category: "personal" }),
-        ];
-        const pages = [{ id: "p1", title: "P1", fields: ["full_name"] }];
-        const spec = new FormSpec("", categories, fields, pages);
-        const result = spec.validate();
-        expect(result.valid).toBe(false);
-        expect(result.errors[0].message).toMatch(/displayName: Form display name is required/);
-    });
-    it("invalid schema version fails", () => {
-        const categories = [new FormFieldCategory("personal", "Personal Information")];
-        const fields = [
-            FormField.fromObject({ name: "full_name", displayName: "Full Name", type: "text", category: "personal" }),
-        ];
-        const pages = [{ id: "p1", title: "P1", fields: ["full_name"] }];
-        const spec = new FormSpec("Form", categories, fields, pages, "icon", "invalid-version");
-        const result = spec.validate();
-        expect(result.valid).toBe(false);
-        expect(result.errors[0].message).toMatch(/schemaVersion: must match pattern/);
-    });
-    it("orphaned category fails", () => {
-        const categories = [new FormFieldCategory("personal", "Personal Information")];
-        const fields = [
-            FormField.fromObject({
-                name: "full_name",
-                displayName: "Full Name",
-                type: "text",
-                category: "non-existent-category",
-            }),
-        ];
-        const pages = [{ id: "p1", title: "P1", fields: ["full_name"] }];
-        const spec = new FormSpec("Form", categories, fields, pages);
-        const result = spec.validate();
-        expect(result.valid).toBe(false);
-        expect(result.errors[0].message).toMatch(/references non-existent category/);
-    });
-    it("page referencing non-existent field fails", () => {
-        const categories = [new FormFieldCategory("personal", "Personal Information")];
-        const fields = [
-            FormField.fromObject({ name: "full_name", displayName: "Full Name", type: "text", category: "personal" }),
-        ];
-        const pages = [{ id: "page1", title: "Step 1", fields: ["missing_field"] }];
-        const spec = new FormSpec("Form", categories, fields, pages);
-        const result = spec.validate();
-        expect(result.valid).toBe(false);
-        expect(result.errors[0].message).toMatch(/references non-existent field/);
-    });
-});
-describe("FormSpec fromJSON", () => {
-    it("throws for missing schemaVersion", () => {
-        expect(() => FormSpec.fromJSON(JSON.stringify({ displayName: "Err" }))).toThrow(/schemaVersion is missing/);
-    });
-    it("throws for outdated version", () => {
-        expect(() => FormSpec.fromJSON(JSON.stringify({ schemaVersion: "v0.9.0", displayName: "Err" }))).toThrow(/outdated schema version/);
-    });
-    it("throws for missing displayName", () => {
-        expect(() => FormSpec.fromJSON(JSON.stringify({ schemaVersion: "v1.0.0" }))).toThrow(/displayName is missing/);
-    });
-    it("throws for missing categories", () => {
-        expect(() => FormSpec.fromJSON(JSON.stringify({ schemaVersion: "v1.0.0", displayName: "D" }))).toThrow(/categories is missing/);
-    });
-    it("throws for missing fields", () => {
-        expect(() => FormSpec.fromJSON(JSON.stringify({ schemaVersion: "v1.0.0", displayName: "D", categories: [] }))).toThrow(/fields is missing/);
-    });
-    it("throws for invalid JSON", () => {
-        expect(() => FormSpec.fromJSON("invalid")).toThrow();
-    });
-    it("parses legacy fields array with categoryId", () => {
-        const legacyJson = {
-            schemaVersion: "v1.0.0",
-            displayName: "Legacy",
-            categories: [{ id: 1, name: "C1" }],
-            fields: [{ name: "f1", displayName: "F1", type: "text", categoryId: 1 }],
-        };
-        const spec = FormSpec.fromJSON(JSON.stringify(legacyJson));
-        expect(spec.fields.length).toBe(1);
-        expect(spec.pages.length).toBe(1);
-    });
-    it("parses v2 object fields format", () => {
-        const v2Json = {
-            schemaVersion: "v2.0.0",
-            displayName: "v2",
-            categories: [{ id: "c1", name: "C1" }],
-            fields: { f1: { displayName: "F1", type: "text", category: "c1" } },
-            pages: [{ id: "p1", fields: ["f1"] }],
-        };
-        const spec = FormSpec.fromJSON(JSON.stringify(v2Json));
-        expect(spec.fields.length).toBe(1);
-        expect(spec.fields[0].name).toBe("f1");
-    });
-    it("generates default pages when missing", () => {
-        const v2NoPages = {
-            schemaVersion: "v2.0.0",
-            displayName: "v2",
-            categories: [{ id: "c1", name: "C1" }],
-            fields: { f1: { displayName: "F1", type: "text", category: "c1" } },
-        };
-        const spec = FormSpec.fromJSON(JSON.stringify(v2NoPages));
-        expect(spec.pages.length).toBe(1);
-    });
-    it("throws error when displayName is missing from JSON", () => {
-        const formSpecFile = {
-            schemaVersion: "v2.0.0",
-            categories: [{ id: "1", name: "Basic Information" }],
-            fields: {
-                dateOfBirth: {
-                    displayName: "Date of Birth",
-                    type: "text",
-                    inputType: "date",
-                    category: "2",
-                    visible: false,
-                },
-            },
-            pages: [{ id: "page-1", fields: ["dateOfBirth"] }],
-        };
-        expect(() => FormSpec.fromJSON(JSON.stringify(formSpecFile))).toThrow("Invalid JSON: displayName is missing or invalid");
-    });
-    it("throws error when categories are missing from JSON", () => {
-        const formSpecFile = {
-            schemaVersion: "v2.0.0",
-            displayName: "test",
-            fields: {
-                dateOfBirth: {
-                    displayName: "Date of Birth",
-                    type: "text",
-                    inputType: "date",
-                    category: "2",
-                    visible: false,
-                },
-            },
-            pages: [{ id: "page-1", fields: ["dateOfBirth"] }],
-        };
-        expect(() => FormSpec.fromJSON(JSON.stringify(formSpecFile))).toThrow("Invalid JSON: categories is missing or invalid");
-    });
-    it("throws error when fields are missing from JSON", () => {
-        const formSpecFile = {
-            schemaVersion: "v2.0.0",
-            displayName: "test",
-            categories: [{ id: "1", name: "Basic Information" }],
-            pages: [{ id: "page-1", fields: ["dateOfBirth"] }],
-        };
-        expect(() => FormSpec.fromJSON(JSON.stringify(formSpecFile))).toThrow("Invalid JSON: fields is missing or invalid");
-    });
-});
-describe("FormFieldCategory", () => {
-    it("manages id, name, and toJSON", () => {
-        const category = new FormFieldCategory("cat1", "Category 1");
-        expect(category.id).toBe("cat1");
-        expect(category.name).toBe("Category 1");
-        category.name = "Updated Category";
-        expect(category.name).toBe("Updated Category");
-        expect(category.toJSON()).toEqual({
-            id: "cat1",
-            name: "Updated Category",
-        });
-    });
-    it("converts numeric id to string", () => {
-        const category = new FormFieldCategory(42, "Test");
-        expect(category.id).toBe("42");
-    });
-});

package/dist/rhf-generator.d.ts

@@ -1,30 +0,0 @@
-import { z } from "zod";
-import { type UnifiedFormConfig, type ResolvedField, type Category, type FieldGroup } from "./survey-generator.js";
-export interface RHFStep {
-    id: number;
-    title: string;
-    description?: string;
-    fields: ResolvedField[];
-    showCategoryHeadings: boolean;
-    layout?: "default" | "grid" | "vertical";
-}
-export interface RHFSchemaOutput {
-    zodSchema: z.ZodTypeAny;
-    baseSchema: z.ZodObject<any>;
-    defaultValues: Record<string, any>;
-    fields: ResolvedField[];
-    groupedFields: FieldGroup[];
-    steps: RHFStep[];
-    displayName: string;
-    categories: Category[];
-    templateIcon?: string;
-}
-export declare function generateRHFSchema(config: UnifiedFormConfig): RHFSchemaOutput;
-/**
- * Get Zod schema for a specific step
- */
-export declare function getStepSchema(step: RHFStep, fullSchema: any): z.ZodTypeAny;
-/**
- * Extract default values for a specific step
- */
-export declare function getStepDefaultValues(step: RHFStep, allDefaults: Record<string, any>): Record<string, any>;