Refactor filename naming system and apply convention-based renames

Standardize settings file naming and relocate documentation files
Fix code quality violations from rsx:check
Reorganize user_management directory into logical subdirectories
Move Quill Bundle to core and align with Tom Select pattern
Simplify Site Settings page to focus on core site information
Complete Phase 5: Multi-tenant authentication with login flow and site selection
Add route query parameter rule and synchronize filename validation logic
Fix critical bug in UpdateNpmCommand causing missing JavaScript stubs
Implement filename convention rule and resolve VS Code auto-rename conflict
Implement js-sanitizer RPC server to eliminate 900+ Node.js process spawns
Implement RPC server architecture for JavaScript parsing
WIP: Add RPC server infrastructure for JS parsing (partial implementation)
Update jqhtml terminology from destroy to stop, fix datagrid DOM preservation
Add JQHTML-CLASS-01 rule and fix redundant class names
Improve code quality rules and resolve violations
Remove legacy fatal error format in favor of unified 'fatal' error type
Filter internal keys from window.rsxapp output
Update button styling and comprehensive form/modal documentation
Add conditional fly-in animation for modals
Fix non-deterministic bundle compilation

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

storage-working/rsx-build/js-model-stubs/client-department-model.js

@@ -0,0 +1,77 @@
+/**
+ * Auto-generated JavaScript stub for Client_Department_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Client_Department_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'Client_Department_Model';
+    }
+
+    /**
+     * Fetch client relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async client() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Client_Department_Model/${this.id}/client`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch contacts relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async contacts() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Client_Department_Model/${this.id}/contacts`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch created_by relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async created_by() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Client_Department_Model/${this.id}/created_by`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+}

storage-working/rsx-build/js-model-stubs/client-model.js

@@ -0,0 +1,194 @@
+/**
+ * Auto-generated JavaScript stub for Client_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Client_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'Client_Model';
+    }
+
+    static PRIORITY_LOW = 1;
+    static PRIORITY_MEDIUM = 2;
+    static PRIORITY_HIGH = 3;
+    static PRIORITY_URGENT = 4;
+
+    static priority_enum_val() {
+        const data = {};
+        const order = [];
+        data[1] = {"constant":"PRIORITY_LOW","label":"Low","badge":"bg-secondary"};
+        order.push(1);
+        data[2] = {"constant":"PRIORITY_MEDIUM","label":"Medium","badge":"bg-primary"};
+        order.push(2);
+        data[3] = {"constant":"PRIORITY_HIGH","label":"High","badge":"bg-warning"};
+        order.push(3);
+        data[4] = {"constant":"PRIORITY_URGENT","label":"Urgent","badge":"bg-danger"};
+        order.push(4);
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static priority_label_list() {
+        const values = {};
+        values[1] = 'Low';
+        values[2] = 'Medium';
+        values[3] = 'High';
+        values[4] = 'Urgent';
+        return values;
+    }
+
+    static priority_enum_select() {
+        const fullData = this.priority_enum_val();
+        const data = {};
+        const order = [];
+        
+        // Extract labels from full data, respecting selectable flag
+        for (const key in fullData) {
+            const item = fullData[key];
+            if (item.selectable !== false && item.label) {
+                data[key] = item.label;
+                order.push(parseInt(key));
+            }
+        }
+        
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    /**
+     * Fetch billing_contact relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async billing_contact() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Client_Model/${this.id}/billing_contact`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch contacts relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async contacts() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Client_Model/${this.id}/contacts`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch departments relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async departments() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Client_Model/${this.id}/departments`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch created_by relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async created_by() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Client_Model/${this.id}/created_by`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch owner relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async owner() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Client_Model/${this.id}/owner`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+}

storage-working/rsx-build/js-model-stubs/contact-model.js

@@ -0,0 +1,216 @@
+/**
+ * Auto-generated JavaScript stub for Contact_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Contact_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'Contact_Model';
+    }
+
+    static PRIORITY_LOW = 1;
+    static PRIORITY_MEDIUM = 2;
+    static PRIORITY_HIGH = 3;
+    static PRIORITY_URGENT = 4;
+
+    static priority_enum_val() {
+        const data = {};
+        const order = [];
+        data[1] = {"constant":"PRIORITY_LOW","label":"Low","badge":"bg-secondary"};
+        order.push(1);
+        data[2] = {"constant":"PRIORITY_MEDIUM","label":"Medium","badge":"bg-primary"};
+        order.push(2);
+        data[3] = {"constant":"PRIORITY_HIGH","label":"High","badge":"bg-warning"};
+        order.push(3);
+        data[4] = {"constant":"PRIORITY_URGENT","label":"Urgent","badge":"bg-danger"};
+        order.push(4);
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static priority_label_list() {
+        const values = {};
+        values[1] = 'Low';
+        values[2] = 'Medium';
+        values[3] = 'High';
+        values[4] = 'Urgent';
+        return values;
+    }
+
+    static priority_enum_select() {
+        const fullData = this.priority_enum_val();
+        const data = {};
+        const order = [];
+        
+        // Extract labels from full data, respecting selectable flag
+        for (const key in fullData) {
+            const item = fullData[key];
+            if (item.selectable !== false && item.label) {
+                data[key] = item.label;
+                order.push(parseInt(key));
+            }
+        }
+        
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    /**
+     * Fetch client relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async client() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Contact_Model/${this.id}/client`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch department relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async department() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Contact_Model/${this.id}/department`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch reports_to relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async reports_to() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Contact_Model/${this.id}/reports_to`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch direct_reports relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async direct_reports() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Contact_Model/${this.id}/direct_reports`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch created_by relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async created_by() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Contact_Model/${this.id}/created_by`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch owner relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async owner() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Contact_Model/${this.id}/owner`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+}

storage-working/rsx-build/js-model-stubs/country-model.js

@@ -0,0 +1,11 @@
+/**
+ * Auto-generated JavaScript stub for Country_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Country_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'Country_Model';
+    }
+
+}

storage-working/rsx-build/js-model-stubs/demo-product-model.js

@@ -0,0 +1,153 @@
+/**
+ * Auto-generated JavaScript stub for Demo_Product_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Demo_Product_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'Demo_Product_Model';
+    }
+
+    static STATUS_AVAILABLE = 1;
+    static STATUS_OUT_OF_STOCK = 2;
+    static STATUS_DISCONTINUED = 3;
+
+    static status_id_enum_val() {
+        const data = {};
+        const order = [];
+        data[1] = {"constant":"STATUS_AVAILABLE","label":"Available","order":1};
+        order.push(1);
+        data[2] = {"constant":"STATUS_OUT_OF_STOCK","label":"Out of Stock","order":2};
+        order.push(2);
+        data[3] = {"constant":"STATUS_DISCONTINUED","label":"Discontinued","order":3};
+        order.push(3);
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static status_id_label_list() {
+        const values = {};
+        values[1] = 'Available';
+        values[2] = 'Out of Stock';
+        values[3] = 'Discontinued';
+        return values;
+    }
+
+    static status_id_enum_select() {
+        const fullData = this.status_id_enum_val();
+        const data = {};
+        const order = [];
+        
+        // Extract labels from full data, respecting selectable flag
+        for (const key in fullData) {
+            const item = fullData[key];
+            if (item.selectable !== false && item.label) {
+                data[key] = item.label;
+                order.push(parseInt(key));
+            }
+        }
+        
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static CATEGORY_ELECTRONICS = 1;
+    static CATEGORY_CLOTHING = 2;
+    static CATEGORY_BOOKS = 3;
+    static CATEGORY_FOOD = 4;
+
+    static category_id_enum_val() {
+        const data = {};
+        const order = [];
+        data[1] = {"constant":"CATEGORY_ELECTRONICS","label":"Electronics","order":1};
+        order.push(1);
+        data[2] = {"constant":"CATEGORY_CLOTHING","label":"Clothing","order":2};
+        order.push(2);
+        data[3] = {"constant":"CATEGORY_BOOKS","label":"Books","order":3};
+        order.push(3);
+        data[4] = {"constant":"CATEGORY_FOOD","label":"Food & Beverage","order":4};
+        order.push(4);
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static category_id_label_list() {
+        const values = {};
+        values[1] = 'Electronics';
+        values[2] = 'Clothing';
+        values[3] = 'Books';
+        values[4] = 'Food & Beverage';
+        return values;
+    }
+
+    static category_id_enum_select() {
+        const fullData = this.category_id_enum_val();
+        const data = {};
+        const order = [];
+        
+        // Extract labels from full data, respecting selectable flag
+        for (const key in fullData) {
+            const item = fullData[key];
+            if (item.selectable !== false && item.label) {
+                data[key] = item.label;
+                order.push(parseInt(key));
+            }
+        }
+        
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+}

storage-working/rsx-build/js-model-stubs/file-attachment-model.js

@@ -0,0 +1,184 @@
+/**
+ * Auto-generated JavaScript stub for File_Attachment_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class File_Attachment_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'File_Attachment_Model';
+    }
+
+    static FILE_TYPE_IMAGE = 1;
+    static FILE_TYPE_ANIMATED_IMAGE = 2;
+    static FILE_TYPE_VIDEO = 3;
+    static FILE_TYPE_ARCHIVE = 4;
+    static FILE_TYPE_TEXT = 5;
+    static FILE_TYPE_DOCUMENT = 6;
+    static FILE_TYPE_OTHER = 7;
+
+    static file_type_id_enum_val() {
+        const data = {};
+        const order = [];
+        data[1] = {"constant":"FILE_TYPE_IMAGE","label":"Image"};
+        order.push(1);
+        data[2] = {"constant":"FILE_TYPE_ANIMATED_IMAGE","label":"Animated Image"};
+        order.push(2);
+        data[3] = {"constant":"FILE_TYPE_VIDEO","label":"Video"};
+        order.push(3);
+        data[4] = {"constant":"FILE_TYPE_ARCHIVE","label":"Archive"};
+        order.push(4);
+        data[5] = {"constant":"FILE_TYPE_TEXT","label":"Text"};
+        order.push(5);
+        data[6] = {"constant":"FILE_TYPE_DOCUMENT","label":"Document"};
+        order.push(6);
+        data[7] = {"constant":"FILE_TYPE_OTHER","label":"Other"};
+        order.push(7);
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static file_type_id_label_list() {
+        const values = {};
+        values[1] = 'Image';
+        values[2] = 'Animated Image';
+        values[3] = 'Video';
+        values[4] = 'Archive';
+        values[5] = 'Text';
+        values[6] = 'Document';
+        values[7] = 'Other';
+        return values;
+    }
+
+    static file_type_id_enum_select() {
+        const fullData = this.file_type_id_enum_val();
+        const data = {};
+        const order = [];
+        
+        // Extract labels from full data, respecting selectable flag
+        for (const key in fullData) {
+            const item = fullData[key];
+            if (item.selectable !== false && item.label) {
+                data[key] = item.label;
+                order.push(parseInt(key));
+            }
+        }
+        
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    /**
+     * Fetch file_storage relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async file_storage() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/File_Attachment_Model/${this.id}/file_storage`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch site relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async site() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/File_Attachment_Model/${this.id}/site`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch fileable relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async fileable() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/File_Attachment_Model/${this.id}/fileable`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch search_indexes relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async search_indexes() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/File_Attachment_Model/${this.id}/search_indexes`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+}

storage-working/rsx-build/js-model-stubs/file-storage-model.js

@@ -0,0 +1,11 @@
+/**
+ * Auto-generated JavaScript stub for File_Storage_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class File_Storage_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'File_Storage_Model';
+    }
+
+}

storage-working/rsx-build/js-model-stubs/file-thumbnail-model.js

@@ -0,0 +1,11 @@
+/**
+ * Auto-generated JavaScript stub for File_Thumbnail_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class File_Thumbnail_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'File_Thumbnail_Model';
+    }
+
+}

storage-working/rsx-build/js-model-stubs/login-user-model.js

@@ -0,0 +1,231 @@
+/**
+ * Auto-generated JavaScript stub for Login_User_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Login_User_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'Login_User_Model';
+    }
+
+    static STATUS_ACTIVE = 1;
+    static STATUS_INACTIVE = 2;
+    static STATUS_SUSPENDED = 3;
+
+    static status_id_enum_val() {
+        const data = {};
+        const order = [];
+        data[1] = {"constant":"STATUS_ACTIVE","label":"Active","order":1};
+        order.push(1);
+        data[2] = {"constant":"STATUS_INACTIVE","label":"Inactive","order":2};
+        order.push(2);
+        data[3] = {"constant":"STATUS_SUSPENDED","label":"Suspended","order":3,"selectable":false};
+        order.push(3);
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static status_id_label_list() {
+        const values = {};
+        values[1] = 'Active';
+        values[2] = 'Inactive';
+        values[3] = 'Suspended';
+        return values;
+    }
+
+    static status_id_enum_select() {
+        const fullData = this.status_id_enum_val();
+        const data = {};
+        const order = [];
+        
+        // Extract labels from full data, respecting selectable flag
+        for (const key in fullData) {
+            const item = fullData[key];
+            if (item.selectable !== false && item.label) {
+                data[key] = item.label;
+                order.push(parseInt(key));
+            }
+        }
+        
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+
+    static is_verified_enum_val() {
+        const data = {};
+        const order = [];
+        data[0] = {"label":"Not Verified"};
+        order.push(0);
+        data[1] = {"label":"Verified"};
+        order.push(1);
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static is_verified_label_list() {
+        const values = {};
+        values[0] = 'Not Verified';
+        values[1] = 'Verified';
+        return values;
+    }
+
+    static is_verified_enum_select() {
+        const fullData = this.is_verified_enum_val();
+        const data = {};
+        const order = [];
+        
+        // Extract labels from full data, respecting selectable flag
+        for (const key in fullData) {
+            const item = fullData[key];
+            if (item.selectable !== false && item.label) {
+                data[key] = item.label;
+                order.push(parseInt(key));
+            }
+        }
+        
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    /**
+     * Fetch users relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async users() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Login_User_Model/${this.id}/users`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch sessions relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async sessions() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Login_User_Model/${this.id}/sessions`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch verifications relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async verifications() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Login_User_Model/${this.id}/verifications`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch invites relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async invites() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Login_User_Model/${this.id}/invites`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+}

storage-working/rsx-build/js-model-stubs/project-model.js

@@ -0,0 +1,293 @@
+/**
+ * Auto-generated JavaScript stub for Project_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Project_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'Project_Model';
+    }
+
+    static STATUS_PLANNING = 1;
+    static STATUS_ACTIVE = 2;
+    static STATUS_ON_HOLD = 3;
+    static STATUS_COMPLETED = 4;
+    static STATUS_CANCELLED = 5;
+
+    static status_enum_val() {
+        const data = {};
+        const order = [];
+        data[1] = {"constant":"STATUS_PLANNING","label":"Planning","badge":"bg-info"};
+        order.push(1);
+        data[2] = {"constant":"STATUS_ACTIVE","label":"Active","badge":"bg-success"};
+        order.push(2);
+        data[3] = {"constant":"STATUS_ON_HOLD","label":"On Hold","badge":"bg-warning"};
+        order.push(3);
+        data[4] = {"constant":"STATUS_COMPLETED","label":"Completed","badge":"bg-primary"};
+        order.push(4);
+        data[5] = {"constant":"STATUS_CANCELLED","label":"Cancelled","badge":"bg-secondary"};
+        order.push(5);
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static status_label_list() {
+        const values = {};
+        values[1] = 'Planning';
+        values[2] = 'Active';
+        values[3] = 'On Hold';
+        values[4] = 'Completed';
+        values[5] = 'Cancelled';
+        return values;
+    }
+
+    static status_enum_select() {
+        const fullData = this.status_enum_val();
+        const data = {};
+        const order = [];
+        
+        // Extract labels from full data, respecting selectable flag
+        for (const key in fullData) {
+            const item = fullData[key];
+            if (item.selectable !== false && item.label) {
+                data[key] = item.label;
+                order.push(parseInt(key));
+            }
+        }
+        
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static PRIORITY_LOW = 1;
+    static PRIORITY_MEDIUM = 2;
+    static PRIORITY_HIGH = 3;
+    static PRIORITY_URGENT = 4;
+
+    static priority_enum_val() {
+        const data = {};
+        const order = [];
+        data[1] = {"constant":"PRIORITY_LOW","label":"Low","badge":"bg-secondary"};
+        order.push(1);
+        data[2] = {"constant":"PRIORITY_MEDIUM","label":"Medium","badge":"bg-primary"};
+        order.push(2);
+        data[3] = {"constant":"PRIORITY_HIGH","label":"High","badge":"bg-warning"};
+        order.push(3);
+        data[4] = {"constant":"PRIORITY_URGENT","label":"Urgent","badge":"bg-danger"};
+        order.push(4);
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static priority_label_list() {
+        const values = {};
+        values[1] = 'Low';
+        values[2] = 'Medium';
+        values[3] = 'High';
+        values[4] = 'Urgent';
+        return values;
+    }
+
+    static priority_enum_select() {
+        const fullData = this.priority_enum_val();
+        const data = {};
+        const order = [];
+        
+        // Extract labels from full data, respecting selectable flag
+        for (const key in fullData) {
+            const item = fullData[key];
+            if (item.selectable !== false && item.label) {
+                data[key] = item.label;
+                order.push(parseInt(key));
+            }
+        }
+        
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    /**
+     * Fetch client relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async client() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Project_Model/${this.id}/client`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch client_department relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async client_department() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Project_Model/${this.id}/client_department`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch contact relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async contact() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Project_Model/${this.id}/contact`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch tasks relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async tasks() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Project_Model/${this.id}/tasks`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch created_by relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async created_by() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Project_Model/${this.id}/created_by`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch owner relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async owner() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Project_Model/${this.id}/owner`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+}

storage-working/rsx-build/js-model-stubs/region-model.js

@@ -0,0 +1,11 @@
+/**
+ * Auto-generated JavaScript stub for Region_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Region_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'Region_Model';
+    }
+
+}

storage-working/rsx-build/js-model-stubs/search-index-model.js

@@ -0,0 +1,33 @@
+/**
+ * Auto-generated JavaScript stub for Search_Index_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Search_Index_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'Search_Index_Model';
+    }
+
+    /**
+     * Fetch indexable relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async indexable() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Search_Index_Model/${this.id}/indexable`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+}

storage-working/rsx-build/js-model-stubs/site-model.js

@@ -0,0 +1,55 @@
+/**
+ * Auto-generated JavaScript stub for Site_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Site_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'Site_Model';
+    }
+
+    /**
+     * Fetch users relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async users() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Site_Model/${this.id}/users`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch files relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async files() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Site_Model/${this.id}/files`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+}

storage-working/rsx-build/js-model-stubs/task-model.js

@@ -0,0 +1,245 @@
+/**
+ * Auto-generated JavaScript stub for Task_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Task_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'Task_Model';
+    }
+
+    static STATUS_PENDING = 1;
+    static STATUS_IN_PROGRESS = 2;
+    static STATUS_COMPLETED = 3;
+    static STATUS_CANCELLED = 4;
+
+    static status_enum_val() {
+        const data = {};
+        const order = [];
+        data[1] = {"constant":"STATUS_PENDING","label":"Pending","badge":"bg-secondary"};
+        order.push(1);
+        data[2] = {"constant":"STATUS_IN_PROGRESS","label":"In Progress","badge":"bg-info"};
+        order.push(2);
+        data[3] = {"constant":"STATUS_COMPLETED","label":"Completed","badge":"bg-success"};
+        order.push(3);
+        data[4] = {"constant":"STATUS_CANCELLED","label":"Cancelled","badge":"bg-danger"};
+        order.push(4);
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static status_label_list() {
+        const values = {};
+        values[1] = 'Pending';
+        values[2] = 'In Progress';
+        values[3] = 'Completed';
+        values[4] = 'Cancelled';
+        return values;
+    }
+
+    static status_enum_select() {
+        const fullData = this.status_enum_val();
+        const data = {};
+        const order = [];
+        
+        // Extract labels from full data, respecting selectable flag
+        for (const key in fullData) {
+            const item = fullData[key];
+            if (item.selectable !== false && item.label) {
+                data[key] = item.label;
+                order.push(parseInt(key));
+            }
+        }
+        
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static PRIORITY_LOW = 1;
+    static PRIORITY_MEDIUM = 2;
+    static PRIORITY_HIGH = 3;
+    static PRIORITY_URGENT = 4;
+
+    static priority_enum_val() {
+        const data = {};
+        const order = [];
+        data[1] = {"constant":"PRIORITY_LOW","label":"Low","badge":"bg-secondary"};
+        order.push(1);
+        data[2] = {"constant":"PRIORITY_MEDIUM","label":"Medium","badge":"bg-primary"};
+        order.push(2);
+        data[3] = {"constant":"PRIORITY_HIGH","label":"High","badge":"bg-warning"};
+        order.push(3);
+        data[4] = {"constant":"PRIORITY_URGENT","label":"Urgent","badge":"bg-danger"};
+        order.push(4);
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static priority_label_list() {
+        const values = {};
+        values[1] = 'Low';
+        values[2] = 'Medium';
+        values[3] = 'High';
+        values[4] = 'Urgent';
+        return values;
+    }
+
+    static priority_enum_select() {
+        const fullData = this.priority_enum_val();
+        const data = {};
+        const order = [];
+        
+        // Extract labels from full data, respecting selectable flag
+        for (const key in fullData) {
+            const item = fullData[key];
+            if (item.selectable !== false && item.label) {
+                data[key] = item.label;
+                order.push(parseInt(key));
+            }
+        }
+        
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    /**
+     * Fetch taskable relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async taskable() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Task_Model/${this.id}/taskable`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch assigned_to relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async assigned_to() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Task_Model/${this.id}/assigned_to`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch created_by relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async created_by() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Task_Model/${this.id}/created_by`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch subtasks relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async subtasks() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/Task_Model/${this.id}/subtasks`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+}

storage-working/rsx-build/js-model-stubs/user-invite-model.js

@@ -0,0 +1,55 @@
+/**
+ * Auto-generated JavaScript stub for User_Invite_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class User_Invite_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'User_Invite_Model';
+    }
+
+    /**
+     * Fetch inviter relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async inviter() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/User_Invite_Model/${this.id}/inviter`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch site relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async site() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/User_Invite_Model/${this.id}/site`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+}

storage-working/rsx-build/js-model-stubs/user-model.js

@@ -0,0 +1,227 @@
+/**
+ * Auto-generated JavaScript stub for User_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class User_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'User_Model';
+    }
+
+    static ROLE_OWNER = 1;
+    static ROLE_ADMIN = 2;
+    static ROLE_MEMBER = 3;
+    static ROLE_VIEWER = 4;
+
+    static role_id_enum_val() {
+        const data = {};
+        const order = [];
+        data[1] = {"constant":"ROLE_OWNER","label":"Owner"};
+        order.push(1);
+        data[2] = {"constant":"ROLE_ADMIN","label":"Admin"};
+        order.push(2);
+        data[3] = {"constant":"ROLE_MEMBER","label":"Member"};
+        order.push(3);
+        data[4] = {"constant":"ROLE_VIEWER","label":"Viewer"};
+        order.push(4);
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static role_id_label_list() {
+        const values = {};
+        values[1] = 'Owner';
+        values[2] = 'Admin';
+        values[3] = 'Member';
+        values[4] = 'Viewer';
+        return values;
+    }
+
+    static role_id_enum_select() {
+        const fullData = this.role_id_enum_val();
+        const data = {};
+        const order = [];
+        
+        // Extract labels from full data, respecting selectable flag
+        for (const key in fullData) {
+            const item = fullData[key];
+            if (item.selectable !== false && item.label) {
+                data[key] = item.label;
+                order.push(parseInt(key));
+            }
+        }
+        
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static USER_ROLE_READ_ONLY = 1;
+    static USER_ROLE_STANDARD = 2;
+    static USER_ROLE_ADMIN = 3;
+    static USER_ROLE_BILLING_ADMIN = 4;
+    static USER_ROLE_ROOT_ADMIN = 5;
+
+    static user_role_id_enum_val() {
+        const data = {};
+        const order = [];
+        data[1] = {"constant":"USER_ROLE_READ_ONLY","label":"Read Only","order":1};
+        order.push(1);
+        data[2] = {"constant":"USER_ROLE_STANDARD","label":"Standard","order":2};
+        order.push(2);
+        data[3] = {"constant":"USER_ROLE_ADMIN","label":"Admin","order":3};
+        order.push(3);
+        data[4] = {"constant":"USER_ROLE_BILLING_ADMIN","label":"Billing Admin","order":4};
+        order.push(4);
+        data[5] = {"constant":"USER_ROLE_ROOT_ADMIN","label":"Root Admin","order":5};
+        order.push(5);
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static user_role_id_label_list() {
+        const values = {};
+        values[1] = 'Read Only';
+        values[2] = 'Standard';
+        values[3] = 'Admin';
+        values[4] = 'Billing Admin';
+        values[5] = 'Root Admin';
+        return values;
+    }
+
+    static user_role_id_enum_select() {
+        const fullData = this.user_role_id_enum_val();
+        const data = {};
+        const order = [];
+        
+        // Extract labels from full data, respecting selectable flag
+        for (const key in fullData) {
+            const item = fullData[key];
+            if (item.selectable !== false && item.label) {
+                data[key] = item.label;
+                order.push(parseInt(key));
+            }
+        }
+        
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    /**
+     * Fetch login_user relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async login_user() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/User_Model/${this.id}/login_user`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch site relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async site() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/User_Model/${this.id}/site`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+    /**
+     * Fetch user_profile relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async user_profile() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/User_Model/${this.id}/user_profile`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+}

storage-working/rsx-build/js-model-stubs/user-profile-model.js

@@ -0,0 +1,33 @@
+/**
+ * Auto-generated JavaScript stub for User_Profile_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class User_Profile_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'User_Profile_Model';
+    }
+
+    /**
+     * Fetch user relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async user() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/User_Profile_Model/${this.id}/user`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+}

storage-working/rsx-build/js-model-stubs/user-verification-model.js

@@ -0,0 +1,106 @@
+/**
+ * Auto-generated JavaScript stub for User_Verification_Model
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class User_Verification_Model extends Rsx_Js_Model {
+    static get name() {
+        return 'User_Verification_Model';
+    }
+
+    static VERIFICATION_TYPE_EMAIL = 1;
+    static VERIFICATION_TYPE_SMS = 2;
+    static VERIFICATION_TYPE_EMAIL_RECOVERY = 3;
+    static VERIFICATION_TYPE_SMS_RECOVERY = 4;
+
+    static verification_type_id_enum_val() {
+        const data = {};
+        const order = [];
+        data[1] = {"constant":"VERIFICATION_TYPE_EMAIL","label":"Email Verification"};
+        order.push(1);
+        data[2] = {"constant":"VERIFICATION_TYPE_SMS","label":"SMS Verification"};
+        order.push(2);
+        data[3] = {"constant":"VERIFICATION_TYPE_EMAIL_RECOVERY","label":"Email Recovery"};
+        order.push(3);
+        data[4] = {"constant":"VERIFICATION_TYPE_SMS_RECOVERY","label":"SMS Recovery"};
+        order.push(4);
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    static verification_type_id_label_list() {
+        const values = {};
+        values[1] = 'Email Verification';
+        values[2] = 'SMS Verification';
+        values[3] = 'Email Recovery';
+        values[4] = 'SMS Recovery';
+        return values;
+    }
+
+    static verification_type_id_enum_select() {
+        const fullData = this.verification_type_id_enum_val();
+        const data = {};
+        const order = [];
+        
+        // Extract labels from full data, respecting selectable flag
+        for (const key in fullData) {
+            const item = fullData[key];
+            if (item.selectable !== false && item.label) {
+                data[key] = item.label;
+                order.push(parseInt(key));
+            }
+        }
+        
+        // Return Proxy that maintains sort order for enumeration
+        return new Proxy(data, {
+            ownKeys() {
+                return order.map(String);
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                if (prop in target) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: target[prop]
+                    };
+                }
+            }
+        });
+    }
+
+    /**
+     * Fetch user relationship
+     * @returns {Promise} Related model instance(s) or false
+     */
+    async user() {
+        if (!this.id) {
+            shouldnt_happen('Cannot fetch relationship without id property');
+        }
+
+        const response = await $.ajax({
+            url: `/_fetch_rel/User_Verification_Model/${this.id}/user`,
+            method: 'POST',
+            dataType: 'json'
+        });
+
+        if (!response) return false;
+
+        // Convert response to model instance(s)
+        // Framework handles instantiation based on relationship type
+        return response;
+    }
+
+}

