@seedprotocol/sdk 0.7.9-next.1189.g5e63267 → 0.7.9

package/dist/dist/Schema-BS8oR7QV.d.ts

@@ -1,432 +0,0 @@
-declare class Schema {
-    static create(schemaName: any, options: any): any;
-    /**
-     * Update the cache to use schemaFileId as the key instead of schemaName
-     * This should be called once the schema is loaded and we have the schemaFileId
-     * We keep the instance in BOTH caches for efficient lookups by either name or ID
-     */
-    static _updateCacheKey(schemaName: any, schemaFileId: any): void;
-    /**
-     * Get schema instance by schemaFileId (preferred method)
-     * Returns null if not found in cache
-     */
-    static getById(schemaFileId: any): any;
-    /**
-     * The cached schema with this file id or name, without taking a hold. For SDK code that reads
-     * the schema and doesn't hand it to a caller; callers that keep it use `create` or `find`.
-     */
-    static peek(schemaFileIdOrName: any): any;
-    /**
-     * Clear all cached Schema instances.
-     * This is primarily useful for test cleanup.
-     * All cached instances will be unloaded and removed from both caches.
-     */
-    static clearCache(): void;
-    /**
-     * Create or get schema instance by schemaFileId
-     * Queries the database to find the schema name if not cached
-     * @param schemaFileId - The schema file ID
-     * @returns Schema instance, with a hold taken (unless `hold: false`)
-     */
-    static createById(schemaFileId: any, options: any): Promise<any>;
-    /**
-     * Find schema instance by schemaFileId
-     * Waits for the schema to be fully loaded (idle state) by default
-     * @param options - Find options including schemaFileId and wait configuration
-     * @returns Schema instance if found, undefined otherwise
-     */
-    static find({ schemaFileId, waitForReady, readyTimeout, }: {
-        schemaFileId: any;
-        waitForReady?: boolean | undefined;
-        readyTimeout?: number | undefined;
-    }): Promise<any>;
-    /**
-     * Get instantiated Schema objects for all schemas (from database and files)
-     * By default, returns only the latest version of each schema and excludes the internal Seed Protocol schema.
-     * Uses loadAllSchemasFromDb() as the single source of truth, which intelligently merges database and file data.
-     * Takes no holds on the instances it returns: a caller that keeps one uses `Schema.create` or `Schema.find`.
-     *
-     * @param options - Configuration options
-     * @param options.includeAllVersions - If true, returns all versions of each schema. Default: false
-     * @param options.includeInternal - If true, includes the internal Seed Protocol schema. Default: false
-     * @returns Array of Schema instances
-     */
-    static all(options?: {}): Promise<any[]>;
-    /**
-     * Force-evict the cached Schema instance(s) named `schemaName`, ignoring refCounts: stop their live
-     * query and service. Schema.destroy does the same for itself. For code that deletes a schema's rows
-     * without destroying it (test cleanup): a live Schema keeps re-creating its models from its live
-     * query while their rows are being deleted.
-     */
-    static evict(schemaName: any): void;
-    constructor(schemaName: any);
-    _service: import("xstate").Actor<import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
-        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
-    }, {
-        src: "validateSchema";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "checkExistingSchema";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "writeSchemaToDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "verifySchemaInDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "writeModelsToDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "verifyModelsInDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "createModelInstances";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "verifyModelInstancesInCache";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "writePropertiesToDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "verifyPropertiesInDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "createPropertyInstances";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "verifyPropertyInstancesInCache";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    }, never, never, never, "error" | "idle" | "validating" | {
-        loading: "checkingExisting" | "writingSchema" | "verifyingSchema" | "writingModels" | "verifyingModels" | "creatingModelInstances" | "verifyingModelInstances" | "writingProperties" | "verifyingProperties" | "creatingPropertyInstances" | "verifyingPropertyInstances";
-    }, string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
-        id: "schema";
-        states: {
-            readonly loading: {
-                states: {
-                    readonly checkingExisting: {};
-                    readonly writingSchema: {};
-                    readonly verifyingSchema: {};
-                    readonly writingModels: {};
-                    readonly verifyingModels: {};
-                    readonly creatingModelInstances: {};
-                    readonly verifyingModelInstances: {};
-                    readonly writingProperties: {};
-                    readonly verifyingProperties: {};
-                    readonly creatingPropertyInstances: {};
-                    readonly verifyingPropertyInstances: {};
-                };
-            };
-            readonly idle: {};
-            readonly validating: {};
-            readonly error: {};
-        };
-    }, import("xstate").MetaObject>>;
-    getService(): import("xstate").Actor<import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
-        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
-    }, {
-        src: "validateSchema";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "checkExistingSchema";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "writeSchemaToDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "verifySchemaInDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "writeModelsToDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "verifyModelsInDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "createModelInstances";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "verifyModelInstancesInCache";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "writePropertiesToDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "verifyPropertiesInDb";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "createPropertyInstances";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    } | {
-        src: "verifyPropertyInstancesInCache";
-        logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-        id: string | undefined;
-    }, never, never, never, "error" | "idle" | "validating" | {
-        loading: "checkingExisting" | "writingSchema" | "verifyingSchema" | "writingModels" | "verifyingModels" | "creatingModelInstances" | "verifyingModelInstances" | "writingProperties" | "verifyingProperties" | "creatingPropertyInstances" | "verifyingPropertyInstances";
-    }, string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
-        id: "schema";
-        states: {
-            readonly loading: {
-                states: {
-                    readonly checkingExisting: {};
-                    readonly writingSchema: {};
-                    readonly verifyingSchema: {};
-                    readonly writingModels: {};
-                    readonly verifyingModels: {};
-                    readonly creatingModelInstances: {};
-                    readonly verifyingModelInstances: {};
-                    readonly writingProperties: {};
-                    readonly verifyingProperties: {};
-                    readonly creatingPropertyInstances: {};
-                    readonly verifyingPropertyInstances: {};
-                };
-            };
-            readonly idle: {};
-            readonly validating: {};
-            readonly error: {};
-        };
-    }, import("xstate").MetaObject>>;
-    _getSnapshot(): import("xstate").MachineSnapshot<{}, import("xstate").AnyEventObject, {
-        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
-    }, "error" | "idle" | "validating" | {
-        loading: "checkingExisting" | "writingSchema" | "verifyingSchema" | "writingModels" | "verifyingModels" | "creatingModelInstances" | "verifyingModelInstances" | "writingProperties" | "verifyingProperties" | "creatingPropertyInstances" | "verifyingPropertyInstances";
-    }, string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
-        id: "schema";
-        states: {
-            readonly loading: {
-                states: {
-                    readonly checkingExisting: {};
-                    readonly writingSchema: {};
-                    readonly verifyingSchema: {};
-                    readonly writingModels: {};
-                    readonly verifyingModels: {};
-                    readonly creatingModelInstances: {};
-                    readonly verifyingModelInstances: {};
-                    readonly writingProperties: {};
-                    readonly verifyingProperties: {};
-                    readonly creatingPropertyInstances: {};
-                    readonly verifyingPropertyInstances: {};
-                };
-            };
-            readonly idle: {};
-            readonly validating: {};
-            readonly error: {};
-        };
-    }>;
-    _getSnapshotContext(): {};
-    get schemaName(): any;
-    get schemaFileId(): any;
-    get id(): any;
-    /**
-     * Returns Model instances for this schema
-     * This is a computed property that reads from the service context
-     * Note: This is NOT reactive - use useModels() hook for reactivity
-     */
-    get models(): any[];
-    get status(): "error" | "idle" | "validating" | {
-        loading: "checkingExisting" | "writingSchema" | "verifyingSchema" | "writingModels" | "verifyingModels" | "creatingModelInstances" | "verifyingModelInstances" | "writingProperties" | "verifyingProperties" | "creatingPropertyInstances" | "verifyingPropertyInstances";
-    };
-    get isEdited(): any;
-    get validationErrors(): any;
-    /**
-     * The error from the last draft save that an assignment started (e.g. `schema.name = ...`),
-     * such as a ConflictError; undefined once a later one succeeds.
-     */
-    get lastSaveError(): any;
-    get isValid(): boolean;
-    /**
-     * Validate the schema
-     * @returns Validation result
-     */
-    validate(): Promise<any>;
-    /**
-     * Build the file-format `models` object from this schema's Model instances: every model
-     * (those created at runtime too), each property as its file definition ({ id, type, model,
-     * ref, refValueType, required, storage, validation, ... }).
-     */
-    _buildModelsFromInstances(): Promise<{}>;
-    /**
-     * Saves all edited properties to a new schema version.
-     * This writes the changes to a new JSON file and clears the draft flags.
-     * Validates the schema before saving.
-     * Transitions schema from draft (DB-only) to published (file + DB).
-     * @returns The file path of the new schema version
-     */
-    saveNewVersion(): Promise<any>;
-    /**
-     * Check for conflicts between actor context and database
-     * @returns ConflictResult indicating if a conflict exists
-     */
-    _checkForConflicts(): Promise<{
-        hasConflict: boolean;
-        localVersion?: undefined;
-        dbVersion?: undefined;
-        localUpdatedAt?: undefined;
-        dbUpdatedAt?: undefined;
-        message?: undefined;
-    } | {
-        hasConflict: boolean;
-        localVersion: any;
-        dbVersion: any;
-        localUpdatedAt: any;
-        dbUpdatedAt: string;
-        message: string;
-    }>;
-    /**
-     * Reload schema from database
-     * This refreshes the actor context with the latest data from the database
-     */
-    reload(): Promise<any>;
-    /**
-     * Save the current schema state to the database as a draft
-     * This persists changes immediately without creating a new file version
-     * @param oldName - Optional old name to look up existing record before name change
-     * @param newName - Optional new name to use (if not provided, uses this.schemaName)
-     */
-    _saveDraftToDb(oldName: any, newName: any): Promise<void>;
-    unload(): void;
-    /**
-     * Destroy the schema instance completely: remove from caches, delete from database (cascade),
-     * and stop the service. Uses shared destroy helpers.
-     */
-    destroy(): Promise<void>;
-    _destroyRows(schemaFileId: any, schemaName: any, metadataName: any): Promise<void>;
-    /**
-     * Set up liveQuery subscription to watch for model changes in the database
-     * This enables cross-instance synchronization (e.g., changes in other tabs/windows)
-     */
-    _setupLiveQuerySubscription(): void;
-}
-declare namespace Schema {
-    let instanceCacheById: Map<any, any>;
-    let instanceCacheByName: Map<any, any>;
-    let pendingSchemaByName: Map<any, any>;
-    let savingSchemas: Set<any>;
-}
-declare var Schema$1: Readonly<{
-    __proto__: null;
-    Schema: typeof Schema;
-    schemaInstanceState: ActorKeyedState;
-}>;
-/**
- * Rename a property in a model
- * This is a convenience function that updates the property name
- * Note: This creates a new property and you may want to handle the old property separately
- * @param schemaName - The name of the schema
- * @param modelName - The name of the model
- * @param oldPropertyName - The current property name
- * @param newPropertyName - The new property name
- * @returns The file path of the new schema version
- */
-declare function renameModelProperty(schemaName: any, modelName: any, oldPropertyName: any, newPropertyName: any): Promise<any>;
-declare const schemaMachine: import("xstate").StateMachine<{}, import("xstate").AnyEventObject, {
-    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>> | undefined;
-}, {
-    src: "validateSchema";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-    id: string | undefined;
-} | {
-    src: "checkExistingSchema";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-    id: string | undefined;
-} | {
-    src: "writeSchemaToDb";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-    id: string | undefined;
-} | {
-    src: "verifySchemaInDb";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-    id: string | undefined;
-} | {
-    src: "writeModelsToDb";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-    id: string | undefined;
-} | {
-    src: "verifyModelsInDb";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-    id: string | undefined;
-} | {
-    src: "createModelInstances";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-    id: string | undefined;
-} | {
-    src: "verifyModelInstancesInCache";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-    id: string | undefined;
-} | {
-    src: "writePropertiesToDb";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-    id: string | undefined;
-} | {
-    src: "verifyPropertiesInDb";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-    id: string | undefined;
-} | {
-    src: "createPropertyInstances";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-    id: string | undefined;
-} | {
-    src: "verifyPropertyInstancesInCache";
-    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, import("xstate").NonReducibleUnknown, import("xstate").EventObject>;
-    id: string | undefined;
-}, never, never, never, "error" | "idle" | "validating" | {
-    loading: "checkingExisting" | "writingSchema" | "verifyingSchema" | "writingModels" | "verifyingModels" | "creatingModelInstances" | "verifyingModelInstances" | "writingProperties" | "verifyingProperties" | "creatingPropertyInstances" | "verifyingPropertyInstances";
-}, string, {}, import("xstate").NonReducibleUnknown, import("xstate").EventObject, import("xstate").MetaObject, {
-    id: "schema";
-    states: {
-        readonly loading: {
-            states: {
-                readonly checkingExisting: {};
-                readonly writingSchema: {};
-                readonly verifyingSchema: {};
-                readonly writingModels: {};
-                readonly verifyingModels: {};
-                readonly creatingModelInstances: {};
-                readonly verifyingModelInstances: {};
-                readonly writingProperties: {};
-                readonly verifyingProperties: {};
-                readonly creatingPropertyInstances: {};
-                readonly verifyingPropertyInstances: {};
-            };
-        };
-        readonly idle: {};
-        readonly validating: {};
-        readonly error: {};
-    };
-}, import("xstate").MetaObject>;
-/**
- * Update model properties in a schema and create a new version
- * @param schemaName - The name of the schema to update
- * @param propertyUpdates - Array of property updates to apply
- * @param modelUpdates - Optional array of model renames
- * @returns The file path of the new schema version
- * @throws Error if schema not found or updates are invalid
- */
-declare function updateModelProperties(schemaName: any, propertyUpdates: any, modelUpdates: any): Promise<any>;
-import { ak as ActorKeyedState } from './Item-CG5IhPtL.js';
-export { Schema as S, Schema$1 as a, renameModelProperty as r, schemaMachine as s, updateModelProperties as u };
-//# sourceMappingURL=Schema-BS8oR7QV.d.ts.map

