@statezero/core 0.1.2 → 0.1.3-9.2

package/dist/cli/commands/syncModels.js

@@ -97,32 +97,27 @@ import { loadConfigFromFile } from "../configFileLoader.js";
 // Fallback Selection for Inquirer Errors
 // --------------------
 /**
- * Simple fallback selector when inquirer fails
+ * Simple fallback that generates all models when inquirer fails
  * @param {Array} choices - Array of choice objects with {name, value, checked} properties
  * @param {string} message - Selection message
- * @returns {Promise<Array>} - Selected values
+ * @returns {Promise<Array>} - All model values
  */
-async function fallbackSelect(choices, message) {
+async function fallbackSelectAll(choices, message) {
     console.log(`\n${message}`);
-    console.log("Interactive selection not available - auto-selecting all available models:");
-    const selected = [];
+    console.log("Interactive selection not available - generating ALL models:");
+    const allModels = [];
     for (const choice of choices) {
         // Skip separators (they don't have a 'value' property)
         if (!choice.value) {
             console.log(choice.name); // Print separator text
             continue;
         }
-        // Auto-select items that were checked by default
-        if (choice.checked) {
-            selected.push(choice.value);
-            console.log(`  ✓ ${choice.name}`);
-        }
-        else {
-            console.log(`    ${choice.name}`);
-        }
+        // Add ALL models, regardless of checked status
+        allModels.push(choice.value);
+        console.log(`  ✓ ${choice.name}`);
     }
-    console.log(`\nAuto-selected ${selected.length} models for generation.`);
-    return selected;
+    console.log(`\nGenerating ALL ${allModels.length} models.`);
+    return allModels;
 }
 /**
  * Model selection with inquirer fallback
@@ -146,9 +141,9 @@ async function selectModels(choices, message) {
         return selectedModels;
     }
     catch (error) {
-        // Fall back to auto-selection if inquirer fails for any reason
-        console.warn("Interactive selection failed, falling back to auto-selection:", error.message);
-        return await fallbackSelect(choices, message);
+        // Fall back to generating all models if inquirer fails for any reason
+        console.warn("Interactive selection failed, generating all models:", error.message);
+        return await fallbackSelectAll(choices, message);
     }
 }
 // --------------------
@@ -164,7 +159,7 @@ const JS_MODEL_TEMPLATE = `/**
 
 import { Model, Manager, QuerySet, getModelClass } from '{{modulePath}}';
 import { wrapReactiveModel } from '{{modulePath}}';
-import schemaData from './{{className}}.schema.json';
+import schemaData from './{{toLowerCase className}}.schema.json';
 
 /**
  * Model-specific QuerySet implementation
@@ -232,22 +227,6 @@ export class {{className}} extends Model {
       });
     });
   }
-
-  /**
-   * Serialize the model's data.
-   * Returns a plain object containing the current values of all fields,
-   * including raw IDs for relationship fields.
-   * @returns {Object}
-   */
-  serialize() {
-    const data = {};
-    // Simply assign the current value of each field.
-    // No special handling or PK extraction for relationships here.
-    {{#each properties}}
-    data.{{name}} = this.{{name}};
-    {{/each}}
-    return data;
-  }
 }
 `;
 // Updated TS_DECLARATION_TEMPLATE with improved relationship handling
@@ -504,6 +483,9 @@ Handlebars.registerHelper("ifDefaultProvided", function (defaultValue, options)
 Handlebars.registerHelper("isRequired", function (required) {
     return required ? "" : "?";
 });
+Handlebars.registerHelper("toLowerCase", function (str) {
+    return str.toLowerCase();
+});
 const jsTemplate = Handlebars.compile(JS_MODEL_TEMPLATE);
 const dtsTemplate = Handlebars.compile(TS_DECLARATION_TEMPLATE);
 // --------------------

package/dist/cli/index.js

@@ -1,14 +1,22 @@
 #!/usr/bin/env node
-import dotenv from 'dotenv';
+import dotenv from "dotenv";
 dotenv.config();
-import yargs from 'yargs';
-import { hideBin } from 'yargs/helpers';
-import { generateSchema } from './commands/syncModels.js';
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { generateSchema } from "./commands/syncModels.js";
+import { generateActions } from "./commands/syncActions.js";
+import { sync } from "./commands/sync.js"; // Import the new combined sync function
 yargs(hideBin(process.argv))
-    .command('sync-models', 'Generate model classes from the openapi schema', 
-// No CLI options since API_URL and GENERATED_TYPES_DIR are read from .env.
-{}, async () => {
-    await generateSchema({});
+    // The new 'sync' command
+    .command("sync", "Synchronize both models and actions from the backend", {}, // Builder for command-specific options (if any)
+async (argv) => {
+    await sync(argv);
 })
-    .help()
-    .argv;
+    .command("sync-models", "Generate model classes from the backend schema", {}, async (argv) => {
+    await generateSchema(argv);
+})
+    .command("sync-actions", "Generate action functions from the backend schema", {}, async (argv) => {
+    await generateActions(); // This function does not take arguments
+})
+    .demandCommand(1, "You must provide a command to run. Use --help to see available commands.")
+    .help().argv;

package/dist/config.d.ts

@@ -29,6 +29,10 @@ export function initializeAllEventReceivers(): Object;
  * @param {Function} getterFn - The getModelClass function imported from model-registry.js
  */
 export function registerModelGetter(getterFn: Function): void;
+/**
+ * Helper function to build file URLs
+ */
+export function buildFileUrl(fileUrl: any, backendKey?: string): any;
 /**
  * Get a model class by name using the registered getter.
  *
@@ -47,6 +51,7 @@ export namespace configInstance {
     export { initializeEventReceiver };
     export { registerModelGetter };
     export { getModelClass };
+    export { buildFileUrl };
 }
 export default configInstance;
 import { PusherEventReceiver } from './core/eventReceivers.js';

package/dist/config.js

@@ -44,15 +44,23 @@ const eventConfigSchema = z.object({
     }
 });
 const backendSchema = z.object({
-    API_URL: z.string().url('API_URL must be a valid URL'),
-    GENERATED_TYPES_DIR: z.string({ required_error: 'GENERATED_TYPES_DIR is required' }),
+    API_URL: z.string().url("API_URL must be a valid URL"),
+    GENERATED_TYPES_DIR: z.string({
+        required_error: "GENERATED_TYPES_DIR is required",
+    }),
+    GENERATED_ACTIONS_DIR: z.string().optional(),
     BACKEND_TZ: z.string().optional(),
-    fileUploadMode: z.enum(['server', 's3']).default('server'),
-    getAuthHeaders: z.function().optional()
-        .refine((fn) => fn === undefined || typeof fn === 'function', 'getAuthHeaders must be a function if provided'),
-    eventInterceptor: z.function().optional()
-        .refine((fn) => fn === undefined || typeof fn === 'function', 'eventInterceptor must be a function if provided'),
-    events: z.lazy(() => eventConfigSchema.optional())
+    fileRootURL: z.string().url("fileRootURL must be a valid URL").optional(),
+    fileUploadMode: z.enum(["server", "s3"]).default("server"),
+    getAuthHeaders: z
+        .function()
+        .optional()
+        .refine((fn) => fn === undefined || typeof fn === "function", "getAuthHeaders must be a function if provided"),
+    eventInterceptor: z
+        .function()
+        .optional()
+        .refine((fn) => fn === undefined || typeof fn === "function", "eventInterceptor must be a function if provided"),
+    events: z.lazy(() => eventConfigSchema.optional()),
 });
 const configSchema = z.object({
     backendConfigs: z.record(z.string(), backendSchema)
@@ -76,7 +84,8 @@ const configSchema = z.object({
             }
         }
         return { message: errors.join('; ') };
-    })
+    }),
+    periodicSyncIntervalSeconds: z.number().min(5).nullable().optional().default(null),
 });
 // Internal variable to hold the validated configuration.
 let config = null;
@@ -212,6 +221,26 @@ export function registerModelGetter(getterFn) {
     }
     modelGetter = getterFn;
 }
+/**
+ * Helper function to build file URLs
+ */
+export function buildFileUrl(fileUrl, backendKey = 'default') {
+    // If URL is already absolute (cloud storage), use it as-is
+    if (fileUrl && fileUrl.startsWith('http')) {
+        return fileUrl;
+    }
+    const cfg = getConfig();
+    const backend = cfg.backendConfigs[backendKey];
+    if (!backend) {
+        throw new ConfigError(`Backend "${backendKey}" not found in configuration.`);
+    }
+    // If no fileRootURL provided, return relative URL as-is
+    if (!backend.fileRootURL) {
+        return fileUrl;
+    }
+    // Construct full URL
+    return backend.fileRootURL.replace(/\/$/, '') + fileUrl;
+}
 /**
  * Get a model class by name using the registered getter.
  *
@@ -237,6 +266,7 @@ export const configInstance = {
     setBackendConfig,
     initializeEventReceiver,
     registerModelGetter,
-    getModelClass
+    getModelClass,
+    buildFileUrl
 };
 export default configInstance;

package/dist/flavours/django/dates.js

@@ -23,7 +23,7 @@ export class DateParsingHelpers {
         // Get field-specific format from schema
         const formatStrings = {
             'date': schema.date_format,
-            'datetime': schema.datetime_format
+            'date-time': schema.datetime_format
         };
         const dateFormat = formatStrings[fieldFormat];
         // Check if format is supported
@@ -56,13 +56,13 @@ export class DateParsingHelpers {
             return date;
         }
         const fieldFormat = schema.properties[fieldName].format;
-        if (!["date", "datetime"].includes(fieldFormat)) {
+        if (!["date", "date-time"].includes(fieldFormat)) {
             throw new Error(`Only date and date-time fields can be processed to JS date objects. ${fieldName} has format ${fieldFormat}`);
         }
         // Get field-specific format from schema
         const formatStrings = {
             'date': schema.date_format,
-            'datetime': schema.datetime_format
+            'date-time': schema.datetime_format
         };
         const dateFormat = formatStrings[fieldFormat];
         // Check if format is supported

package/dist/flavours/django/files.d.ts

@@ -5,10 +5,10 @@ export class FileObject {
     static configKey: string;
     static MIN_CHUNK_SIZE: number;
     constructor(file: any, options?: {});
-    name: string;
-    size: number;
-    type: string;
-    lastModified: number;
+    name: any;
+    size: any;
+    type: any;
+    lastModified: number | null;
     uploaded: boolean;
     uploading: boolean;
     uploadResult: any;
@@ -21,6 +21,7 @@ export class FileObject {
     chunkSize: any;
     maxConcurrency: any;
     uploadPromise: any;
+    get isStoredFile(): any;
     get status(): "failed" | "uploading" | "uploaded" | "pending";
     get filePath(): any;
     get fileUrl(): any;
@@ -59,9 +60,9 @@ export class FileObject {
     getBlob(): Blob;
     waitForUpload(): Promise<any>;
     toJSON(): {
-        name: string;
-        size: number;
-        type: string;
+        name: any;
+        size: any;
+        type: any;
         status: string;
         uploaded: boolean;
         filePath: any;

package/dist/flavours/django/files.js

@@ -5,9 +5,37 @@ import PQueue from "p-queue";
  * FileObject - A file wrapper that handles uploads to StateZero backend
  */
 export class FileObject {
+    // Simple changes to FileObject constructor
     constructor(file, options = {}) {
+        // Handle stored file data (from API)
+        if (file &&
+            typeof file === "object" &&
+            file.file_path &&
+            !(file instanceof File)) {
+            // This is stored file data from the backend
+            this.name = file.file_name;
+            this.size = file.size;
+            this.type = file.mime_type; // Now coming from backend
+            this.lastModified = null;
+            // Mark as already uploaded
+            this.uploaded = true;
+            this.uploading = false;
+            this.uploadResult = file; // Store the entire response
+            this.uploadError = null;
+            this.fileData = null;
+            // No upload properties needed
+            this.uploadType = null;
+            this.uploadId = null;
+            this.totalChunks = 0;
+            this.completedChunks = 0;
+            this.chunkSize = null;
+            this.maxConcurrency = null;
+            this.uploadPromise = Promise.resolve(this.uploadResult);
+            return;
+        }
+        // Handle File objects (for upload) - existing code
         if (!file || !(file instanceof File)) {
-            throw new Error("FileObject requires a File object");
+            throw new Error("FileObject requires a File object or stored file data");
         }
         // Store file metadata directly
         this.name = file.name;
@@ -33,6 +61,9 @@ export class FileObject {
         this.maxConcurrency = options.maxConcurrency || 3;
         this.uploadPromise = this._initializeAndStartUpload(file, options);
     }
+    get isStoredFile() {
+        return this.uploaded && !this.fileData && this.uploadResult?.file_path;
+    }
     get status() {
         if (this.uploadError)
             return "failed";
@@ -46,7 +77,10 @@ export class FileObject {
         return this.uploadResult?.file_path;
     }
     get fileUrl() {
-        return this.uploadResult?.file_url;
+        if (!this.uploadResult?.file_url) {
+            return null;
+        }
+        return configInstance.buildFileUrl(this.uploadResult.file_url, this.constructor.configKey);
     }
     async _initializeAndStartUpload(file, options) {
         const config = configInstance.getConfig();

package/dist/flavours/django/model.d.ts

@@ -35,6 +35,14 @@ export class Model {
      * @throws {ValidationError} If an unknown key is found.
      */
     static validateFields(data: Object): void;
+    /**
+     * Static method to validate data without creating an instance
+     * @param {Object} data - Data to validate
+     * @param {string} validateType - 'create' or 'update'
+     * @param {boolean} partial - Whether to allow partial validation
+     * @returns {Promise<boolean>} Promise that resolves to true if valid, throws error if invalid
+     */
+    static validate(data: Object, validateType?: string, partial?: boolean): Promise<boolean>;
     constructor(data?: {});
     _data: {};
     _pk: any;
@@ -105,6 +113,13 @@ export class Model {
      * @throws {Error} If the instance has not been saved (no primary key).
      */
     refreshFromDb(): Promise<void>;
+    /**
+     * Validates the model instance using the same serialize behavior as save()
+     * @param {string} validateType - 'create' or 'update' (defaults to auto-detect)
+     * @param {boolean} partial - Whether to allow partial validation
+     * @returns {Promise<boolean>} Promise that resolves to true if valid, throws error if invalid
+     */
+    validate(validateType?: string, partial?: boolean): Promise<boolean>;
 }
 /**
  * A constructor for a Model.

package/dist/flavours/django/model.js

@@ -1,10 +1,18 @@
-import { Manager } from './manager.js';
-import { ValidationError } from './errors.js';
-import { modelStoreRegistry } from '../../syncEngine/registries/modelStoreRegistry.js';
-import { isNil } from 'lodash-es';
-import { QueryExecutor } from './queryExecutor';
-import { wrapReactiveModel } from '../../reactiveAdaptor.js';
-import { DateParsingHelpers } from './dates.js';
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+import { Manager } from "./manager.js";
+import { ValidationError } from "./errors.js";
+import { modelStoreRegistry } from "../../syncEngine/registries/modelStoreRegistry.js";
+import { isNil } from "lodash-es";
+import { QueryExecutor } from "./queryExecutor";
+import { wrapReactiveModel } from "../../reactiveAdaptor.js";
+import { DateParsingHelpers } from "./dates.js";
+import { FileObject } from './files.js';
+import { configInstance } from "../../config.js";
+import { parseStateZeroError, MultipleObjectsReturned, DoesNotExist, } from "./errors.js";
+import axios from "axios";
 /**
  * A constructor for a Model.
  *
@@ -54,7 +62,7 @@ export class Model {
      * Instantiate from pk using queryset scoped singletons
      */
     static fromPk(pk, querySet) {
-        let qsId = querySet ? querySet.__uuid : '';
+        let qsId = querySet ? querySet.__uuid : "";
         let key = `${qsId}__${this.configKey}__${this.modelName}__${pk}`;
         if (!this.instanceCache.has(key)) {
             const instance = new this();
@@ -70,6 +78,7 @@ export class Model {
      * @returns {any} The field value
      */
     getField(field) {
+        var _a;
         // Access the reactive __version property to establish dependency for vue integration
         const trackVersion = this.__version;
         const ModelClass = this.constructor;
@@ -78,11 +87,39 @@ export class Model {
         // check local overrides
         let value = this._data[field];
         // if its not been overridden, get it from the store
-        if (isNil(value) && !isNil(this._pk)) {
+        if (value === undefined && !isNil(this._pk)) {
             let storedValue = modelStoreRegistry.getEntity(ModelClass, this._pk);
             if (storedValue)
                 value = storedValue[field]; // if stops null -> undefined
         }
+        // Date/DateTime fields need special handling - convert to Date objects
+        const dateFormats = ["date", "datetime", "date-time"];
+        if (ModelClass.schema &&
+            dateFormats.includes(ModelClass.schema.properties[field]?.format) &&
+            value) {
+            // Let DateParsingHelpers.parseDate throw if it fails
+            return DateParsingHelpers.parseDate(value, field, ModelClass.schema);
+        }
+        // File/Image fields need special handling - wrap as FileObject
+        const fileFormats = ["file-path", "image-path"];
+        if (ModelClass.schema &&
+            fileFormats.includes(ModelClass.schema.properties[field]?.format) &&
+            value) {
+            // Check if it's already a FileObject
+            if (value instanceof FileObject) {
+                return value;
+            }
+            // If it's stored file data from API, wrap it as FileObject
+            if (typeof value === "object" && value.file_path) {
+                // Create anonymous subclass with correct configKey
+                const BackendFileObject = (_a = class extends FileObject {
+                    },
+                    __setFunctionName(_a, "BackendFileObject"),
+                    _a.configKey = ModelClass.configKey,
+                    _a);
+                return new BackendFileObject(value);
+            }
+        }
         // relationship fields need special handling
         if (ModelClass.relationshipFields.has(field) && value) {
             // fetch the stored value
@@ -90,15 +127,15 @@ export class Model {
             // footgun - fieldInfo.ModelClass() calls the arrow function that lazily gets the model class
             let relPkField = fieldInfo.ModelClass().primaryKeyField;
             switch (fieldInfo.relationshipType) {
-                case 'many-to-many':
+                case "many-to-many":
                     // value is an array
                     if (!Array.isArray(value) && value)
                         throw new Error(`Data corruption: m2m field for ${ModelClass.modelName} stored as ${value}`);
                     // set each pk to the full model object for that pk
-                    value = value.map(pk => fieldInfo.ModelClass().fromPk(pk));
+                    value = value.map((pk) => fieldInfo.ModelClass().fromPk(pk));
                     break;
-                case 'one-to-one':
-                case 'foreign-key':
+                case "one-to-one":
+                case "foreign-key":
                     // footgun - fieldInfo.ModelClass() calls the arrow function that lazily gets the model class
                     if (!isNil(value))
                         value = fieldInfo.ModelClass().fromPk(value);
@@ -135,13 +172,13 @@ export class Model {
             return;
         const allowedFields = this.fields;
         for (const key of Object.keys(data)) {
-            if (key === 'repr' || key === 'type')
+            if (key === "repr" || key === "type")
                 continue;
             // Handle nested fields by splitting on double underscore
             // and taking just the base field name
-            const baseField = key.split('__')[0];
+            const baseField = key.split("__")[0];
             if (!allowedFields.includes(baseField)) {
-                let errorMsg = `Invalid field: ${baseField}. Allowed fields are: ${allowedFields.join(', ')}`;
+                let errorMsg = `Invalid field: ${baseField}. Allowed fields are: ${allowedFields.join(", ")}`;
                 console.error(errorMsg);
                 throw new ValidationError(errorMsg);
             }
@@ -160,11 +197,19 @@ export class Model {
         // check local overrides
         let value = this._data[field];
         // if it's not been overridden, get it from the store
-        if (isNil(value) && !isNil(this._pk)) {
+        if (value === undefined && !isNil(this._pk)) {
             let storedValue = modelStoreRegistry.getEntity(ModelClass, this._pk);
             if (storedValue)
                 value = storedValue[field];
         }
+        // Date/DateTime fields need special handling - convert Date objects to strings for API
+        const dateFormats = ["date", "date-time"];
+        if (ModelClass.schema &&
+            dateFormats.includes(ModelClass.schema.properties[field]?.format) &&
+            value instanceof Date) {
+            // Let DateParsingHelpers.serializeDate throw if it fails
+            return DateParsingHelpers.serializeDate(value, field, ModelClass.schema);
+        }
         return value;
     }
     /**
@@ -192,16 +237,20 @@ export class Model {
     async save() {
         const ModelClass = this.constructor;
         const pkField = ModelClass.primaryKeyField;
-        const querySet = !this.pk ? ModelClass.objects.newQuerySet() : ModelClass.objects.filter({ [pkField]: this.pk });
+        const querySet = !this.pk
+            ? ModelClass.objects.newQuerySet()
+            : ModelClass.objects.filter({ [pkField]: this.pk });
         const data = this.serialize();
         let instance;
         if (!this.pk) {
             // Create new instance
-            instance = await QueryExecutor.execute(querySet, 'create', { data });
+            instance = await QueryExecutor.execute(querySet, "create", { data });
         }
         else {
             // Update existing instance
-            instance = await QueryExecutor.execute(querySet, 'update_instance', { data });
+            instance = await QueryExecutor.execute(querySet, "update_instance", {
+                data,
+            });
         }
         this._pk = instance.pk;
         this._data = {};
@@ -218,14 +267,14 @@ export class Model {
      */
     async delete() {
         if (!this.pk) {
-            throw new Error('Cannot delete unsaved instance');
+            throw new Error("Cannot delete unsaved instance");
         }
         const ModelClass = this.constructor;
         const pkField = ModelClass.primaryKeyField;
         const querySet = ModelClass.objects.filter({ [pkField]: this.pk });
         // Pass the instance data with primary key as the args
         const args = { [pkField]: this.pk };
-        const result = await QueryExecutor.execute(querySet, 'delete_instance', args);
+        const result = await QueryExecutor.execute(querySet, "delete_instance", args);
         // result -> [deletedCount, { [modelName]: deletedCount }];
         return result;
     }
@@ -237,13 +286,83 @@ export class Model {
      */
     async refreshFromDb() {
         if (!this.pk) {
-            throw new Error('Cannot refresh unsaved instance');
+            throw new Error("Cannot refresh unsaved instance");
         }
         const ModelClass = this.constructor;
-        const fresh = await ModelClass.objects.get({ [ModelClass.primaryKeyField]: this.pk });
+        const fresh = await ModelClass.objects.get({
+            [ModelClass.primaryKeyField]: this.pk,
+        });
         // clear the current data and fresh data will flow
         this._data = {};
     }
+    /**
+     * Validates the model instance using the same serialize behavior as save()
+     * @param {string} validateType - 'create' or 'update' (defaults to auto-detect)
+     * @param {boolean} partial - Whether to allow partial validation
+     * @returns {Promise<boolean>} Promise that resolves to true if valid, throws error if invalid
+     */
+    async validate(validateType = null, partial = false) {
+        const ModelClass = this.constructor;
+        if (!validateType) {
+            validateType = this.pk ? "update" : "create";
+        }
+        // Validate the validateType parameter
+        if (!["update", "create"].includes(validateType)) {
+            throw new Error(`Validation type must be 'update' or 'create', not '${validateType}'`);
+        }
+        // Use the same serialize logic as save()
+        const data = this.serialize();
+        // Delegate to static method
+        return ModelClass.validate(data, validateType, partial);
+    }
+    /**
+     * Static method to validate data without creating an instance
+     * @param {Object} data - Data to validate
+     * @param {string} validateType - 'create' or 'update'
+     * @param {boolean} partial - Whether to allow partial validation
+     * @returns {Promise<boolean>} Promise that resolves to true if valid, throws error if invalid
+     */
+    static async validate(data, validateType = "create", partial = false) {
+        const ModelClass = this;
+        // Validate the validateType parameter
+        if (!["update", "create"].includes(validateType)) {
+            throw new Error(`Validation type must be 'update' or 'create', not '${validateType}'`);
+        }
+        // Get backend config and check if it exists
+        const config = configInstance.getConfig();
+        const backend = config.backendConfigs[ModelClass.configKey];
+        if (!backend) {
+            throw new Error(`No backend configuration found for key: ${ModelClass.configKey}`);
+        }
+        // Build URL for validate endpoint
+        const baseUrl = backend.API_URL.replace(/\/+$/, "");
+        const url = `${baseUrl}/${ModelClass.modelName}/validate/`;
+        // Prepare headers
+        const headers = {
+            "Content-Type": "application/json",
+            ...(backend.getAuthHeaders ? backend.getAuthHeaders() : {}),
+        };
+        // Make direct API call to validate endpoint
+        try {
+            const response = await axios.post(url, {
+                data: data,
+                validate_type: validateType,
+                partial: partial,
+            }, { headers });
+            // Backend returns {"valid": true} on success
+            return response.data.valid === true;
+        }
+        catch (error) {
+            if (error.response && error.response.data) {
+                const parsedError = parseStateZeroError(error.response.data);
+                if (Error.captureStackTrace) {
+                    Error.captureStackTrace(parsedError, ModelClass.validate);
+                }
+                throw parsedError;
+            }
+            throw new Error(`Validation failed: ${error.message}`);
+        }
+    }
 }
 /**
  * Creates a new Model instance.