storage-working/rsx-build/js-stubs/Accept_Invite_Controller.js

@@ -0,0 +1,19 @@
+/**
+ * Auto-generated JavaScript stub for Accept_Invite_Controller
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Accept_Invite_Controller {
+    /**
+     * Call Accept_Invite_Controller::accept via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async accept(params = {}) {
+        return Ajax.call('/_ajax/Accept_Invite_Controller/accept', params);
+    }
+
+}
+
+// Path properties for type-safe routing
+Accept_Invite_Controller.accept.path = '/_ajax/Accept_Invite_Controller/accept';

storage-working/rsx-build/js-stubs/Debugger_Controller.js

@@ -0,0 +1,29 @@
+/**
+ * Auto-generated JavaScript stub for Debugger_Controller
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Debugger_Controller {
+    /**
+     * Call Debugger_Controller::log_console_messages via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async log_console_messages(params = {}) {
+        return Ajax.call('/_ajax/Debugger_Controller/log_console_messages', params);
+    }
+
+    /**
+     * Call Debugger_Controller::log_browser_errors via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async log_browser_errors(params = {}) {
+        return Ajax.call('/_ajax/Debugger_Controller/log_browser_errors', params);
+    }
+
+}
+
+// Path properties for type-safe routing
+Debugger_Controller.log_console_messages.path = '/_ajax/Debugger_Controller/log_console_messages';
+Debugger_Controller.log_browser_errors.path = '/_ajax/Debugger_Controller/log_browser_errors';

storage-working/rsx-build/js-stubs/Frontend_Clients_Controller.js

@@ -0,0 +1,49 @@
+/**
+ * Auto-generated JavaScript stub for Frontend_Clients_Controller
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Frontend_Clients_Controller {
+    /**
+     * Call Frontend_Clients_Controller::datagrid_fetch via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async datagrid_fetch(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Clients_Controller/datagrid_fetch', params);
+    }
+
+    /**
+     * Call Frontend_Clients_Controller::save via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async save(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Clients_Controller/save', params);
+    }
+
+    /**
+     * Call Frontend_Clients_Controller::delete via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async delete(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Clients_Controller/delete', params);
+    }
+
+    /**
+     * Call Frontend_Clients_Controller::restore via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async restore(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Clients_Controller/restore', params);
+    }
+
+}
+
+// Path properties for type-safe routing
+Frontend_Clients_Controller.datagrid_fetch.path = '/_ajax/Frontend_Clients_Controller/datagrid_fetch';
+Frontend_Clients_Controller.save.path = '/_ajax/Frontend_Clients_Controller/save';
+Frontend_Clients_Controller.delete.path = '/_ajax/Frontend_Clients_Controller/delete';
+Frontend_Clients_Controller.restore.path = '/_ajax/Frontend_Clients_Controller/restore';

storage-working/rsx-build/js-stubs/Frontend_Contacts_Controller.js

@@ -0,0 +1,49 @@
+/**
+ * Auto-generated JavaScript stub for Frontend_Contacts_Controller
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Frontend_Contacts_Controller {
+    /**
+     * Call Frontend_Contacts_Controller::datagrid_fetch via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async datagrid_fetch(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Contacts_Controller/datagrid_fetch', params);
+    }
+
+    /**
+     * Call Frontend_Contacts_Controller::get_clients via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async get_clients(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Contacts_Controller/get_clients', params);
+    }
+
+    /**
+     * Call Frontend_Contacts_Controller::get_client via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async get_client(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Contacts_Controller/get_client', params);
+    }
+
+    /**
+     * Call Frontend_Contacts_Controller::save via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async save(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Contacts_Controller/save', params);
+    }
+
+}
+
+// Path properties for type-safe routing
+Frontend_Contacts_Controller.datagrid_fetch.path = '/_ajax/Frontend_Contacts_Controller/datagrid_fetch';
+Frontend_Contacts_Controller.get_clients.path = '/_ajax/Frontend_Contacts_Controller/get_clients';
+Frontend_Contacts_Controller.get_client.path = '/_ajax/Frontend_Contacts_Controller/get_client';
+Frontend_Contacts_Controller.save.path = '/_ajax/Frontend_Contacts_Controller/save';

storage-working/rsx-build/js-stubs/Frontend_Projects_Controller.js

@@ -0,0 +1,29 @@
+/**
+ * Auto-generated JavaScript stub for Frontend_Projects_Controller
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Frontend_Projects_Controller {
+    /**
+     * Call Frontend_Projects_Controller::datagrid_fetch via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async datagrid_fetch(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Projects_Controller/datagrid_fetch', params);
+    }
+
+    /**
+     * Call Frontend_Projects_Controller::save via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async save(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Projects_Controller/save', params);
+    }
+
+}
+
+// Path properties for type-safe routing
+Frontend_Projects_Controller.datagrid_fetch.path = '/_ajax/Frontend_Projects_Controller/datagrid_fetch';
+Frontend_Projects_Controller.save.path = '/_ajax/Frontend_Projects_Controller/save';

storage-working/rsx-build/js-stubs/Frontend_Settings_Api_Keys_Controller.js

@@ -0,0 +1,29 @@
+/**
+ * Auto-generated JavaScript stub for Frontend_Settings_Api_Keys_Controller
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Frontend_Settings_Api_Keys_Controller {
+    /**
+     * Call Frontend_Settings_Api_Keys_Controller::generate via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async generate(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Settings_Api_Keys_Controller/generate', params);
+    }
+
+    /**
+     * Call Frontend_Settings_Api_Keys_Controller::revoke via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async revoke(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Settings_Api_Keys_Controller/revoke', params);
+    }
+
+}
+
+// Path properties for type-safe routing
+Frontend_Settings_Api_Keys_Controller.generate.path = '/_ajax/Frontend_Settings_Api_Keys_Controller/generate';
+Frontend_Settings_Api_Keys_Controller.revoke.path = '/_ajax/Frontend_Settings_Api_Keys_Controller/revoke';

storage-working/rsx-build/js-stubs/Frontend_Settings_Password_Security_Controller.js

@@ -0,0 +1,29 @@
+/**
+ * Auto-generated JavaScript stub for Frontend_Settings_Password_Security_Controller
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Frontend_Settings_Password_Security_Controller {
+    /**
+     * Call Frontend_Settings_Password_Security_Controller::change_password via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async change_password(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Settings_Password_Security_Controller/change_password', params);
+    }
+
+    /**
+     * Call Frontend_Settings_Password_Security_Controller::revoke_session via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async revoke_session(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Settings_Password_Security_Controller/revoke_session', params);
+    }
+
+}
+
+// Path properties for type-safe routing
+Frontend_Settings_Password_Security_Controller.change_password.path = '/_ajax/Frontend_Settings_Password_Security_Controller/change_password';
+Frontend_Settings_Password_Security_Controller.revoke_session.path = '/_ajax/Frontend_Settings_Password_Security_Controller/revoke_session';

storage-working/rsx-build/js-stubs/Frontend_Settings_Profile_Edit_Controller.js

@@ -0,0 +1,19 @@
+/**
+ * Auto-generated JavaScript stub for Frontend_Settings_Profile_Edit_Controller
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Frontend_Settings_Profile_Edit_Controller {
+    /**
+     * Call Frontend_Settings_Profile_Edit_Controller::save_profile via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async save_profile(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Settings_Profile_Edit_Controller/save_profile', params);
+    }
+
+}
+
+// Path properties for type-safe routing
+Frontend_Settings_Profile_Edit_Controller.save_profile.path = '/_ajax/Frontend_Settings_Profile_Edit_Controller/save_profile';

storage-working/rsx-build/js-stubs/Frontend_Settings_Site_Settings_Controller.js

@@ -0,0 +1,19 @@
+/**
+ * Auto-generated JavaScript stub for Frontend_Settings_Site_Settings_Controller
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Frontend_Settings_Site_Settings_Controller {
+    /**
+     * Call Frontend_Settings_Site_Settings_Controller::update via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async update(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Settings_Site_Settings_Controller/update', params);
+    }
+
+}
+
+// Path properties for type-safe routing
+Frontend_Settings_Site_Settings_Controller.update.path = '/_ajax/Frontend_Settings_Site_Settings_Controller/update';

storage-working/rsx-build/js-stubs/Frontend_Settings_User_Management_Controller.js

@@ -0,0 +1,59 @@
+/**
+ * Auto-generated JavaScript stub for Frontend_Settings_User_Management_Controller
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Frontend_Settings_User_Management_Controller {
+    /**
+     * Call Frontend_Settings_User_Management_Controller::datagrid_fetch via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async datagrid_fetch(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Settings_User_Management_Controller/datagrid_fetch', params);
+    }
+
+    /**
+     * Call Frontend_Settings_User_Management_Controller::add_user via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async add_user(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Settings_User_Management_Controller/add_user', params);
+    }
+
+    /**
+     * Call Frontend_Settings_User_Management_Controller::get_user_for_edit via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async get_user_for_edit(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Settings_User_Management_Controller/get_user_for_edit', params);
+    }
+
+    /**
+     * Call Frontend_Settings_User_Management_Controller::save_user via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async save_user(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Settings_User_Management_Controller/save_user', params);
+    }
+
+    /**
+     * Call Frontend_Settings_User_Management_Controller::send_invite via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async send_invite(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Settings_User_Management_Controller/send_invite', params);
+    }
+
+}
+
+// Path properties for type-safe routing
+Frontend_Settings_User_Management_Controller.datagrid_fetch.path = '/_ajax/Frontend_Settings_User_Management_Controller/datagrid_fetch';
+Frontend_Settings_User_Management_Controller.add_user.path = '/_ajax/Frontend_Settings_User_Management_Controller/add_user';
+Frontend_Settings_User_Management_Controller.get_user_for_edit.path = '/_ajax/Frontend_Settings_User_Management_Controller/get_user_for_edit';
+Frontend_Settings_User_Management_Controller.save_user.path = '/_ajax/Frontend_Settings_User_Management_Controller/save_user';
+Frontend_Settings_User_Management_Controller.send_invite.path = '/_ajax/Frontend_Settings_User_Management_Controller/send_invite';

storage-working/rsx-build/js-stubs/Frontend_Settings_User_Settings_Controller.js

@@ -0,0 +1,19 @@
+/**
+ * Auto-generated JavaScript stub for Frontend_Settings_User_Settings_Controller
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Frontend_Settings_User_Settings_Controller {
+    /**
+     * Call Frontend_Settings_User_Settings_Controller::update via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async update(params = {}) {
+        return Ajax.call('/_ajax/Frontend_Settings_User_Settings_Controller/update', params);
+    }
+
+}
+
+// Path properties for type-safe routing
+Frontend_Settings_User_Settings_Controller.update.path = '/_ajax/Frontend_Settings_User_Settings_Controller/update';

storage-working/rsx-build/js-stubs/Rsx_Formdata_Generator_Controller.js

@@ -0,0 +1,119 @@
+/**
+ * Auto-generated JavaScript stub for Rsx_Formdata_Generator_Controller
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Rsx_Formdata_Generator_Controller {
+    /**
+     * Call Rsx_Formdata_Generator_Controller::first_name via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async first_name(params = {}) {
+        return Ajax.call('/_ajax/Rsx_Formdata_Generator_Controller/first_name', params);
+    }
+
+    /**
+     * Call Rsx_Formdata_Generator_Controller::last_name via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async last_name(params = {}) {
+        return Ajax.call('/_ajax/Rsx_Formdata_Generator_Controller/last_name', params);
+    }
+
+    /**
+     * Call Rsx_Formdata_Generator_Controller::company_name via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async company_name(params = {}) {
+        return Ajax.call('/_ajax/Rsx_Formdata_Generator_Controller/company_name', params);
+    }
+
+    /**
+     * Call Rsx_Formdata_Generator_Controller::address via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async address(params = {}) {
+        return Ajax.call('/_ajax/Rsx_Formdata_Generator_Controller/address', params);
+    }
+
+    /**
+     * Call Rsx_Formdata_Generator_Controller::city via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async city(params = {}) {
+        return Ajax.call('/_ajax/Rsx_Formdata_Generator_Controller/city', params);
+    }
+
+    /**
+     * Call Rsx_Formdata_Generator_Controller::state via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async state(params = {}) {
+        return Ajax.call('/_ajax/Rsx_Formdata_Generator_Controller/state', params);
+    }
+
+    /**
+     * Call Rsx_Formdata_Generator_Controller::zip via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async zip(params = {}) {
+        return Ajax.call('/_ajax/Rsx_Formdata_Generator_Controller/zip', params);
+    }
+
+    /**
+     * Call Rsx_Formdata_Generator_Controller::phone via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async phone(params = {}) {
+        return Ajax.call('/_ajax/Rsx_Formdata_Generator_Controller/phone', params);
+    }
+
+    /**
+     * Call Rsx_Formdata_Generator_Controller::email via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async email(params = {}) {
+        return Ajax.call('/_ajax/Rsx_Formdata_Generator_Controller/email', params);
+    }
+
+    /**
+     * Call Rsx_Formdata_Generator_Controller::website via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async website(params = {}) {
+        return Ajax.call('/_ajax/Rsx_Formdata_Generator_Controller/website', params);
+    }
+
+    /**
+     * Call Rsx_Formdata_Generator_Controller::text via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async text(params = {}) {
+        return Ajax.call('/_ajax/Rsx_Formdata_Generator_Controller/text', params);
+    }
+
+}
+
+// Path properties for type-safe routing
+Rsx_Formdata_Generator_Controller.first_name.path = '/_ajax/Rsx_Formdata_Generator_Controller/first_name';
+Rsx_Formdata_Generator_Controller.last_name.path = '/_ajax/Rsx_Formdata_Generator_Controller/last_name';
+Rsx_Formdata_Generator_Controller.company_name.path = '/_ajax/Rsx_Formdata_Generator_Controller/company_name';
+Rsx_Formdata_Generator_Controller.address.path = '/_ajax/Rsx_Formdata_Generator_Controller/address';
+Rsx_Formdata_Generator_Controller.city.path = '/_ajax/Rsx_Formdata_Generator_Controller/city';
+Rsx_Formdata_Generator_Controller.state.path = '/_ajax/Rsx_Formdata_Generator_Controller/state';
+Rsx_Formdata_Generator_Controller.zip.path = '/_ajax/Rsx_Formdata_Generator_Controller/zip';
+Rsx_Formdata_Generator_Controller.phone.path = '/_ajax/Rsx_Formdata_Generator_Controller/phone';
+Rsx_Formdata_Generator_Controller.email.path = '/_ajax/Rsx_Formdata_Generator_Controller/email';
+Rsx_Formdata_Generator_Controller.website.path = '/_ajax/Rsx_Formdata_Generator_Controller/website';
+Rsx_Formdata_Generator_Controller.text.path = '/_ajax/Rsx_Formdata_Generator_Controller/text';

storage-working/rsx-build/js-stubs/Rsx_Reference_Data_Controller.js

@@ -0,0 +1,29 @@
+/**
+ * Auto-generated JavaScript stub for Rsx_Reference_Data_Controller
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Rsx_Reference_Data_Controller {
+    /**
+     * Call Rsx_Reference_Data_Controller::countries via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async countries(params = {}) {
+        return Ajax.call('/_ajax/Rsx_Reference_Data_Controller/countries', params);
+    }
+
+    /**
+     * Call Rsx_Reference_Data_Controller::states via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async states(params = {}) {
+        return Ajax.call('/_ajax/Rsx_Reference_Data_Controller/states', params);
+    }
+
+}
+
+// Path properties for type-safe routing
+Rsx_Reference_Data_Controller.countries.path = '/_ajax/Rsx_Reference_Data_Controller/countries';
+Rsx_Reference_Data_Controller.states.path = '/_ajax/Rsx_Reference_Data_Controller/states';

storage-working/rsx-build/js-stubs/Signup_Controller.js

@@ -0,0 +1,19 @@
+/**
+ * Auto-generated JavaScript stub for Signup_Controller
+ * DO NOT EDIT - This file is automatically regenerated
+ */
+
+class Signup_Controller {
+    /**
+     * Call Signup_Controller::submit via Ajax.call()
+     * @param {Object} params - Parameters object to pass to the method
+     * @returns {Promise<*>}
+     */
+    static async submit(params = {}) {
+        return Ajax.call('/_ajax/Signup_Controller/submit', params);
+    }
+
+}
+
+// Path properties for type-safe routing
+Signup_Controller.submit.path = '/_ajax/Signup_Controller/submit';