package/dist/dist/Schema-BS8oR7QV.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Schema-BS8oR7QV.d.ts","sourceRoot":"","sources":["../Schema-BS8oR7QV.js"],"names":[],"mappings":"AAkhFA;IAiCI,kDAoPC;IACD;;;;OAIG;IACH,iEAaC;IACD;;;OAGG;IACH,uCAMC;IACD;;;OAGG;IACH,0CAGC;IACD;;;;OAIG;IACH,0BAwBC;IACD;;;;;OAKG;IACH,iEAgCC;IACD;;;;;OAKG;IACH;;;;qBAgBC;IACD;;;;;;;;;;OAUG;IACH,yCA+IC;IA01BD;;;;;OAKG;IACH,oCAkCC;IAn7CD,6BA+BC;IA3BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEE;IA4iBN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAEC;IACD;;;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IACD,0BAEC;IACD,sBAeC;IACD,wBAEC;IACD,cAEC;IACD;;;;OAIG;IACH,oBAmCC;IACD;;MAEC;IACD,oBAcC;IACD,4BAEC;IACD;;;OAGG;IACH,yBAEC;IACD,uBAGC;IACD;;;OAGG;IACH,yBA8BC;IACD;;;;OAIG;IACH,yCAoEC;IACD;;;;;;OAMG;IACH,+BAqLC;IACD;;;OAGG;IACH;;;;;;;;;;;;;;OAyCC;IACD;;;OAGG;IACH,uBAwBC;IACD;;;;;OAKG;IACH,0DAqXC;IA0CD,eAwCC;IACD;;;OAGG;IACH,yBAgCC;IACD,mFAqEC;IACD;;;OAGG;IACH,oCAgKC;CACJ;;;;;;;AAUD;;;;GAIG;AA54DH;;;;;;;;;GASG;AACH,gIAsGC;AAniCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAwgBG;AA2LH;;;;;;;GAOG;AACH,+GA6HC;sCA9wE2Q,oBAAoB"}

