@statezero/core 0.1.75 → 0.1.77

package/dist/actions/default/django_app/process-data.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Process a list of numbers with various mathematical operations
+ *
+ * @param any[] data - List of numbers to process
+ * @param 'sum' | 'avg' | 'max' | 'min' operation - Mathematical operation to perform
+ * @param {Object} [axiosOverrides] - Allows overriding Axios request parameters.
+ * @returns {Promise<Object>} A promise that resolves with the action's result.
+ */
+export function processData(data: any, operation: any, axiosOverrides?: Object): Promise<Object>;
+export namespace processData {
+    let actionName: string;
+    let title: string;
+    let app: string;
+    let permissions: string[];
+    let configKey: string;
+}
+/**
+ * Zod schema for the input of processData.
+ * NOTE: This is an object schema for validating the data payload.
+ */
+export const processDataInputSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodAny, "many">;
+    operation: z.ZodEnum<["sum", "avg", "max", "min"]>;
+}, "strip", z.ZodTypeAny, {
+    data: any[];
+    operation: "min" | "max" | "avg" | "sum";
+}, {
+    data: any[];
+    operation: "min" | "max" | "avg" | "sum";
+}>;
+/**
+ * Zod schema for the response of processData.
+ */
+export const processDataResponseSchema: z.ZodObject<{
+    operation: z.ZodString;
+    result: z.ZodNumber;
+    processed_count: z.ZodNumber;
+    execution_time_ms: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    operation: string;
+    result: number;
+    processed_count: number;
+    execution_time_ms: number;
+}, {
+    operation: string;
+    result: number;
+    processed_count: number;
+    execution_time_ms: number;
+}>;
+export default processData;
+import { z } from 'zod';

package/dist/actions/{django_app → default/django_app}/process-data.js

@@ -5,7 +5,7 @@
  */
 import axios from 'axios';
 import { z } from 'zod';
-import { configInstance, parseStateZeroError } from '../../../src';
+import { configInstance, parseStateZeroError } from '../../../../src';
 /**
  * Zod schema for the input of processData.
  * NOTE: This is an object schema for validating the data payload.

package/dist/actions/default/django_app/send-notification.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Send notifications to multiple recipients
+ *
+ * @param string message - Notification message to send
+ * @param any[] recipients - List of email addresses to notify
+ * @param 'low' | 'high' priority - Notification priority level
+ * @param {Object} [axiosOverrides] - Allows overriding Axios request parameters.
+ * @returns {Promise<Object>} A promise that resolves with the action's result.
+ */
+export function sendNotification(message: any, recipients: any, priority?: string, axiosOverrides?: Object): Promise<Object>;
+export namespace sendNotification {
+    let actionName: string;
+    let title: string;
+    let app: string;
+    let permissions: string[];
+    let configKey: string;
+}
+/**
+ * Zod schema for the input of sendNotification.
+ * NOTE: This is an object schema for validating the data payload.
+ */
+export const sendNotificationInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    recipients: z.ZodArray<z.ZodAny, "many">;
+    priority: z.ZodDefault<z.ZodOptional<z.ZodEnum<["low", "high"]>>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    priority: "low" | "high";
+    recipients: any[];
+}, {
+    message: string;
+    recipients: any[];
+    priority?: "low" | "high" | undefined;
+}>;
+/**
+ * Zod schema for the response of sendNotification.
+ */
+export const sendNotificationResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message_id: z.ZodString;
+    sent_to: z.ZodNumber;
+    queued_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    message_id: string;
+    sent_to: number;
+    queued_at: string;
+}, {
+    success: boolean;
+    message_id: string;
+    sent_to: number;
+    queued_at: string;
+}>;
+export default sendNotification;
+import { z } from 'zod';

package/dist/actions/{django_app → default/django_app}/send-notification.js

@@ -5,7 +5,7 @@
  */
 import axios from 'axios';
 import { z } from 'zod';