package/dist/dist/SchemaValidationService-CZzKNL04.d.ts

@@ -1,118 +0,0 @@
-/**
- * Service for validating schemas, models, and properties using TypeBox
- */
-export class SchemaValidationService {
-    /**
-     * Enhance TypeBox error message with expected values for union/literal types
-     */
-    enhanceErrorMessage(error: any, schema: any, fieldPath: any): any;
-    /**
-     * Extract expected values from a schema for a given field path
-     */
-    extractExpectedValues(schema: any, fieldPath: any): any;
-    /**
-     * Extract literal value from a schema
-     */
-    extractLiteralValue(schema: any, _fieldPath: any): any;
-    /**
-     * Get the schema for a specific field path
-     */
-    getSchemaForField(schema: any, fieldPath: any): any;
-    /**
-     * Validate a property structure against TProperty schema
-     */
-    validatePropertyStructure(property: any): {
-        isValid: boolean;
-        errors: {
-            field: string;
-            message: any;
-            code: string;
-            severity: string;
-        }[];
-    };
-    /**
-     * Validate a property value against its validation rules
-     * @param value - The value to validate
-     * @param dataType - The property's data type
-     * @param validationRules - Optional validation rules (enum, pattern, minLength, maxLength)
-     * @param refValueType - For List properties: the element type (Text, Number, etc.). When set, each array element is validated against this type + validationRules.
-     */
-    validatePropertyValue(value: any, dataType: any, validationRules: any, refValueType: any): any;
-    /**
-     * Validate a specific property within a schema
-     */
-    validateProperty(schema: any, modelName: any, propertyName: any, propertyData: any): {
-        isValid: boolean;
-        errors: {
-            field: string;
-            message: any;
-            code: string;
-            severity: string;
-        }[];
-    };
-    /**
-     * Validate model structure (basic structure checks)
-     */
-    validateModelStructure(model: any): {
-        isValid: boolean;
-        errors: {
-            field: string;
-            message: string;
-            code: string;
-            severity: string;
-        }[];
-    };
-    /**
-     * Validate a model against a schema WITHOUT requiring it to be in the schema's context
-     * This allows validation before registration, preventing update loops
-     */
-    validateModelAgainstSchema(schema: any, modelName: any, modelData: any): {
-        isValid: boolean;
-        errors: {
-            field: string;
-            message: any;
-            code: string;
-            severity: string;
-        }[];
-    };
-    /**
-     * Validate a model within a schema (requires model to already be in schema context)
-     */
-    validateModel(schema: any, modelName: any, _modelData: any): {
-        isValid: boolean;
-        errors: {
-            field: string;
-            message: any;
-            code: string;
-            severity: string;
-        }[];
-    };
-    /**
-     * Validate entire schema
-     */
-    validateSchema(schema: any): {
-        isValid: boolean;
-        errors: {
-            field: string;
-            message: any;
-            code: string;
-            severity: string;
-        }[];
-    };
-    /**
-     * Get base TypeBox schema for a data type
-     */
-    getBaseSchemaForDataType(dataType: any): import("@sinclair/typebox").TString | import("@sinclair/typebox").TAny | import("@sinclair/typebox").TArray<import("@sinclair/typebox").TAny> | import("@sinclair/typebox").TNumber | import("@sinclair/typebox").TBoolean | import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
-    /**
-     * Apply validation rules to a TypeBox schema. For Text and Html, pattern, minLength and
-     * maxLength combine into one string schema; enum further restricts the value to its list.
-     * (Each rule used to replace the schema built so far, so e.g. Text's default maxLength
-     * silently dropped any pattern.)
-     */
-    applyValidationRules(schema: any, dataType: any, rules: any): any;
-    /**
-     * Validate custom validation rules
-     */
-    validateCustomRules(value: any, rules: any): any[];
-}
-//# sourceMappingURL=SchemaValidationService-CZzKNL04.d.ts.map