-import { configInstance, parseStateZeroError } from '../../../src';
+import { configInstance, parseStateZeroError } from '../../../../src';
 /**
  * Zod schema for the input of sendNotification.
  * NOTE: This is an object schema for validating the data payload.

package/dist/actions/default/index.d.ts

@@ -0,0 +1 @@
+export * from "./django_app";

package/dist/actions/default/index.js

@@ -0,0 +1 @@
+export * from './django_app';

package/dist/actions/index.d.ts

@@ -1 +1 @@
-export * from "./django_app";
+export * from "./default/index";

package/dist/actions/index.js

@@ -1 +1,5 @@
-export * from './django_app';
+/**
+ * This file was auto-generated. Do not make direct changes to the file.
+ * Re-exports from the 'default' backend for backwards compatibility.
+ */
+export * from './default/index';

package/dist/cli/commands/syncActions.js

@@ -439,9 +439,10 @@ function prepareActionTemplateData(modulePath, functionName, actionName, actionD
 }
 async function generateActionFile(backend, actionName, actionDefinition) {
     const functionName = _.camelCase(actionName);
-    const modulePath = process.env.NODE_ENV === "test" ? "../../../src" : "@statezero/core";
+    const modulePath = process.env.NODE_ENV === "test" ? "../../../../src" : "@statezero/core";
     const appName = (actionDefinition.app || "general").toLowerCase();
-    const outDir = path.join(backend.GENERATED_ACTIONS_DIR, appName);
+    // Always include the backend key as the top-level folder
+    const outDir = path.join(backend.GENERATED_ACTIONS_DIR, backend.NAME, appName);
     await fs.mkdir(outDir, { recursive: true });
     const templateData = prepareActionTemplateData(modulePath, functionName, actionName, actionDefinition, backend.NAME);
     const fileName = _.kebabCase(actionName);
@@ -469,6 +470,7 @@ async function generateActionRegistry(generatedFiles, backendConfigs) {
     const registryByBackend = {};
     const schemasByBackend = {};
     const allImports = new Set();
+    const allSchemaImports = new Set();
     for (const file of generatedFiles) {
         const backendKey = file.backend;
         if (!backendKey)
@@ -482,12 +484,16 @@ async function generateActionRegistry(generatedFiles, backendConfigs) {
         const importPath = path
             .relative(process.cwd(), path.join(actionsDir, `${file.relativePath}.js`))
             .replace(/\\/g, "/");
+        // Generate action import
         const importStatement = `import { ${functionName} } from './${importPath}';`;
         allImports.add(importStatement);
         registryByBackend[backendKey].actions[file.action] = functionName;
-        // Store schema path for getSchema function
+        // Generate schema import
+        const schemaImportName = `${functionName}Schema`;
         const schemaPath = `./${importPath.replace(/\.js$/, '')}.schema.json`;
-        schemasByBackend[backendKey][file.action] = schemaPath;
+        const schemaImportStatement = `import ${schemaImportName} from '${schemaPath}' assert { type: 'json' };`;
+        allSchemaImports.add(schemaImportStatement);
+        schemasByBackend[backendKey][file.action] = schemaImportName;
     }
     let registryContent = `/**
  * This file was auto-generated. Do not make direct changes to the file.
@@ -495,9 +501,11 @@ async function generateActionRegistry(generatedFiles, backendConfigs) {
  */
 
 `;
+    // Add action imports
     registryContent += Array.from(allImports).sort().join("\n") + "\n\n";
-    // Add schema paths constant
-    registryContent += `const SCHEMA_PATHS = ${JSON.stringify(schemasByBackend, null, 2)};\n\n`;
+    // Add schema imports
+    registryContent += Array.from(allSchemaImports).sort().join("\n") + "\n\n";
+    // Add ACTION_REGISTRY
     registryContent += `export const ACTION_REGISTRY = {\n`;
     Object.entries(registryByBackend).forEach(([backendKey, data], index, arr) => {
         registryContent += `  '${backendKey}': {\n`;
@@ -508,6 +516,17 @@ async function generateActionRegistry(generatedFiles, backendConfigs) {
         registryContent += `  }${index < arr.length - 1 ? "," : ""}\n`;
     });
     registryContent += `};\n\n`;
+    // Add SCHEMA_REGISTRY
+    registryContent += `export const SCHEMA_REGISTRY = {\n`;
+    Object.entries(schemasByBackend).forEach(([backendKey, schemas], index, arr) => {
+        registryContent += `  '${backendKey}': {\n`;
+        const schemaEntries = Object.entries(schemas);
+        schemaEntries.forEach(([actionName, schemaName], idx, schemasArr) => {
+            registryContent += `    '${actionName}': ${schemaName}${idx < schemasArr.length - 1 ? "," : ""}\n`;
+        });
+        registryContent += `  }${index < arr.length - 1 ? "," : ""}\n`;
+    });
+    registryContent += `};\n\n`;
     registryContent += `/**
  * Get an action function by name and config key
  * @param {string} actionName - The name of the action
@@ -524,25 +543,18 @@ export function getAction(actionName, configKey) {
 }
 
 /**
- * Get the full schema for an action by loading its schema file
+ * Get the full schema for an action
  * @param {string} actionName - The name of the action
  * @param {string} configKey - The backend config key
- * @returns {Promise<Object|null>} The action schema or null if not found
+ * @returns {Object|null} The action schema or null if not found
  */
-export async function getSchema(actionName, configKey) {
-  const schemaPath = SCHEMA_PATHS[configKey]?.[actionName];
-  if (!schemaPath) {
+export function getSchema(actionName, configKey) {
+  const schema = SCHEMA_REGISTRY[configKey]?.[actionName];
+  if (!schema) {
     console.warn(\`Schema for action '\${actionName}' not found for config key '\${configKey}'.\`);
     return null;
   }
-  
-  try {
-    const schema = await import(schemaPath, { assert: { type: 'json' } });
-    return schema.default || schema;
-  } catch (error) {
-    console.error(\`Error loading schema for action '\${actionName}':\`, error);
-    return null;
-  }
+  return schema;
 }
 `;
     const registryFilePath = path.join(process.cwd(), "action-registry.js");
@@ -562,7 +574,8 @@ export * from '{{this.relativePath}}';
         const filesByApp = _.groupBy(backendFiles, "appName");
         for (const appName in filesByApp) {
             const appFiles = filesByApp[appName];
-            const appDir = path.join(rootActionsDir, appName);
+            // Include backend key in the path
+            const appDir = path.join(rootActionsDir, backendName, appName);
             const appIndexExports = appFiles.map((file) => {
                 const relativePathToAppDir = `./${path.basename(file.relativePath)}`;
                 return { ...file, relativePath: relativePathToAppDir };
@@ -573,10 +586,39 @@ export * from '{{this.relativePath}}';
             rootExports.push(`export * from './${appName}';`);
         }
         const rootIndexContent = rootExports.sort().join("\n");
-        await fs.writeFile(path.join(rootActionsDir, "index.js"), rootIndexContent);
-        await fs.writeFile(path.join(rootActionsDir, "index.d.ts"), rootIndexContent);
+        // Include backend key in the path for root index files
+        const backendDir = path.join(rootActionsDir, backendName);
+        await fs.writeFile(path.join(backendDir, "index.js"), rootIndexContent);
+        await fs.writeFile(path.join(backendDir, "index.d.ts"), rootIndexContent);
     }
 }
+/**
+ * Generates a top-level index file that re-exports from the 'default' backend
+ * if it exists. This improves backwards compatibility and reduces verbosity.
+ * @param {Object.<string, BackendConfig>} backendConfigs
+ * @returns {Promise<void>}
+ */
+async function generateDefaultBackendIndex(backendConfigs) {
+    // Check if a 'default' backend exists
+    if (!backendConfigs['default']) {
+        return; // No default backend, skip
+    }
+    const defaultBackend = backendConfigs['default'];
+    const actionsDir = defaultBackend.GENERATED_ACTIONS_DIR;
+    // Create top-level index files that re-export from default
+    const indexContent = `/**
+ * This file was auto-generated. Do not make direct changes to the file.
+ * Re-exports from the 'default' backend for backwards compatibility.
+ */
+
+export * from './default/index';
+`;
+    const jsIndexPath = path.join(actionsDir, 'index.js');
+    const dtsIndexPath = path.join(actionsDir, 'index.d.ts');
+    await fs.writeFile(jsIndexPath, indexContent);
+    await fs.writeFile(dtsIndexPath, indexContent);
+    console.log(`✨ Generated top-level index for 'default' backend`);
+}
 // ================================================================================================
 // MAIN SCRIPT RUNNER
 // ================================================================================================
@@ -645,6 +687,8 @@ async function main() {
     progressBar.stop();
     await generateAppLevelIndexFiles(allGeneratedFiles, backendConfigs);
     await generateActionRegistry(allGeneratedFiles, backendConfigs);
+    // Generate top-level index for 'default' backend if it exists
+    await generateDefaultBackendIndex(backendConfigs);
     console.log(`\n✨ Generated ${allGeneratedFiles.length} actions successfully.`);
 }
 /**

package/dist/cli/commands/syncModels.js

@@ -521,9 +521,11 @@ async function generateSchemaForModel(backend, model) {
     const interfaceName = `${className}Fields`;
     const parts = model.split(".");
     const currentApp = parts.length > 1 ? parts[0] : "";
-    const modulePath = process.env.NODE_ENV === "test" ? "../../../src" : "@statezero/core";
+    // With the backend folder added, we need an extra ../
+    const modulePath = process.env.NODE_ENV === "test" ? "../../../../src" : "@statezero/core";
     const templateData = prepareTemplateData(modulePath, className, interfaceName, rawModelName, schema, currentApp, backend.NAME);
-    let outDir = backend.GENERATED_TYPES_DIR;
+    // Always include the backend key as the top-level folder
+    let outDir = path.join(backend.GENERATED_TYPES_DIR, backend.NAME);
     if (parts.length > 1) {
         outDir = path.join(outDir, ...parts.slice(0, -1).map((p) => p.toLowerCase()));
     }
@@ -908,7 +910,8 @@ export * from '{{this.relativePath}}';
             }
             else {
                 // Create app-level index files with proper relative paths
-                const appDir = path.join(backend.GENERATED_TYPES_DIR, app.toLowerCase());
+                // Include backend key in the path
+                const appDir = path.join(backend.GENERATED_TYPES_DIR, backend.NAME, app.toLowerCase());
                 // Create relative paths for imports within the app directory
                 // These should be relative to the app directory, not the backend root
                 const appFiles = files.map((file) => {
@@ -931,8 +934,10 @@ export * from '{{this.relativePath}}';
             "export * from './fileobject';", // Add this line
             ...rootExports,
         ].join("\n");
-        await fs.writeFile(path.join(backend.GENERATED_TYPES_DIR, "index.js"), backendIndexContent);
-        await fs.writeFile(path.join(backend.GENERATED_TYPES_DIR, "index.d.ts"), backendIndexContent);
+        // Include backend key in the path for index files
+        const backendDir = path.join(backend.GENERATED_TYPES_DIR, backend.NAME);
+        await fs.writeFile(path.join(backendDir, "index.js"), backendIndexContent);
+        await fs.writeFile(path.join(backendDir, "index.d.ts"), backendIndexContent);
     }
 }
 // FileObject template
@@ -962,7 +967,10 @@ async function generateFileObjectForBackend(backend) {
         modulePath: modulePath,
     };
     const fileObjectContent = fileObjectTemplate(templateData);
-    const fileObjectPath = path.join(backend.GENERATED_TYPES_DIR, "fileobject.js");
+    // Include backend key in the path
+    const backendDir = path.join(backend.GENERATED_TYPES_DIR, backend.NAME);
+    await fs.mkdir(backendDir, { recursive: true });
+    const fileObjectPath = path.join(backendDir, "fileobject.js");
     await fs.writeFile(fileObjectPath, fileObjectContent);
     // Also generate TypeScript declaration
     const dtsContent = `/**
@@ -978,9 +986,36 @@ export declare class ${backend.NAME}FileObject extends BaseFileObject {
 
 export declare const FileObject: typeof ${backend.NAME}FileObject;
 `;
-    const dtsPath = path.join(backend.GENERATED_TYPES_DIR, "fileobject.d.ts");
+    const dtsPath = path.join(backendDir, "fileobject.d.ts");
     await fs.writeFile(dtsPath, dtsContent);
 }
+/**
+ * Generates a top-level index file that re-exports from the 'default' backend
+ * if it exists. This improves backwards compatibility and reduces verbosity.
+ * @param {Object.<string, BackendConfig>} backendConfigs
+ * @returns {Promise<void>}
+ */
+async function generateDefaultBackendIndex(backendConfigs) {
+    // Check if a 'default' backend exists
+    if (!backendConfigs['default']) {
+        return; // No default backend, skip
+    }
+    const defaultBackend = backendConfigs['default'];
+    const typesDir = defaultBackend.GENERATED_TYPES_DIR;
+    // Create top-level index files that re-export from default
+    const indexContent = `/**
+ * This file was auto-generated. Do not make direct changes to the file.
+ * Re-exports from the 'default' backend for backwards compatibility.
+ */
+
+export * from './default/index';
+`;
+    const jsIndexPath = path.join(typesDir, 'index.js');
+    const dtsIndexPath = path.join(typesDir, 'index.d.ts');
+    await fs.writeFile(jsIndexPath, indexContent);
+    await fs.writeFile(dtsIndexPath, indexContent);
+    console.log(`✨ Generated top-level index for 'default' backend`);
+}
 // --------------------
 // Main Runner: Fetch models and prompt selection
 // --------------------
@@ -1060,6 +1095,8 @@ async function main() {
     await generateAppLevelIndexFiles(allGeneratedFiles, backendConfigs);
     // Generate model registry
     await generateModelRegistry(allGeneratedFiles, backendConfigs);
+    // Generate top-level index for 'default' backend if it exists
+    await generateDefaultBackendIndex(backendConfigs);
     console.log(`✨ Generated JavaScript files with TypeScript declarations for ${selectedModels.length} models across ${Object.keys(backendConfigs).length} backends.`);
 }
 /**

package/dist/filtering/localFiltering.js

@@ -14,6 +14,45 @@ function getBackendTimezone(ModelClass) {
     const backendConfig = config.backendConfigs[ModelClass.configKey] || config.backendConfigs.default;
     return backendConfig.BACKEND_TZ || 'UTC';
 }
+/**
+ * Normalizes a filter value based on the field's schema type.
+ * This ensures Django-like behavior where date strings are automatically
+ * converted to Date objects for comparison.
+ *
+ * @param {string} fieldName - The field name to check in the schema
+ * @param {any} value - The filter value to normalize
+ * @param {Class} ModelClass - The model class containing the field
+ * @returns {any} The normalized value
+ */
+function normalizeFilterValue(fieldName, value, ModelClass) {
+    // If no schema or field name, return value as-is
+    if (!ModelClass?.schema || !fieldName)
+        return value;
+    // Get the field schema
+    const fieldSchema = ModelClass.schema.properties?.[fieldName];
+    if (!fieldSchema)
+        return value;
+    const { type, format } = fieldSchema;
+    // Handle date/datetime fields - convert strings to Date objects
+    if (type === 'string' && (format === 'date' || format === 'date-time')) {
+        if (typeof value === 'string') {
+            const parsed = new Date(value);
+            // Only return the parsed date if it's valid
+            return isNaN(parsed.getTime()) ? value : parsed;
+        }
+    }
+    // Handle 'in' lookups - normalize array values
+    if (Array.isArray(value) && type === 'string' && (format === 'date' || format === 'date-time')) {
+        return value.map(v => {
+            if (typeof v === 'string') {
+                const parsed = new Date(v);
+                return isNaN(parsed.getTime()) ? v : parsed;
+            }
+            return v;
+        });
+    }
+    return value;
+}
 /**
  * Process a Django-style field path with relationships to match Django ORM behavior.
  * This handles nested relationships by traversing the model schema and properly
@@ -61,6 +100,7 @@ function processFieldPath(fieldPath, value, ModelClass, options = {}) {
     let currentModel = ModelClass;
     let processedPath = [];
     let isRelationship = false;
+    let finalFieldName = null; // Track the actual field name for schema lookup
     for (let i = 0; i < fieldParts.length; i++) {
         let part = fieldParts[i];
         if (part === 'pk' && currentModel)
@@ -87,16 +127,19 @@ function processFieldPath(fieldPath, value, ModelClass, options = {}) {
                 // to properly match Django's behavior
                 const pkField = relatedModel.primaryKeyField || 'id';
                 processedPath.push(pkField);
+                finalFieldName = pkField;
+                currentModel = relatedModel;
             }
         }
         else if (currentModel && currentModel.fields && currentModel.fields.includes(part)) {
             // This is a regular field
             processedPath.push(part);
+            finalFieldName = part;
             // If it's the last part, we're done
             if (isLastPart) {
                 break;
             }
-            // If it's not the last part but it's a regular field, 
+            // If it's not the last part but it's a regular field,
             // we can't continue traversal
             throw new Error(`Field '${part}' in '${fieldPath}' is not a relationship field and cannot be traversed.`);
         }
@@ -107,28 +150,30 @@ function processFieldPath(fieldPath, value, ModelClass, options = {}) {
     }
     // Join the processed path parts, using dot notation for sift
     const finalPath = processedPath.join('.');
+    // Normalize the value based on the field schema
+    const normalizedValue = normalizeFilterValue(finalFieldName, value, currentModel);
     // Handle the date part + comparison chain if present
     if (lookupChain.length === 2) {
         const [datePart, comparisonOperator] = lookupChain;
-        return createDatePartComparisonOperator(finalPath, datePart, comparisonOperator, value, isRelationship);
+        return createDatePartComparisonOperator(finalPath, datePart, comparisonOperator, normalizedValue, isRelationship);
     }
     // Handle the single lookup operation if present
     if (lookup) {
-        return createOperatorFromLookup(finalPath, lookup, value, isRelationship);
+        return createOperatorFromLookup(finalPath, lookup, normalizedValue, isRelationship, currentModel, finalFieldName);
     }
     // If there's no explicit lookup and this is a relationship field,
     // we've already appended the PK field name to the path
     // so we just need to apply the equality operator to the value
     if (isRelationship) {
         // In case the user passed in a raw model as the query value
-        let raw = value;
-        if (value && typeof value === 'object' && 'pk' in value) {
-            raw = value.pk;
+        let raw = normalizedValue;
+        if (normalizedValue && typeof normalizedValue === 'object' && 'pk' in normalizedValue) {
+            raw = normalizedValue.pk;
         }
         return { field: finalPath, operator: { $eq: raw } };
     }
     // Default to direct equality
-    return { field: finalPath, operator: { $eq: value } };
+    return { field: finalPath, operator: { $eq: normalizedValue } };
 }
 /**
  * Creates a special operator for date part comparison (e.g., created_at__hour__gt: 12)
@@ -157,11 +202,13 @@ function createDatePartComparisonOperator(field, datePart, comparisonOperator, v
  * Creates a sift operator from a Django-style lookup
  * @param {string} field - Processed field path
  * @param {string} lookup - Django-style lookup (e.g., 'contains', 'iexact')
- * @param {any} value - Value to filter by
+ * @param {any} value - Value to filter by (already normalized)
  * @param {boolean} isRelationship - Whether the field is a relationship
+ * @param {Class} ModelClass - The model class (unused, for future extensibility)
+ * @param {string} finalFieldName - The final field name (unused, for future extensibility)
  * @returns {Object} Object with field name and sift operator
  */
-function createOperatorFromLookup(field, lookup, value, isRelationship) {
+function createOperatorFromLookup(field, lookup, value, isRelationship, ModelClass, finalFieldName) {
     // Helper function to escape special characters in regex
     function escapeRegExp(string) {
         return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

package/dist/models/{django_app → backend1/django_app}/comprehensivemodel.d.ts

@@ -42,6 +42,6 @@ export class ComprehensiveModel extends Model {
      */
     private _defineProperties;
 }
-import { QuerySet } from '../../../src';
-import { Manager } from '../../../src';
-import { Model } from '../../../src';
+import { QuerySet } from '../../../../src';
+import { Manager } from '../../../../src';
+import { Model } from '../../../../src';

package/dist/models/backend1/django_app/comprehensivemodel.js

@@ -0,0 +1,63 @@
+/**
+ * This file was auto-generated. Do not make direct changes to the file.
+ */
+import { Model, Manager, QuerySet, getModelClass } from '../../../../src';
+import { wrapReactiveModel } from '../../../../src';
+import schemaData from './comprehensivemodel.schema.json';
+/**
+ * Model-specific QuerySet implementation
+ */
+export class ComprehensiveModelQuerySet extends QuerySet {
+}
+/**
+ * Model-specific Manager implementation
+ */
+export class ComprehensiveModelManager extends Manager {
+    constructor(ModelClass) {
+        super(ModelClass, ComprehensiveModelQuerySet);
+    }
+    newQuerySet() {
+        return new ComprehensiveModelQuerySet(this.ModelClass);
+    }
+}
+/**
+ * Implementation of the ComprehensiveModel model
+ */
+export class ComprehensiveModel extends Model {
+    constructor(data) {
+        ComprehensiveModel.validateFields(data);
+        super(data);
+        // Define getters and setters for all fields
+        this._defineProperties();
+        return wrapReactiveModel(this);
+    }
+    /**
+     * Define property getters and setters for all model fields
+     * @private
+     */
+    _defineProperties() {
+        // For each field, define a property that gets/sets from internal storage
+        ComprehensiveModel.fields.forEach(field => {
+            Object.defineProperty(this, field, {
+                get: function () {
+                    return this.getField(field);
+                },
+                set: function (value) {
+                    this.setField(field, value);
+                },
+                enumerable: true, // Make sure fields are enumerable for serialization
+                configurable: true
+            });
+        });
+    }
+}
+// Bind this model to its backend
+ComprehensiveModel.configKey = 'backend1';
+ComprehensiveModel.modelName = 'django_app.comprehensivemodel';
+ComprehensiveModel.primaryKeyField = 'id';
+ComprehensiveModel.objects = new ComprehensiveModelManager(ComprehensiveModel);
+ComprehensiveModel.fields = ['id', 'char_field', 'text_field', 'int_field', 'bool_field', 'datetime_field', 'decimal_field', 'json_field', 'money_field_currency', 'money_field', 'related'];
+ComprehensiveModel.schema = schemaData;
+ComprehensiveModel.relationshipFields = new Map([
+    ['related', { 'ModelClass': () => getModelClass('django_app.deepmodellevel1', 'backend1'), 'relationshipType': 'foreign-key' }]
+]);

package/dist/models/{django_app → backend1/django_app}/custompkmodel.d.ts

@@ -39,6 +39,6 @@ export class CustomPKModel extends Model {
      */
     private _defineProperties;
 }
-import { QuerySet } from '../../../src';
-import { Manager } from '../../../src';
-import { Model } from '../../../src';
+import { QuerySet } from '../../../../src';
+import { Manager } from '../../../../src';
+import { Model } from '../../../../src';