package/dist/dist/SchemaValidationService-CZzKNL04.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SchemaValidationService-CZzKNL04.d.ts","sourceRoot":"","sources":["../SchemaValidationService-CZzKNL04.js"],"names":[],"mappings":"AA+BA;;GAEG;AACH;IACI;;OAEG;IACH,kEAqBC;IACD;;OAEG;IACH,wDAyDC;IACD;;OAEG;IACH,uDAgBC;IACD;;OAEG;IACH,oDA8BC;IACD;;OAEG;IACH;;;;;;;;MA2HC;IACD;;;;;;OAMG;IACH,+FAsJC;IACD;;OAEG;IACH;;;;;;;;MA2GC;IACD;;OAEG;IACH;;;;;;;;MAiCC;IACD;;;OAGG;IACH;;;;;;;;MAcC;IACD;;OAEG;IACH;;;;;;;;MA4BC;IACD;;OAEG;IACH;;;;;;;;MA4CC;IACD;;OAEG;IACH,mXAsBC;IACD;;;;;OAKG;IACH,kEA0BC;IACD;;OAEG;IACH,mDAOC;CACJ"}

package/dist/dist/backfillMetadataPropertyIds-C7P7FL6F.d.ts

@@ -1,7 +0,0 @@
-/**
- * Backfill metadata.property_id for rows that have model_type and property_name
- * but property_id is null. Run after migrations. Idempotent - only updates NULL rows.
- * Call after appDb is set (e.g. at end of prepareDb).
- */
-export function backfillMetadataPropertyIds(): Promise<number>;
-//# sourceMappingURL=backfillMetadataPropertyIds-C7P7FL6F.d.ts.map

package/dist/dist/backfillMetadataPropertyIds-C7P7FL6F.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backfillMetadataPropertyIds-C7P7FL6F.d.ts","sourceRoot":"","sources":["../backfillMetadataPropertyIds-C7P7FL6F.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH,+DA4CC"}