@superleapai/flow-ui 2.2.2 → 2.2.3

package/dist/superleap-flow.js

@@ -1,12 +1,12 @@
 /**
- * @superleapai/flow-ui v2.1.1
+ * @superleapai/flow-ui v2.2.2
  * A reusable design system for building multi-step forms
  *
  * Copyright (c) 2024-present SuperLeap
  * Licensed under MIT
  *
  * Build: development
- * Date: 2026-02-12T07:18:55.044Z
+ * Date: 2026-02-12T07:58:50.601Z
  *
  * For documentation and examples, visit:
  * https://github.com/superleap/superleap-flow
@@ -15,7 +15,2634 @@
   'use strict';
 
   // ============================================
-  // File 1/36: core/superleapClient.js
+  // File 1/37: node_modules/superleap-sdk/superleap.js
+  // ============================================
+
+  /**
+   * SuperLeap CRM SDK
+   * A Django-like SDK for interacting with SuperLeap API
+   * Version: 2.0.0 - Optimized for minimal API calls with opt-in caching
+   */
+
+  (function (global) {
+
+    // Data type mappings
+    const DataType = {
+      Int: 1,
+      Varchar: 5,
+      Checkbox: 6,
+      DateTime: 7,
+      Date: 8,
+      SecondsSinceMidnight: 9,
+      Email: 11,
+      Text: 14,
+      SingleSelect: 15,
+      MultiSelect: 16,
+      Url: 17,
+      FileUpload: 20,
+      PhoneNumber: 21,
+      Rating: 22,
+      Decimal: 4,
+      Currency: 23,
+      Stage: 24,
+      Location: 18,
+      Region: 27,
+      MultiFileUpload: 29,
+    };
+
+    const RelationshipType = {
+      OneToOne: 1,
+      OneToMany: 2,
+      ManyToOne: 3,
+      Restricted: 6,
+    };
+
+    /**
+     * Cache entry class with TTL support
+     * @class CacheEntry
+     */
+    class CacheEntry {
+      constructor(value, ttl = null) {
+        this.value = value;
+        this.createdAt = Date.now();
+        // Validate TTL - ensure it's a positive number or null
+        this.ttl = ttl && typeof ttl === "number" && ttl > 0 ? ttl : null;
+      }
+
+      isExpired() {
+        if (!this.ttl) return false;
+        return Date.now() - this.createdAt > this.ttl;
+      }
+
+      getValue() {
+        return this.isExpired() ? null : this.value;
+      }
+    }
+
+    /**
+     * Cache manager class
+     * @class CacheManager
+     */
+    class CacheManager {
+      constructor(options = {}) {
+        this.enabled = options.enabled !== false; // Default to enabled
+        this.maxSize = options.maxSize || 1000; // Maximum number of cache entries
+        this.defaultTTL = options.defaultTTL || 5 * 60 * 1000; // 5 minutes default
+        this.storage = new Map();
+        this.stats = {
+          hits: 0,
+          misses: 0,
+          sets: 0,
+          deletes: 0,
+          evictions: 0,
+        };
+      }
+
+      /**
+       * Get value from cache
+       * @param {string} key - Cache key
+       * @returns {any} Cached value or null if not found/expired
+       */
+      get(key) {
+        if (!this.enabled) return null;
+
+        const entry = this.storage.get(key);
+        if (!entry) {
+          this.stats.misses++;
+          return null;
+        }
+
+        if (entry.isExpired()) {
+          this.storage.delete(key);
+          this.stats.misses++;
+          return null;
+        }
+
+        this.stats.hits++;
+        return entry.getValue();
+      }
+
+      /**
+       * Set value in cache
+       * @param {string} key - Cache key
+       * @param {any} value - Value to cache
+       * @param {number} ttl - Time to live in milliseconds (optional)
+       */
+      set(key, value, ttl = null) {
+        if (!this.enabled) return;
+
+        // Validate TTL
+        const validTTL =
+          ttl && typeof ttl === "number" && ttl > 0 ? ttl : this.defaultTTL;
+
+        // Evict if cache is full
+        if (this.storage.size >= this.maxSize) {
+          this._evictOldest();
+        }
+
+        const entry = new CacheEntry(value, validTTL);
+        this.storage.set(key, entry);
+        this.stats.sets++;
+      }
+
+      /**
+       * Delete value from cache
+       * @param {string} key - Cache key
+       * @returns {boolean} True if key was found and deleted
+       */
+      delete(key) {
+        if (!this.enabled) return false;
+
+        const deleted = this.storage.delete(key);
+        if (deleted) {
+          this.stats.deletes++;
+        }
+        return deleted;
+      }
+
+      /**
+       * Clear all cache entries
+       */
+      clear() {
+        this.storage.clear();
+        this.stats = {
+          hits: 0,
+          misses: 0,
+          sets: 0,
+          deletes: 0,
+          evictions: 0,
+        };
+      }
+
+      /**
+       * Get cache statistics
+       * @returns {Object} Cache statistics
+       */
+      getStats() {
+        return {
+          ...this.stats,
+          size: this.storage.size,
+          maxSize: this.maxSize,
+          hitRate:
+            this.stats.hits + this.stats.misses > 0
+              ? (
+                  (this.stats.hits / (this.stats.hits + this.stats.misses)) *
+                  100
+                ).toFixed(2) + "%"
+              : "0%",
+        };
+      }
+
+      /**
+       * Evict oldest cache entry (LRU-like behavior)
+       * @private
+       */
+      _evictOldest() {
+        let oldestKey = null;
+        let oldestTime = Date.now();
+
+        for (const [key, entry] of this.storage.entries()) {
+          if (entry.createdAt < oldestTime) {
+            oldestTime = entry.createdAt;
+            oldestKey = key;
+          }
+        }
+
+        if (oldestKey) {
+          this.storage.delete(oldestKey);
+          this.stats.evictions++;
+        }
+      }
+
+      /**
+       * Clean expired entries
+       * @returns {number} Number of entries cleaned
+       */
+      cleanExpired() {
+        let cleaned = 0;
+        for (const [key, entry] of this.storage.entries()) {
+          if (entry.isExpired()) {
+            this.storage.delete(key);
+            cleaned++;
+          }
+        }
+        return cleaned;
+      }
+    }
+
+    // Operators constants
+    const Operators = {
+      EQ: "eq",
+      NEQ: "neq",
+      GT: "gt",
+      GTE: "gte",
+      LT: "lt",
+      LTE: "lte",
+      IN: "in",
+      NOT_IN: "nin",
+      LIKE: "ilike",
+      NOT_LIKE: "not_ilike",
+      SW: "starts_with",
+      EW: "ends_with",
+      IS_EMPTY: "is_empty",
+      NOT_EMPTY: "not_empty",
+      CONTAINS: "contains",
+      NOT_CONTAINS: "not_contains",
+      BETWEEN: "between",
+      LOWER_EQ: "leq",
+      LOWER_NOT_EQ: "nleq",
+      IN_ACCESSIBLE_OWNERS: "in_accessible_owners",
+    };
+
+    // Advanced Date Operators constants
+    const AdvancedDateOperators = {
+      TODAY: "is_today",
+      ON: "on",
+      IS_YESTERDAY: "is_yesterday",
+      BEFORE_TODAY: "before_today",
+      AFTER_TODAY: "after_today",
+      TOMORROW: "tomorrow",
+      THIS_WEEK: "this_week",
+      NEXT_WEEK: "next_week",
+      LAST_WEEK: "last_week",
+      LAST_SEVEN_DAYS: "last_seven_days",
+      LAST_TEN_DAYS: "last_ten_days",
+      LAST_FIFTEEN_DAYS: "last_fifteen_days",
+      LAST_THIRTY_DAYS: "last_thirty_days",
+      THIS_MONTH: "this_month",
+      NEXT_MONTH: "next_month",
+      LAST_MONTH: "last_month",
+      LAST_MONTH_TILL_DATE: "last_month_till_date",
+      LAST_NINETY_DAYS: "last_ninety_days",
+      THIS_QUARTER: "this_quarter",
+      NEXT_QUARTER: "next_quarter",
+      LAST_QUARTER: "last_quarter",
+      LAST_180_DAYS: "last_180_days",
+      LAST_365_DAYS: "last_365_days",
+      THIS_YEAR: "this_year",
+      NEXT_YEAR: "next_year",
+      LAST_YEAR: "last_year",
+      ALL_TIME: "all_time",
+    };
+
+    /**
+     * Helper function to check if a field value is empty
+     * @param {any} value - The value to check
+     * @returns {boolean} True if the value is considered empty
+     * @private
+     */
+    function isFieldValueEmpty(value) {
+      if (
+        (typeof value === "string" && value?.trim() === "") ||
+        value === null ||
+        value === undefined ||
+        (Array.isArray(value) && value.length === 0)
+      )
+        return true;
+    }
+
+    /**
+     * Helper function to check if a value can be empty for a given operator
+     * @param {string} operator - The operator to check
+     * @returns {boolean} True if the operator allows empty values
+     * @private
+     */
+    function isValueCanBeEmptyForOperator(operator) {
+      return (
+        Operators.IS_EMPTY === operator ||
+        Operators.NOT_EMPTY === operator ||
+        Operators.IN_ACCESSIBLE_OWNERS === operator ||
+        AdvancedDateOperators.TODAY === operator ||
+        AdvancedDateOperators.IS_YESTERDAY === operator ||
+        AdvancedDateOperators.BEFORE_TODAY === operator ||
+        AdvancedDateOperators.THIS_WEEK === operator ||
+        AdvancedDateOperators.LAST_WEEK === operator ||
+        AdvancedDateOperators.LAST_SEVEN_DAYS === operator ||
+        AdvancedDateOperators.LAST_FIFTEEN_DAYS === operator ||
+        AdvancedDateOperators.LAST_THIRTY_DAYS === operator ||
+        AdvancedDateOperators.THIS_MONTH === operator ||
+        AdvancedDateOperators.LAST_MONTH === operator ||
+        AdvancedDateOperators.LAST_MONTH_TILL_DATE === operator ||
+        AdvancedDateOperators.THIS_QUARTER === operator ||
+        AdvancedDateOperators.LAST_QUARTER === operator ||
+        AdvancedDateOperators.THIS_YEAR === operator ||
+        AdvancedDateOperators.LAST_YEAR === operator ||
+        AdvancedDateOperators.AFTER_TODAY === operator
+      );
+    }
+
+    /**
+     * Count valid conditions in a filter (recursive helper)
+     * @param {Object|Array} item - A filter item (condition, nested and/or, or array)
+     * @returns {number} Number of valid conditions
+     * @private
+     */
+    function countValidConditionsRecursive(item) {
+      if (!item || typeof item !== "object") {
+        return 0;
+      }
+
+      // If it's a direct condition (has field and operator)
+      if (item.field && item.operator) {
+        if (isValueCanBeEmptyForOperator(item.operator)) {
+          return 1;
+        }
+        return !isFieldValueEmpty(item.value) ? 1 : 0;
+      }
+
+      // If it's an array, count recursively for each item
+      if (Array.isArray(item)) {
+        return item.reduce((sum, subItem) => {
+          return sum + countValidConditionsRecursive(subItem);
+        }, 0);
+      }
+
+      // If it has nested 'and' or 'or', count recursively
+      let count = 0;
+      if (item.and && Array.isArray(item.and)) {
+        count += countValidConditionsRecursive(item.and);
+      }
+      if (item.or && Array.isArray(item.or)) {
+        count += countValidConditionsRecursive(item.or);
+      }
+
+      return count;
+    }
+
+    /**
+     * Count valid conditions in a filter
+     * @param {Object} filter - The filter object
+     * @param {string} mainCondition - The main condition type ('and' or 'or')
+     * @returns {number} Number of valid conditions
+     * @private
+     */
+    function countValidConditions(filter, mainCondition) {
+      const mainConditionGroups = filter[mainCondition];
+      if (!Array.isArray(mainConditionGroups)) {
+        return 0;
+      }
+      return countValidConditionsRecursive(mainConditionGroups);
+    }
+
+    /**
+     * Query builder class for constructing filters
+     * @class QueryBuilder
+     */
+    class QueryBuilder {
+      /**
+       * Create a new QueryBuilder instance
+       * @param {string} objectSlug - The object slug to query
+       * @param {SuperLeapSDK} sdk - The SDK instance
+       */
+      constructor(objectSlug, sdk) {
+        this.objectSlug = objectSlug;
+        this.sdk = sdk;
+        this.query = {
+          fields: [],
+          filters: {
+            and: [],
+            or: [],
+          },
+          sort: [],
+        };
+        this._executed = false;
+      }
+
+      /**
+       * Make QueryBuilder thenable (awaitable)
+       * @param {Function} onFulfilled - Success callback
+       * @param {Function} onRejected - Error callback
+       * @returns {Promise} Promise that resolves to array of RecordInstance objects
+       * @example
+       * // Await the query builder directly
+       * const records = await query;
+       */
+      then(onFulfilled, onRejected) {
+        return this._execute().then(onFulfilled, onRejected);
+      }
+
+      /**
+       * Make QueryBuilder catchable for error handling
+       * @param {Function} onRejected - Error callback
+       * @returns {Promise} Promise
+       */
+      catch(onRejected) {
+        return this._execute().catch(onRejected);
+      }
+
+      /**
+       * Make QueryBuilder finallyable for cleanup
+       * @param {Function} onFinally - Finally callback
+       * @returns {Promise} Promise
+       */
+      finally(onFinally) {
+        return this._execute().finally(onFinally);
+      }
+
+      /**
+       * Select specific fields
+       * @param {...string} fields - Fields to select (supports dot notation)
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Select specific fields
+       * query.select('name', 'email', 'created_at')
+       *
+       * // Select related fields using dot notation
+       * query.select('user.name', 'user.email')
+       */
+      select(...fields) {
+        this.query.fields = [...new Set([...this.query.fields, ...fields])];
+        return this;
+      }
+
+      /**
+       * Select all fields for the query
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Select all fields
+       * query.selectAll()
+       *
+       * // Use in a chain
+       * const records = await model.selectAll().limit(5);
+       */
+      selectAll() {
+        // Set flag to select all fields when executing the query
+        this._selectAll = true;
+
+        // For APIs that require empty fields array to return all fields
+        this.query.fields = [];
+
+        return this;
+      }
+
+      /**
+       * Add WHERE conditions using object notation
+       * @param {Object} conditions - Filter conditions as key-value pairs
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Simple where conditions
+       * query.where({ name: 'John', status: 'active' })
+       */
+      where(conditions) {
+        Object.entries(conditions).forEach(([field, value]) => {
+          this.query.filters.and.push({
+            field,
+            operator: "eq",
+            value,
+          });
+        });
+        return this;
+      }
+
+      /**
+       * Add complex AND conditions
+       * @param {Function} callback - Callback that receives a QueryBuilder for AND conditions
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Complex AND conditions
+       * query.whereAnd(q => {
+       *   q.gte('age', 18);
+       *   q.contains('name', 'John');
+       * })
+       */
+      whereAnd(callback) {
+        const subQuery = new QueryBuilder(this.objectSlug, this.sdk);
+        callback(subQuery);
+
+        const hasAnd = subQuery.query.filters.and.length > 0;
+        const hasOr = subQuery.query.filters.or.length > 0;
+
+        if (!hasAnd && !hasOr) {
+          return this; // Nothing to add
+        }
+
+        const conditions = [];
+
+        // Collect all AND conditions
+        if (hasAnd) {
+          conditions.push(...subQuery.query.filters.and);
+        }
+
+        // Collect OR conditions as a wrapped group
+        if (hasOr) {
+          conditions.push({ or: subQuery.query.filters.or });
+        }
+
+        // Optimization: if only one condition, add it directly
+        if (conditions.length === 1) {
+          this.query.filters.and.push(conditions[0]);
+        } else {
+          // Multiple conditions: wrap them in { and: [...] }
+          this.query.filters.and.push({ and: conditions });
+        }
+
+        return this;
+      }
+      /**
+       * Add complex OR conditions
+       * @param {Function} callback - Callback that receives a QueryBuilder for OR conditions
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Complex OR conditions
+       * query.whereOr(q => {
+       *   q.contains('name', 'a');
+       *   q.contains('name', 'b').whereAnd(r=>{r.startswith("email",'a')});
+       *   q.isnotempty('email');
+       * })
+       */
+      whereOr(callback) {
+        const subQuery = new QueryBuilder(this.objectSlug, this.sdk);
+        callback(subQuery);
+
+        const hasAnd = subQuery.query.filters.and.length > 0;
+        const hasOr = subQuery.query.filters.or.length > 0;
+
+        if (!hasAnd && !hasOr) {
+          return this; // Nothing to add
+        }
+
+        const conditions = [];
+
+        // Collect all AND conditions (they become OR siblings)
+        if (hasAnd) {
+          conditions.push(...subQuery.query.filters.and);
+        }
+
+        // Collect all OR conditions as direct siblings
+        if (hasOr) {
+          conditions.push(...subQuery.query.filters.or);
+        }
+
+        // Push all conditions to the OR array
+        conditions.forEach((condition) => {
+          this.query.filters.or.push(condition);
+        });
+
+        return this;
+      }
+
+      /**
+       * Add filter conditions with operators
+       * @param {string} field - Field name (supports dot notation)
+       * @param {string} operator - Filter operator (eq, contains, gt, lt, etc.)
+       * @param {any} value - Filter value
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Basic filter
+       * query.filter('name', 'contains', 'John')
+       *
+       * // Numeric filter
+       * query.filter('age', 'gte', 18)
+       */
+      filter(field, operator, value) {
+        this.query.filters.and.push({
+          field,
+          operator,
+          value,
+        });
+        return this;
+      }
+
+      // Django-style filter methods with correct backend operators
+
+      /**
+       * Exact match filter
+       * @param {string} field - Field name
+       * @param {any} value - Value to match exactly
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      exact(field, value) {
+        return this.filter(field, "eq", value);
+      }
+
+      /**
+       * Case-insensitive exact match filter
+       * @param {string} field - Field name
+       * @param {string} value - Value to match exactly (case-insensitive)
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      iexact(field, value) {
+        return this.filter(field, "leq", value);
+      }
+
+      /**
+       * Not exact match filter
+       * @param {string} field - Field name
+       * @param {any} value - Value to not match exactly
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      notexact(field, value) {
+        return this.filter(field, "neq", value);
+      }
+
+      /**
+       * Case-insensitive not exact match filter
+       * @param {string} field - Field name
+       * @param {string} value - Value to not match exactly (case-insensitive)
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      notiexact(field, value) {
+        return this.filter(field, "nleq", value);
+      }
+
+      /**
+       * Contains text filter (case-sensitive)
+       * @param {string} field - Field name
+       * @param {string} value - Text to search for
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      contains(field, value) {
+        return this.filter(field, "contains", value);
+      }
+
+      /**
+       * Contains text filter (case-insensitive)
+       * @param {string} field - Field name
+       * @param {string} value - Text to search for
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      icontains(field, value) {
+        return this.filter(field, "ilike", value);
+      }
+
+      /**
+       * Starts with text filter
+       * @param {string} field - Field name
+       * @param {string} value - Text that field should start with
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      startswith(field, value) {
+        return this.filter(field, "starts_with", value);
+      }
+
+      /**
+       * Ends with text filter
+       * @param {string} field - Field name
+       * @param {string} value - Text that field should end with
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      endswith(field, value) {
+        return this.filter(field, "ends_with", value);
+      }
+
+      /**
+       * In array filter
+       * @param {string} field - Field name
+       * @param {Array} values - Array of values to match
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      in(field, values) {
+        return this.filter(field, "in", values);
+      }
+
+      /**
+       * Not in array filter
+       * @param {string} field - Field name
+       * @param {Array} values - Array of values to exclude
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      notin(field, values) {
+        return this.filter(field, "nin", values);
+      }
+
+      /**
+       * Greater than filter
+       * @param {string} field - Field name
+       * @param {number|string} value - Value to compare against
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      gt(field, value) {
+        return this.filter(field, "gt", value);
+      }
+
+      /**
+       * Greater than or equal filter
+       * @param {string} field - Field name
+       * @param {number|string} value - Value to compare against
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      gte(field, value) {
+        return this.filter(field, "gte", value);
+      }
+
+      /**
+       * Less than filter
+       * @param {string} field - Field name
+       * @param {number|string} value - Value to compare against
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      lt(field, value) {
+        return this.filter(field, "lt", value);
+      }
+
+      /**
+       * Less than or equal filter
+       * @param {string} field - Field name
+       * @param {number|string} value - Value to compare against
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      lte(field, value) {
+        return this.filter(field, "lte", value);
+      }
+
+      /**
+       * Between values filter
+       * @param {string} field - Field name
+       * @param {Array} value - Array with [min, max] values
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      between(field, value) {
+        return this.filter(field, "between", value);
+      }
+
+      /**
+       * Does not contain text filter
+       * @param {string} field - Field name
+       * @param {string} value - Text that should not be contained
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      notcontains(field, value) {
+        return this.filter(field, "not_contains", value);
+      }
+
+      /**
+       * Field is empty filter
+       * @param {string} field - Field name
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      isempty(field) {
+        return this.filter(field, "is_empty", null);
+      }
+
+      /**
+       * Field is not empty filter
+       * @param {string} field - Field name
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      isnotempty(field) {
+        return this.filter(field, "not_empty", null);
+      }
+
+      /**
+       * Field exists filter
+       * @param {string} field - Field name
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      exists(field) {
+        return this.filter(field, "exists", null);
+      }
+
+      /**
+       * Field does not exist filter
+       * @param {string} field - Field name
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      notexists(field) {
+        return this.filter(field, "not_exists", null);
+      }
+
+      /**
+       * Like pattern filter
+       * @param {string} field - Field name
+       * @param {string} value - Pattern to match
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      like(field, value) {
+        return this.filter(field, "like", value);
+      }
+
+      /**
+       * Case-insensitive like pattern filter
+       * @param {string} field - Field name
+       * @param {string} value - Pattern to match
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       */
+      ilike(field, value) {
+        return this.filter(field, "ilike", value);
+      }
+
+      // Legacy support
+      /**
+       * Field is null filter (legacy)
+       * @param {string} field - Field name
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @deprecated Use isempty() instead
+       */
+      isnull(field) {
+        console.warn("isnull is deprecated, use isempty() instead");
+        return this.filter(field, "is_empty", null);
+      }
+
+      /**
+       * Field is not null filter (legacy)
+       * @param {string} field - Field name
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @deprecated Use isnotempty() instead
+       */
+      isnotnull(field) {
+        console.warn("isnotnull is deprecated, use isnotempty() instead");
+        return this.filter(field, "not_empty", null);
+      }
+
+      /**
+       * Add filter using complete filter structure directly
+       * @param {Object} filter - Complete filter object structure
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Direct filter with complete filter structure
+       * query.filterBy({ field: 'name', operator: 'contains', value: 'John' })
+       *
+       * // Multiple filters
+       * query.filterBy({ field: 'status', operator: 'eq', value: 'active' })
+       *     .filterBy({ field: 'age', operator: 'gte', value: 18 })
+       *
+       * // Complex filter with array value
+       * query.filterBy({ field: 'category', operator: 'in', value: ['A', 'B', 'C'] })
+       *
+       * // Complex AND/OR filters
+       * query.filterBy({
+       *   and: [
+       *     { field: 'status', operator: 'eq', value: 'active' },
+       *     { field: 'age', operator: 'gte', value: 18 }
+       *   ]
+       * })
+       */
+      filterBy(filter) {
+        if (!filter || typeof filter !== "object") {
+          throw new Error("Filter must be an object");
+        }
+
+        // Validate filter before adding it
+        let hasValidConditions = false;
+
+        // Check if it's a simple condition (has field and operator)
+        if (filter.field && filter.operator) {
+          // Simple condition validation
+          if (
+            isValueCanBeEmptyForOperator(filter.operator) ||
+            !isFieldValueEmpty(filter.value)
+          ) {
+            hasValidConditions = true;
+          }
+        } else {
+          // Complex condition validation (and/or structure)
+          if (filter.and && countValidConditions(filter, "and") > 0) {
+            hasValidConditions = true;
+          }
+          if (filter.or && countValidConditions(filter, "or") > 0) {
+            hasValidConditions = true;
+          }
+        }
+
+        // Only add the filter if it has valid conditions
+        if (hasValidConditions) {
+          // If filter only has 'and' property (no 'or' and no direct field/operator),
+          // merge its conditions into this.query.filters.and to avoid extra wrapping
+          if (
+            filter.and &&
+            Array.isArray(filter.and) &&
+            !filter.or &&
+            !filter.field &&
+            !filter.operator
+          ) {
+            this.query.filters.and.push(...filter.and);
+          }
+          // If filter only has 'or' property, merge into this.query.filters.or
+          else if (
+            filter.or &&
+            Array.isArray(filter.or) &&
+            !filter.and &&
+            !filter.field &&
+            !filter.operator
+          ) {
+            this.query.filters.or.push(...filter.or);
+          }
+          // Otherwise, push the entire filter object (for mixed and/or or simple conditions)
+          else {
+            this.query.filters.and.push(filter);
+          }
+        } else {
+          console.warn(
+            "FilterBy: Skipping filter with no valid conditions",
+            filter
+          );
+        }
+
+        return this;
+      }
+
+      /**
+       * Order by fields
+       * @param {...string} fields - Fields to order by (prefix with '-' for descending)
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Order by single field ascending
+       * query.orderBy('name')
+       *
+       * // Order by multiple fields
+       * query.orderBy('name', '-created_at')
+       */
+      orderBy(...fields) {
+        this.query.sort = fields.map((field) => {
+          if (field.startsWith("-")) {
+            return { field: field.slice(1), direction: "desc" };
+          }
+          return { field, direction: "asc" };
+        });
+        return this;
+      }
+
+      /**
+       * Limit results
+       * @param {number} limit - Maximum number of results
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Limit to 10 results
+       * query.limit(10)
+       */
+      limit(limit) {
+        if (!this.query.pagination) {
+          this.query.pagination = { page: 1, page_size: limit };
+        } else {
+          this.query.pagination.page_size = limit;
+        }
+        return this;
+      }
+
+      /**
+       * Set page number
+       * @param {number} page - Page number (1-based)
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Get page 2
+       * query.page(2)
+       */
+      page(page) {
+        if (!this.query.pagination) {
+          this.query.pagination = { page: page, page_size: 100 };
+        } else {
+          this.query.pagination.page = page;
+        }
+        return this;
+      }
+
+      /**
+       * Offset results (converted to page)
+       * @param {number} offset - Number of results to skip
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Skip first 20 results
+       * query.offset(20)
+       */
+      offset(offset) {
+        if (!this.query.pagination) {
+          this.query.pagination = {
+            page: Math.floor(offset / 100) + 1,
+            page_size: 100,
+          };
+        } else {
+          const pageSize = this.query.pagination.page_size;
+          this.query.pagination.page = Math.floor(offset / pageSize) + 1;
+        }
+        return this;
+      }
+
+      /**
+       * Execute the query and return results (internal method)
+       * @returns {Promise<RecordInstance[]>} Array of RecordInstance objects
+       * @private
+       */
+      async _execute() {
+        if (this._executed) {
+          console.warn("Query already executed. Create a new query builder.");
+          return [];
+        }
+
+        try {
+          // Handle selectAll in two ways:
+          // 1. Try to get explicit field list from schema
+          // 2. If that fails, use empty array approach which works for some APIs
+          if (this._selectAll === true) {
+            try {
+              // First attempt: Get schema and extract field names
+              const model = this.sdk.getModel(this.objectSlug);
+              const schema = await model.getSchema();
+
+              if (
+                schema &&
+                schema.org_object_columns &&
+                Array.isArray(schema.org_object_columns)
+              ) {
+                // Get all field slugs from the schema
+                this.query.fields = schema.org_object_columns
+                  .filter((col) => col && col.slug)
+                  .filter(
+                    (col) =>
+                      !col.relation ||
+                      (col.relation &&
+                        col.relationship_type !== RelationshipType.OneToMany)
+                  )
+                  .map((col) => col.slug);
+                if (this.query.fields.length > 0) {
+                  console.log(
+                    `Using ${this.query.fields.length} explicit fields from schema`
+                  );
+                } else {
+                  console.warn(
+                    "Schema returned no valid fields, using empty fields array"
+                  );
+                }
+              } else {
+                console.warn(
+                  "No valid schema structure found, using empty fields array"
+                );
+              }
+            } catch (error) {
+              console.error("Error fetching schema fields:", error);
+              // Second approach: Empty fields array often means "all fields" in many APIs
+              console.log("Falling back to empty fields array");
+            }
+          }
+
+          // Prepare query
+          const queryData = { ...this.query };
+
+          // Ensure id field is always included if we have other fields
+          if (queryData.fields.length > 0 && !queryData.fields.includes("id")) {
+            queryData.fields.push("id");
+          }
+
+          // Add default sorting if none specified
+          if (queryData.sort.length === 0) {
+            queryData.sort = [{ field: "id", direction: "desc" }];
+          }
+
+          // Build filter structure - API requires filters to be present
+          queryData.filters = this._buildFilterStructure(queryData.filters);
+
+          // If no filters, provide empty AND structure
+          if (!queryData.filters) {
+            queryData.filters = { and: [] };
+          }
+
+          console.log("Executing query with fields:", queryData.fields);
+          // Use user-defined cache options or defaults
+          const cacheOptions = this._cacheOptions || {};
+          const result = await this.sdk.getRecords(
+            this.objectSlug,
+            queryData,
+            cacheOptions
+          );
+          this._executed = true;
+
+          if (result.success) {
+            // Handle different response structures
+            let records = [];
+            if (Array.isArray(result.data)) {
+              records = result.data;
+            } else if (result.data && Array.isArray(result.data.records)) {
+              records = result.data.records;
+            } else if (
+              result.data &&
+              result.data.data &&
+              Array.isArray(result.data.data)
+            ) {
+              records = result.data.data;
+            }
+
+            console.log(`Query returned ${records.length} records`);
+
+            // Convert to RecordInstance objects
+            return records.map(
+              (record) =>
+                new RecordInstance(record, this.sdk.getModel(this.objectSlug))
+            );
+          } else {
+            console.warn("Query failed:", result.message);
+            return [];
+          }
+        } catch (error) {
+          console.error("Error executing query:", error);
+          return [];
+        }
+      }
+
+      /**
+       * Build proper filter structure for complex queries
+       * @param {Object} filters - Filter object
+       * @returns {Object|null}
+       * @private
+       */
+      _buildFilterStructure(filters) {
+        if (!filters || (!filters.and.length && !filters.or.length)) {
+          return null;
+        }
+
+        const result = {};
+
+        if (filters.and.length > 0) {
+          result.and = filters.and;
+        }
+
+        if (filters.or.length > 0) {
+          result.or = filters.or;
+        }
+
+        return result;
+      }
+
+      /**
+       * Get first result
+       * @returns {Promise<RecordInstance|null>} First RecordInstance or null if no results
+       * @example
+       * // Get first matching record
+       * const record = await query.first();
+       */
+      async first() {
+        this.limit(1);
+        const results = await this._execute();
+        return results.length > 0 ? results[0] : null;
+      }
+
+      /**
+       * Get count of results
+       * @returns {Promise<number>} Number of matching records
+       * @example
+       * // Get count of matching records
+       * const count = await query.count();
+       */
+      async count() {
+        const filterData = this._buildFilterStructure(this.query.filters);
+
+        // Use user-defined cache options or defaults
+        const cacheOptions = this._cacheOptions || {};
+
+        const result = await this.sdk.getRecordsCount(
+          this.objectSlug,
+          filterData,
+          cacheOptions
+        );
+        return result.success ? result.data.count : 0;
+      }
+
+      /**
+       * Check if any records exist
+       * @returns {Promise<boolean>} True if records exist, false otherwise
+       * @example
+       * // Check if any records match the query
+       * const exists = await query.exists();
+       */
+      async exists() {
+        const count = await this.count();
+        return count > 0;
+      }
+
+      /**
+       * Set cache options for this query
+       * @param {Object} options - Cache options
+       * @param {boolean} options.useCache - Whether to use cache (default: false)
+       * @param {number} options.cacheTTL - Custom TTL for this query
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Enable cache for this query
+       * const records = await query.cache().where({ status: 'active' });
+       *
+       * // Use custom TTL for this query
+       * const records = await query.cacheTTL(60 * 1000).where({ status: 'active' });
+       */
+      cacheOptions(options = {}) {
+        this._cacheOptions = options;
+        return this;
+      }
+
+      /**
+       * Disable cache for this query
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Force fresh data
+       * const records = await query.noCache().where({ status: 'active' });
+       */
+      noCache() {
+        return this.cacheOptions({ useCache: false });
+      }
+
+      /**
+       * Set custom TTL for this query
+       * @param {number} ttl - TTL in milliseconds
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Cache for 1 hour
+       * const records = await query.cacheTTL(60 * 60 * 1000).where({ status: 'active' });
+       */
+      cacheTTL(ttl) {
+        return this.cacheOptions({ useCache: true, cacheTTL: ttl });
+      }
+
+      /**
+       * Enable caching for this query
+       * @param {Object} options - Cache options
+       * @param {number} options.ttl - Custom TTL for this query (optional)
+       * @returns {QueryBuilder} Returns this QueryBuilder instance for method chaining
+       * @example
+       * // Enable caching with default TTL (can be at the end of chain)
+       * const records = await query.where({ status: 'active' }).cache();
+       *
+       * // Enable caching with custom TTL (can be at the end of chain)
+       * const records = await query.where({ status: 'active' }).cache({ ttl: 60 * 60 * 1000 });
+       *
+       * // Enable caching in the middle of chain
+       * const records = await query.select('name', 'email').cache().where({ status: 'active' }).limit(10);
+       */
+      cache(options = {}) {
+        return this.cacheOptions({ useCache: true, cacheTTL: options.ttl });
+      }
+    }
+
+    /**
+     * Record instance class
+     * @class RecordInstance
+     */
+    class RecordInstance {
+      /**
+       * Create a new RecordInstance
+       * @param {Object} data - Record data
+       * @param {Model} model - Model instance
+       */
+      constructor(data, model) {
+        if (!data || typeof data !== "object") {
+          throw new Error("Record data must be a valid object");
+        }
+        if (!model) {
+          throw new Error("Model instance is required");
+        }
+        this.data = data;
+        this.model = model;
+        this.id = data.id;
+      }
+
+      /**
+       * Get field value
+       * @param {string} field - Field name
+       * @returns {any} Field value
+       * @example
+       * // Get a field value
+       * const name = record.get('name');
+       */
+      get(field) {
+        if (!this.data || typeof this.data !== "object") {
+          throw new Error("Record data is not valid");
+        }
+        const availableFields = Object.keys(this.data);
+        if (!(field in this.data)) {
+          throw new Error(
+            `Field '${field}' not found. Available fields: ${availableFields.join(
+            ", "
+          )}`
+          );
+        }
+        return this.data[field];
+      }
+
+      /**
+       * Set field value
+       * @param {string} field - Field name
+       * @param {any} value - Field value
+       * @example
+       * // Set a field value
+       * record.set('name', 'New Name');
+       */
+      set(field, value) {
+        this.data[field] = value;
+      }
+
+      /**
+       * Update this record
+       * @param {Object} updateData - Data to update
+       * @returns {Promise<RecordInstance>} Updated RecordInstance
+       * @example
+       * @deprecated Use mode('object').update(id,updatedData) instead
+       * // Update record fields
+       * const updated = await record.update({ name: 'New Name', status: 'active' });
+       */
+      async update(updateData) {
+        console.warn(
+          "update is deprecated, use model('object').update(id,updatedData) instead"
+        );
+        try {
+          const updatedRecord = await this.model.update(this.id, updateData);
+          // Update our local data with the response from the server
+          this.data = updatedRecord.data;
+          return this;
+        } catch (error) {
+          throw new Error(error.message || "Update failed");
+        }
+      }
+
+      /**
+       * Delete this record
+       * @returns {Promise<boolean>} True if deletion was successful
+       * @example
+       * // Delete the record
+       * const deleted = await record.delete();
+       */
+      async delete() {
+        const result = await this.model.delete(this.id);
+        return result.success;
+      }
+
+      /**
+       * Refresh this record from the server
+       * @returns {Promise<RecordInstance>} Refreshed RecordInstance
+       * @example
+       * // Refresh record data from server
+       * const refreshed = await record.refresh();
+       */
+      async refresh() {
+        const fresh = await this.model.get(this.id);
+        this.data = fresh.data;
+        return this;
+      }
+
+      /**
+       * Convert to plain object
+       * @returns {Object} Plain object representation of the record
+       * @example
+       * // Convert to plain object
+       * const plainObject = record.toJSON();
+       */
+      toJSON() {
+        return this.data;
+      }
+    }
+
+    /**
+     * Model class representing a SuperLeap object
+     * @class Model
+     */
+    class Model {
+      /**
+       * Create a new Model instance
+       * @param {string} objectSlug - Object slug
+       * @param {SuperLeapSDK} sdk - SDK instance
+       */
+      constructor(objectSlug, sdk) {
+        this.objectSlug = objectSlug;
+        this.sdk = sdk;
+        this._schema = null;
+        this._schemaLoaded = false;
+      }
+
+      /**
+       * Get schema for this object (lazy loaded)
+       * @returns {Promise<Object>} Object schema
+       * @example
+       * // Get object schema
+       * const schema = await model.getSchema();
+       */
+      async getSchema() {
+        try {
+          if (!this._schemaLoaded) {
+            console.log(`Fetching schema for ${this.objectSlug}...`);
+            const result = await this.sdk.getObjectSchema(this.objectSlug);
+            if (result.success && result.data) {
+              this._schema = result.data;
+              this._schemaLoaded = true;
+              console.log(`Schema loaded for ${this.objectSlug}`);
+            } else {
+              console.warn(
+                `Failed to load schema for ${this.objectSlug}:`,
+                result.message
+              );
+            }
+          }
+          return this._schema;
+        } catch (error) {
+          console.error(`Error loading schema for ${this.objectSlug}:`, error);
+          return null;
+        }
+      }
+
+      /**
+       * Get field information
+       * @param {string} fieldSlug - Field slug
+       * @returns {Promise<Object|null>} Field information or null if not found
+       * @example
+       * // Get field information
+       * const field = await model.getField('name');
+       */
+      async getField(fieldSlug) {
+        const schema = await this.getSchema();
+        if (!schema || !schema.org_object_columns) return null;
+
+        const column = schema.org_object_columns.find(
+          (col) => col.slug === fieldSlug
+        );
+        if (!column) return null;
+
+        return {
+          slug: column.slug,
+          displayName: column.display_name,
+          dataType: column.column_data_type,
+          isRequired: column.is_required === 1,
+          isUnique: column.is_unique === 1,
+          enumGroup: column.enum_group,
+          constraints: column.constraints,
+          properties: column.properties,
+        };
+      }
+
+      /**
+       * Get all fields
+       * @returns {Promise<Array>} Array of field objects
+       * @example
+       * // Get all fields
+       * const fields = await model.getFields();
+       */
+      async getFields() {
+        try {
+          const schema = await this.getSchema();
+          if (!schema) {
+            console.warn(`No schema available for ${this.objectSlug}`);
+            return [];
+          }
+
+          if (
+            !schema.org_object_columns ||
+            !Array.isArray(schema.org_object_columns)
+          ) {
+            console.warn(
+              `Schema for ${this.objectSlug} doesn't contain org_object_columns array`
+            );
+            return [];
+          }
+
+          console.log(
+            `Found ${schema.org_object_columns.length} fields for ${this.objectSlug}`
+          );
+
+          return schema.org_object_columns.map((column) => ({
+            slug: column.slug,
+            displayName: column.display_name,
+            dataType: column.column_data_type,
+            isRequired: column.is_required === 1,
+            isUnique: column.is_unique === 1,
+            enumGroup: column.enum_group,
+            constraints: column.constraints,
+            properties: column.properties,
+          }));
+        } catch (error) {
+          console.error(`Error getting fields for ${this.objectSlug}:`, error);
+          return [];
+        }
+      }
+
+      /**
+       * Create a new query builder with field selection
+       * @param {...string} fields - Fields to select (supports dot notation)
+       * @returns {QueryBuilder} New QueryBuilder instance
+       * @example
+       * // Select specific fields
+       * const query = model.select('name', 'email', 'created_at');
+       */
+      select(...fields) {
+        const queryBuilder = new QueryBuilder(this.objectSlug, this.sdk);
+        return queryBuilder.select(...fields);
+      }
+
+      /**
+       * Create a new query builder with all fields selected
+       * @returns {QueryBuilder} New QueryBuilder instance
+       * @example
+       * // Select all fields
+       * const query = model.selectAll();
+       * @deprecated Use select() with fields
+       */
+      selectAll() {
+        console.warn("selectAll is deprecated, use select() with fields instead");
+        const queryBuilder = new QueryBuilder(this.objectSlug, this.sdk);
+        return queryBuilder.selectAll();
+      }
+
+      /**
+       * Create a new record
+       * @param {Object} data - Record data
+       * @returns {Promise<RecordInstance>} Created RecordInstance
+       * @example
+       * // Create a new record
+       * const record = await model.create({ name: 'John Doe', email: 'john@example.com' });
+       */
+      async create(data) {
+        const result = await this.sdk.createRecord(this.objectSlug, data);
+        if (result.success) {
+          // Invalidate cache for this object since we added a new record
+          this.sdk.invalidateCache(this.objectSlug);
+          return new RecordInstance(result.data, this);
+        }
+        throw new Error(JSON.stringify(result.data));
+      }
+
+      /**
+       * Get record by ID with all fields
+       * @param {string} id - Record ID
+       * @returns {Promise<RecordInstance>} RecordInstance
+       * @example
+       * // Get record by ID
+       * const record = await model.get('record-id');
+       * @deprecated Use select()
+       */
+      async get(id) {
+        console.warn("get is deprecated, use select() instead");
+        const result = await this.sdk.getRecordById(this.objectSlug, id);
+        if (result.success) {
+          return new RecordInstance(result.data, this);
+        }
+        throw new Error(result.message || "Record not found");
+      }
+
+      /**
+       * Update record
+       * @param {string} id - Record ID
+       * @param {Object} data - Update data
+       * @returns {Promise<RecordInstance>} Updated RecordInstance
+       * @example
+       * // Update record
+       * const updated = await model.update('record-id', { name: 'Updated Name' });
+       */
+      async update(id, data) {
+        const result = await this.sdk.updateRecord(this.objectSlug, id, data);
+
+        if (result.success) {
+          // Invalidate cache for this object since we updated a record
+          this.sdk.invalidateCache(this.objectSlug);
+          return new RecordInstance(result.data || {}, this);
+        }
+      }
+
+      /**
+       * Delete record
+       * @param {string} id - Record ID
+       * @returns {Promise<boolean>} True if deletion was successful
+       * @example
+       * // Delete record
+       * const deleted = await model.delete('record-id');
+       */
+      async delete(id) {
+        const result = await this.sdk.deleteRecord(this.objectSlug, id);
+        if (result.success) {
+          // Invalidate cache for this object since we deleted a record
+          this.sdk.invalidateCache(this.objectSlug);
+        }
+        return result.success;
+      }
+
+      /**
+       * Delete multiple records
+       * @param {string[]} ids - Array of record IDs
+       * @returns {Promise<boolean>} True if deletion was successful
+       * @example
+       * // Delete multiple records
+       * const deleted = await model.deleteMany(['id1', 'id2', 'id3']);
+       */
+      async deleteMany(ids) {
+        const result = await this.sdk.deleteRecords(this.objectSlug, ids);
+        if (result.success) {
+          // Invalidate cache for this object since we deleted records
+          this.sdk.invalidateCache(this.objectSlug);
+        }
+        return result.success;
+      }
+
+      /**
+       * Get or create a record
+       * @param {Object} filters - Filter conditions to find existing record
+       * @param {Object} defaults - Default values for creation
+       * @returns {Promise<{record: RecordInstance, created: boolean}>} Result object with record and created flag
+       * @deprecated dont use at all
+       * @example
+       * // Get or create record
+       * const result = await model.getOrCreate(
+       *   { email: 'john@example.com' },
+       *   { name: 'John Doe', status: 'active' }
+       * );
+       */
+      async getOrCreate(filters, defaults = {}) {
+        console.warn("getOrCreate is deprecated, use select() instead");
+        const existing = await this.selectAll().where(filters).first();
+        if (existing) {
+          // existing is already a RecordInstance from first(), don't wrap it again
+          return { record: existing, created: false };
+        }
+
+        const createData = { ...defaults, ...filters };
+        const newRecord = await this.create(createData);
+        console.warn("getOrCreate is deprecated, use select() instead");
+        return { record: newRecord, created: true };
+      }
+
+      /**
+       * Update or create a record
+       * @param {Object} filters - Filter conditions to find existing record
+       * @param {Object} defaults - Default values for creation/update
+       * @returns {Promise<{record: RecordInstance, created: boolean}>} Result object with record and created flag
+       * @deprecated Use model('object').update(id,updatedData) instead
+       * @example
+       * // Update or create record
+       * const result = await model.updateOrCreate(
+       *   { email: 'john@example.com' },
+       *   { name: 'John Doe', status: 'active' }
+       * );
+       */
+      async updateOrCreate(filters, defaults = {}) {
+        console.warn(
+          "updateOrCreate is deprecated, use model('object').update(id,updatedData) instead"
+        );
+        const existing = await this.selectAll().where(filters).first();
+        if (existing) {
+          const updated = await this.update(existing.id, defaults);
+          return { record: updated, created: false };
+        }
+
+        const createData = { ...defaults, ...filters };
+        const newRecord = await this.create(createData);
+        return { record: newRecord, created: true };
+      }
+
+      /**
+       * Bulk create records using the bulk_upsert API
+       * @param {Array} records - Array of record data
+       * @param {boolean} ignoreDuplicates - Whether to ignore duplicates (default: true for create)
+       * @returns {Promise<Array<RecordInstance>>} Array of created RecordInstance objects
+       * @example
+       * // Bulk create records
+       * const records = await model.bulkCreate([
+       *   { name: 'John', email: 'john@example.com' },
+       *   { name: 'Jane', email: 'jane@example.com' }
+       * ]);
+       */
+      async bulkCreate(
+        records,
+        ignoreDuplicates = true,
+        enablePartialUpsert = false
+      ) {
+        const result = await this.sdk.bulkUpsert(
+          this.objectSlug,
+          records,
+          true,
+          enablePartialUpsert
+        );
+        if (result.success) {
+          // Invalidate cache for this object since we created records
+          this.sdk.invalidateCache(this.objectSlug);
+
+          // Handle the response structure - look for records property first, then fall back to data
+          const responseRecords = result.data?.records || [];
+          return responseRecords.map(
+            (recordData) => new RecordInstance(recordData, this)
+          );
+        }
+        throw new Error(result.message || "Bulk create failed");
+      }
+
+      /**
+       * Bulk update records using the bulk_upsert API
+       * @param {Array} records - Array of record data with IDs
+       * @param {boolean} ignoreDuplicates - Whether to ignore duplicates (default: false for update)
+       * @returns {Promise<Array<RecordInstance>>} Array of updated RecordInstance objects
+       * @example
+       * // Bulk update records
+       * const records = await model.bulkUpdate([
+       *   { id: 'record-id-1', name: 'Updated John' },
+       *   { id: 'record-id-2', email: 'updated@example.com' }
+       * ]);
+       */
+      async bulkUpdate(
+        records,
+        ignoreDuplicates = false,
+        enablePartialUpsert = false
+      ) {
+        const result = await this.sdk.bulkUpsert(
+          this.objectSlug,
+          records,
+          ignoreDuplicates,
+          enablePartialUpsert,
+          true
+        );
+        if (result.success) {
+          // Invalidate cache for this object since we updated records
+          this.sdk.invalidateCache(this.objectSlug);
+
+          // Handle the response structure - look for records property first, then fall back to data
+          const responseRecords = result.data?.records || [];
+          return responseRecords.map(
+            (recordData) => new RecordInstance(recordData, this)
+          );
+        }
+        throw new Error(result.message || "Bulk update failed");
+      }
+    }
+
+    /**
+     * Main SDK class
+     * @class SuperLeapSDK
+     */
+    class SuperLeapSDK {
+      /**
+       * Create a new SuperLeapSDK instance
+       * @param {Object} options - Configuration options
+       * @param {string} options.apiKey - API key for authentication
+       * @param {string} options.baseUrl - Base URL for API requests
+       * @param {string} options.clientId - Client ID for authentication
+       * @param {string} options.clientSecret - Client secret for authentication
+       * @param {Object} options.cache - Cache configuration options
+       * @param {boolean} options.cache.enabled - Enable/disable caching (default: false)
+       * @param {number} options.cache.maxSize - Maximum cache entries (default: 1000)
+       * @param {number} options.cache.defaultTTL - Default TTL in milliseconds (default: 5 minutes)
+       * @param {Object} options.cache.ttl - Specific TTL settings for different operations
+       * @param {number} options.cache.ttl.schema - TTL for schema cache (default: 30 minutes)
+       * @param {number} options.cache.ttl.records - TTL for record queries (default: 2 minutes)
+       * @param {number} options.cache.ttl.count - TTL for count queries (default: 1 minute)
+       */
+      constructor(options = {}) {
+        this.apiKey = options.apiKey || null;
+        this.baseUrl = options.baseUrl || "https://app.superleap.dev/api/v1";
+        this.clientId = options.clientId || "";
+        this.clientSecret = options.clientSecret || "";
+
+        // Validate cache options
+        const cacheOptions = options.cache || {};
+        if (
+          cacheOptions.maxSize &&
+          (typeof cacheOptions.maxSize !== "number" || cacheOptions.maxSize <= 0)
+        ) {
+          console.warn("Invalid cache maxSize, using default: 1000");
+          cacheOptions.maxSize = 1000;
+        }
+        if (
+          cacheOptions.defaultTTL &&
+          (typeof cacheOptions.defaultTTL !== "number" ||
+            cacheOptions.defaultTTL <= 0)
+        ) {
+          console.warn("Invalid cache defaultTTL, using default: 5 minutes");
+          cacheOptions.defaultTTL = 5 * 60 * 1000;
+        }
+
+        // Initialize cache manager
+        this.cache = new CacheManager(cacheOptions);
+
+        // Cache TTL settings with validation
+        this.cacheTTL = {
+          schema:
+            cacheOptions.ttl?.schema &&
+            typeof cacheOptions.ttl.schema === "number" &&
+            cacheOptions.ttl.schema > 0
+              ? cacheOptions.ttl.schema
+              : 30 * 60 * 1000, // 30 minutes
+          records:
+            cacheOptions.ttl?.records &&
+            typeof cacheOptions.ttl.records === "number" &&
+            cacheOptions.ttl.records > 0
+              ? cacheOptions.ttl.records
+              : 2 * 60 * 1000, // 2 minutes
+          count:
+            cacheOptions.ttl?.count &&
+            typeof cacheOptions.ttl.count === "number" &&
+            cacheOptions.ttl.count > 0
+              ? cacheOptions.ttl.count
+              : 60 * 1000, // 1 minute
+          user:
+            cacheOptions.ttl?.user &&
+            typeof cacheOptions.ttl.user === "number" &&
+            cacheOptions.ttl.user > 0
+              ? cacheOptions.ttl.user
+              : 10 * 60 * 1000, // 10 minutes
+        };
+
+        this._models = new Map();
+        this._schemas = new Map();
+      }
+
+      /**
+       * Get model by object slug (creates if not exists)
+       * @param {string} objectSlug - Object slug
+       * @returns {Model} Model instance
+       * @example
+       * // Get model for 'user' object
+       * const userModel = sdk.getModel('user');
+       */
+      getModel(objectSlug) {
+        if (!this._models.has(objectSlug)) {
+          this._models.set(objectSlug, new Model(objectSlug, this));
+        }
+        return this._models.get(objectSlug);
+      }
+
+      async getCurrentUserData() {
+        const result = await this.request("/org/user/me", {
+          cache: {
+            useCache: false,
+            ttl: this.cacheTTL.user,
+          },
+        });
+        return result?.data;
+      }
+
+      async getCurrentUser() {
+        const result = await this.request("/org/user/me", {
+          cache: {
+            useCache: false,
+            ttl: this.cacheTTL.user,
+          },
+        });
+
+        const userData = {
+          user: {
+            id: result.data.user_id,
+            name: result.data.user_name,
+            email: result.data.user_email,
+          },
+          orgId: result.data.org_id,
+          timezone: result.data.timezone,
+        };
+
+        return userData;
+      }
+
+      /**
+       * Get model using property access
+       * @param {string} objectSlug - Object slug
+       * @returns {Model} Model instance
+       * @example
+       * // Get model using property access
+       * const userModel = sdk.model('user');
+       */
+      model(objectSlug) {
+        return this.getModel(objectSlug);
+      }
+
+      /**
+       * Get schema by object slug (cached)
+       * @param {string} objectSlug - Object slug
+       * @returns {Promise<Object>} Schema object
+       * @example
+       * // Get object schema
+       * const schema = await sdk.getObjectSchema('user');
+       */
+      async getObjectSchema(objectSlug) {
+        try {
+          console.log(`Fetching schema from API for ${objectSlug}`);
+          const result = await this.request(`/org/objects/${objectSlug}`, {
+            cache: {
+              useCache: false,
+              ttl: this.cacheTTL.schema,
+            },
+          });
+
+          if (result.success && result.data) {
+            console.log(`Successfully fetched schema for ${objectSlug}`);
+            // Also update legacy cache for backward compatibility
+            this._schemas.set(objectSlug, result.data);
+          } else {
+            console.warn(
+              `Failed to fetch schema for ${objectSlug}:`,
+              result.message
+            );
+          }
+
+          return result;
+        } catch (error) {
+          console.error(`Error fetching schema for ${objectSlug}:`, error);
+          return {
+            success: false,
+            data: null,
+            message: error instanceof Error ? error.message : "Unknown error",
+          };
+        }
+      }
+
+      /**
+       * Check if a request is cacheable
+       * @param {string} endpoint - API endpoint
+       * @param {string} method - HTTP method
+       * @param {Object} body - Request body
+       * @returns {boolean} True if request is cacheable
+       * @private
+       */
+      _isCacheableRequest(endpoint, method, body) {
+        // Cache GET requests
+        if (method === "GET") return true;
+
+        // Cache certain POST requests that are read-only
+        if (method === "POST") {
+          // Cache filter requests
+          if (endpoint.includes("/filter") && !endpoint.includes("/delete")) {
+            return true;
+          }
+          // Cache count requests
+          if (endpoint.includes("/filter/count")) {
+            return true;
+          }
+          // Cache schema requests
+          if (
+            endpoint.includes("/org/objects/") &&
+            !endpoint.includes("/record")
+          ) {
+            return true;
+          }
+        }
+
+        return false;
+      }
+
+      /**
+       * Generate cache key for a request
+       * @param {string} endpoint - API endpoint
+       * @param {string} method - HTTP method
+       * @param {Object} body - Request body
+       * @returns {string} Cache key
+       * @private
+       */
+      _generateCacheKey(endpoint, method, body) {
+        const keyParts = [method, endpoint];
+
+        if (body && Object.keys(body).length > 0) {
+          try {
+            // Sort body keys for consistent cache keys
+            const sortedBody = Object.keys(body)
+              .sort()
+              .reduce((result, key) => {
+                result[key] = body[key];
+                return result;
+              }, {});
+            keyParts.push(JSON.stringify(sortedBody));
+          } catch (error) {
+            // Handle circular references or other JSON.stringify errors
+            console.warn(
+              "Failed to generate cache key, using fallback:",
+              error.message
+            );
+            keyParts.push("fallback:" + Date.now());
+          }
+        }
+
+        return keyParts.join(":");
+      }
+
+      /**
+       * Get default TTL for an endpoint
+       * @param {string} endpoint - API endpoint
+       * @returns {number} TTL in milliseconds
+       * @private
+       */
+      _getDefaultTTL(endpoint) {
+        // Schema requests - long TTL
+        if (endpoint.includes("/org/objects/") && !endpoint.includes("/record")) {
+          return this.cacheTTL.schema;
+        }
+
+        // User data requests
+        if (endpoint.includes("/org/user/me")) {
+          return this.cacheTTL.user;
+        }
+
+        // Count requests - short TTL
+        if (endpoint.includes("/filter/count")) {
+          return this.cacheTTL.count;
+        }
+
+        // Record filter requests - medium TTL
+        if (endpoint.includes("/filter")) {
+          return this.cacheTTL.records;
+        }
+
+        // Default TTL
+        return this.cache.defaultTTL;
+      }
+
+      /**
+       * Set the API key for authentication
+       * @param {string} apiKey - The Bearer token
+       * @example
+       * // Set API key
+       * sdk.setApiKey('your-api-key');
+       */
+      setApiKey(apiKey) {
+        this.apiKey = apiKey;
+      }
+
+      /**
+       * Set client credentials
+       * @param {string} clientId - Client ID
+       * @param {string} clientSecret - Client Secret
+       * @example
+       * // Set client credentials
+       * sdk.setClientCredentials('client-id', 'client-secret');
+       */
+      setClientCredentials(clientId, clientSecret) {
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+      }
+
+      /**
+       * Enable or disable caching
+       * @param {boolean} enabled - Whether to enable caching
+       * @example
+       * // Disable caching
+       * sdk.setCacheEnabled(false);
+       */
+      setCacheEnabled(enabled) {
+        this.cache.enabled = enabled;
+      }
+
+      /**
+       * Clear all cache entries
+       * @example
+       * // Clear all cache
+       * sdk.clearCache();
+       */
+      clearCache() {
+        this.cache.clear();
+        this._schemas.clear();
+        this._models.clear();
+      }
+
+      /**
+       * Get cache statistics
+       * @returns {Object} Cache statistics
+       * @example
+       * // Get cache stats
+       * const stats = sdk.getCacheStats();
+       * console.log('Hit rate:', stats.hitRate);
+       */
+      getCacheStats() {
+        return this.cache.getStats();
+      }
+
+      /**
+       * Invalidate cache for specific object
+       * @param {string} objectSlug - Object slug to invalidate
+       * @example
+       * // Invalidate cache for user object
+       * sdk.invalidateCache('user');
+       */
+      invalidateCache(objectSlug) {
+        if (objectSlug) {
+          try {
+            // Clear cache entries that match the object slug
+            const keysToDelete = [];
+            for (const [key] of this.cache.storage.entries()) {
+              if (
+                key.includes(`/org/objects/${objectSlug}`) ||
+                key.includes(`schema:${objectSlug}`) ||
+                key.includes(`fields:${objectSlug}`)
+              ) {
+                keysToDelete.push(key);
+              }
+            }
+
+            keysToDelete.forEach((key) => this.cache.delete(key));
+            this._schemas.delete(objectSlug);
+            this._models.delete(objectSlug);
+          } catch (error) {
+            console.warn("Error during cache invalidation:", error.message);
+            // Fallback: clear all cache
+            this.clearCache();
+          }
+        } else {
+          // Clear all cache
+          this.clearCache();
+        }
+      }
+
+      /**
+       * Clean expired cache entries
+       * @returns {number} Number of entries cleaned
+       * @example
+       * // Clean expired entries
+       * const cleaned = sdk.cleanExpiredCache();
+       */
+      cleanExpiredCache() {
+        return this.cache.cleanExpired();
+      }
+
+      /**
+       * Make a request to the API
+       * @param {string} endpoint - API endpoint
+       * @param {Object} options - Request options
+       * @param {string} options.method - HTTP method
+       * @param {Object} options.headers - Request headers
+       * @param {Object|FormData} options.body - Request body
+       * @param {Object} options.cache - Cache options
+       * @param {boolean} options.cache.useCache - Whether to use cache (default: false)
+       * @param {number} options.cache.ttl - Custom TTL for this request
+       * @param {string} options.cache.key - Custom cache key (auto-generated if not provided)
+       * @returns {Promise<Object>} Response object
+       * @example
+       * // Make a GET request
+       * const response = await sdk.request('/org/objects');
+       *
+       * // Make a POST request
+       * const response = await sdk.request('/org/objects/user/record', {
+       *   method: 'POST',
+       *   body: { name: 'John Doe' }
+       * });
+       *
+       * // Make a request with custom cache options
+       * const response = await sdk.request('/org/objects/user/filter', {
+       *   method: 'POST',
+       *   body: { filters: { and: [{ field: 'status', operator: 'eq', value: 'active' }] } },
+       *   cache: { useCache: true, ttl: 60 * 1000 }
+       * });
+       */
+      async request(endpoint, options = {}) {
+        const { method = "GET", headers = {}, body, cache = {} } = options;
+        const { useCache = false, ttl = null, key = null } = cache;
+
+        const requestHeaders = {
+          "Content-Type": "application/json",
+          "Client-ID": this.clientId,
+          "Client-Secret": this.clientSecret,
+          ...headers,
+        };
+
+        if (this.apiKey) {
+          requestHeaders.Authorization = `Bearer ${this.apiKey}`;
+        }
+
+        const isFormData = body instanceof FormData;
+        if (isFormData) {
+          delete requestHeaders["Content-Type"];
+        }
+
+        const url = `${this.baseUrl}${
+        endpoint.startsWith("/") ? endpoint : `/${endpoint}`
+      }`;
+
+        // Handle caching for GET requests and certain POST requests
+        if (
+          useCache &&
+          (method === "GET" || this._isCacheableRequest(endpoint, method, body))
+        ) {
+          // Generate cache key if not provided
+          const cacheKey = key || this._generateCacheKey(endpoint, method, body);
+
+          // Check cache first
+          const cached = this.cache.get(cacheKey);
+          if (cached) {
+            console.log(`Using cached response for ${endpoint}`);
+            async function nextTick(value) {
+              return new Promise((resolve) => {
+                setTimeout(() => resolve(value), 0);
+              });
+            }
+
+            return nextTick(cached);
+          }
+
+          // Make the actual request
+          const result = await this._makeRequest(
+            url,
+            method,
+            requestHeaders,
+            body,
+            isFormData
+          );
+
+          // Cache successful responses
+          if (result.success) {
+            const cacheTTL = ttl || this._getDefaultTTL(endpoint);
+            this.cache.set(cacheKey, result, cacheTTL);
+          }
+
+          return result;
+        }
+
+        // For non-cacheable requests, make the request directly
+        return await this._makeRequest(
+          url,
+          method,
+          requestHeaders,
+          body,
+          isFormData
+        );
+      }
+
+      /**
+       * Make the actual HTTP request (internal method)
+       * @param {string} url - Full URL
+       * @param {string} method - HTTP method
+       * @param {Object} headers - Request headers
+       * @param {Object|FormData} body - Request body
+       * @param {boolean} isFormData - Whether body is FormData
+       * @returns {Promise<Object>} Response object
+       * @private
+       */
+      async _makeRequest(url, method, headers, body, isFormData) {
+        try {
+          const response = await fetch(url, {
+            method,
+            headers: headers,
+            body: isFormData ? body : body ? JSON.stringify(body) : undefined,
+          });
+
+          // Check if response is JSON before parsing
+          const contentType = response.headers.get("content-type");
+          let responseData = {};
+
+          if (contentType && contentType.includes("application/json")) {
+            try {
+              responseData = await response.json();
+            } catch (jsonError) {
+              console.warn("Failed to parse JSON response:", jsonError);
+              responseData = { message: await response.text() };
+            }
+          } else {
+            // Handle non-JSON responses (like HTML error pages)
+            const textResponse = await response.text();
+            responseData = { message: textResponse };
+          }
+
+          return {
+            data: responseData.data || null,
+            status: response.status,
+            success: response.ok,
+            message: responseData.message || response.statusText,
+          };
+        } catch (error) {
+          console.error("API request failed:", error);
+          return {
+            data: error,
+            status: 0,
+            success: false,
+            message:
+              error instanceof Error ? error.message : "Unknown error occurred",
+          };
+        }
+      }
+
+      /**
+       * Get records with filtering
+       * @param {string} objectSlug - Object slug
+       * @param {Object} filtersData - Filter data
+       * @param {Object} options - Additional options
+       * @param {boolean} options.useCache - Whether to use cache (default: false)
+       * @param {number} options.cacheTTL - Custom TTL for this request
+       * @returns {Promise<Object>} Response object
+       * @example
+       * // Get records with filters
+       * const response = await sdk.getRecords('user', {
+       *   filters: { and: [{ field: 'status', operator: 'eq', value: 'active' }] }
+       * });
+       *
+       * // Get records with cache
+       * const response = await sdk.getRecords('user', filtersData, { useCache: true });
+       */
+      async getRecords(objectSlug, filtersData = null, options = {}) {
+        const { useCache = false, cacheTTL = null } = options;
+
+        return this.request(`/org/objects/${objectSlug}/filter`, {
+          method: "POST",
+          body: { query: filtersData },
+          cache: {
+            useCache,
+            ttl: cacheTTL || this.cacheTTL.records,
+          },
+        });
+      }
+
+      /**
+       * Get record by ID
+       * @param {string} objectSlug - Object slug
+       * @param {string} id - Record ID
+       * @returns {Promise<Object>} Response object
+       * @example
+       * // Get record by ID
+       * const response = await sdk.getRecordById('user', 'user-id');
+       */
+      async getRecordById(objectSlug, id) {
+        return this.request(`/org/objects/${objectSlug}/record/${id}`, {
+          cache: {
+            useCache: false,
+            ttl: this.cacheTTL.records,
+          },
+        });
+      }
+
+      /**
+       * Create a new record
+       * @param {string} objectSlug - Object slug
+       * @param {Object} createData - Record data
+       * @returns {Promise<Object>} Response object
+       * @example
+       * // Create a new record
+       * const response = await sdk.createRecord('user', {
+       *   name: 'John Doe',
+       *   email: 'john@example.com'
+       * });
+       */
+      async createRecord(objectSlug, createData) {
+        return this.request(`/org/objects/${objectSlug}/record`, {
+          method: "POST",
+          body: createData,
+          cache: {
+            useCache: false, // Don't cache create operations
+          },
+        });
+      }
+
+      /**
+       * Update a record
+       * @param {string} objectSlug - Object slug
+       * @param {string} id - Record ID
+       * @param {Object} updateData - Update data
+       * @returns {Promise<Object>} Response object
+       * @example
+       * // Update a record
+       * const response = await sdk.updateRecord('user', 'user-id', {
+       *   name: 'Updated Name'
+       * });
+       */
+      async updateRecord(objectSlug, id, updateData) {
+        return this.request(`/org/objects/${objectSlug}/record/${id}`, {
+          method: "PUT",
+          body: updateData,
+          cache: {
+            useCache: false, // Don't cache update operations
+          },
+        });
+      }
+
+      /**
+       * Delete a record
+       * @param {string} objectSlug - Object slug
+       * @param {string} id - Record ID
+       * @returns {Promise<Object>} Response object
+       * @example
+       * // Delete a record
+       * const response = await sdk.deleteRecord('user', 'user-id');
+       */
+      async deleteRecord(objectSlug, recordId) {
+        return this.request(`/org/objects/${objectSlug}/record/delete`, {
+          method: "POST",
+          body: { record_ids: [recordId] },
+          cache: {
+            useCache: false, // Don't cache delete operations
+          },
+        });
+      }
+
+      /**
+       * Delete multiple records
+       * @param {string} objectSlug - Object slug
+       * @param {string[]} recordIds - Record IDs
+       * @returns {Promise<Object>} Response object
+       * @example
+       * // Delete multiple records
+       * const response = await sdk.deleteRecords('user', ['id1', 'id2', 'id3']);
+       */
+      async deleteRecords(objectSlug, recordIds) {
+        return this.request(`/org/objects/${objectSlug}/record/delete`, {
+          method: "POST",
+          body: { record_ids: recordIds },
+          cache: {
+            useCache: false, // Don't cache delete operations
+          },
+        });
+      }
+
+      /**
+       * Get record count
+       * @param {string} objectSlug - Object slug
+       * @param {Object} filtersData - Filter data
+       * @param {Object} options - Additional options
+       * @param {boolean} options.useCache - Whether to use cache (default: false)
+       * @param {number} options.cacheTTL - Custom TTL for this request
+       * @returns {Promise<Object>} Response object
+       * @example
+       * // Get record count
+       * const response = await sdk.getRecordsCount('user', {
+       *   and: [{ field: 'status', operator: 'eq', value: 'active' }]
+       * });
+       *
+       * // Get count with cache
+       * const response = await sdk.getRecordsCount('user', filtersData, { useCache: true });
+       */
+      async getRecordsCount(objectSlug, filtersData = null, options = {}) {
+        const { useCache = false, cacheTTL = null } = options;
+
+        const query = {};
+        if (filtersData) {
+          query.filters = filtersData;
+        }
+
+        return this.request(`/org/objects/${objectSlug}/filter/count`, {
+          method: "POST",
+          body: { query },
+          cache: {
+            useCache,
+            ttl: cacheTTL || this.cacheTTL.count,
+          },
+        });
+      }
+
+      /**
+       * Bulk upsert records (create or update)
+       * @param {string} objectSlug - Object slug
+       * @param {Array} records - Array of record data
+       * @param {boolean} ignoreDuplicates - Whether to ignore duplicates
+       * @returns {Promise<Object>} Response object
+       * @example
+       * // Bulk upsert records
+       * const response = await sdk.bulkUpsert('lead', [
+       *   { name: 'John', email: 'john@example.com' },
+       *   { id: 'record-id', name: 'Updated John' }
+       * ], false);
+       */
+      async bulkUpsert(
+        objectSlug,
+        records,
+        ignoreDuplicates = false,
+        enablePartialUpsert = false,
+        disableCreate = false
+      ) {
+        return this.request(`/org/objects/${objectSlug}/record/bulk_upsert`, {
+          method: "POST",
+          body: {
+            values: records,
+            ignore_duplicates: ignoreDuplicates,
+            enable_partial_upsert: enablePartialUpsert,
+            disable_create: disableCreate,
+          },
+          cache: {
+            useCache: false, // Don't cache bulk operations
+          },
+        });
+      }
+
+      /**
+       * Transactional bulk create records across multiple objects
+       * @param {Array} records - Array of objects with object_slug and record properties
+       * @param {boolean} partialUpsert - Whether to enable partial upsert (default: false)
+       * @returns {Promise<Object>} Response object
+       * @example
+       * // Transactional bulk create records across multiple objects
+       * const response = await sdk.transactionalBulkCreate([
+       *   { object_slug: 'user', record: { name: 'John', email: 'john@example.com' } },
+       *   { object_slug: 'lead', record: { name: 'Jane', email: 'jane@example.com' } }
+       * ]);
+       */
+      async transactionalBulkCreate(records, partialUpsert = false) {
+        // Transform records from [{object_slug:'',record:recordData}] to {object_slug: records[]}
+        const transformedValues = {};
+
+        records.forEach((record) => {
+          const { object_slug, record: recordData } = record;
+          if (!transformedValues[object_slug]) {
+            transformedValues[object_slug] = [];
+          }
+          transformedValues[object_slug].push(recordData);
+        });
+
+        return this.request(`/org/objects/record/bulk_upsert`, {
+          method: "POST",
+          body: {
+            values: transformedValues,
+            ignore_duplicates: true,
+            partial_upsert: partialUpsert,
+          },
+          cache: {
+            useCache: false, // Don't cache bulk operations
+          },
+        });
+      }
+
+      /**
+       * Transactional bulk update records across multiple objects
+       * @param {Array} records - Array of objects with object_slug and record properties (record must contain id)
+       * @param {boolean} partialUpsert - Whether to enable partial upsert (default: false)
+       * @returns {Promise<Object>} Response object
+       * @example
+       * // Transactional bulk update records across multiple objects
+       * const response = await sdk.transactionalBulkUpdate([
+       *   { object_slug: 'user', record: { id: 'user-id', name: 'Updated John' } },
+       *   { object_slug: 'lead', record: { id: 'lead-id', status: 'qualified' } }
+       * ]);
+       */
+      async transactionalBulkUpdate(records, partialUpsert = false) {
+        // Transform records from [{object_slug:'',record:recordData}] to {object_slug: records[]}
+        const transformedValues = {};
+
+        records.forEach((record) => {
+          const { object_slug, record: recordData } = record;
+          if (!transformedValues[object_slug]) {
+            transformedValues[object_slug] = [];
+          }
+          transformedValues[object_slug].push(recordData);
+        });
+
+        return this.request(`/org/objects/record/bulk_upsert`, {
+          method: "POST",
+          body: {
+            values: transformedValues,
+            ignore_duplicates: false,
+            partial_upsert: partialUpsert,
+            disable_create: true,
+          },
+          cache: {
+            useCache: false, // Don't cache bulk operations
+          },
+        });
+      }
+      /**
+       * Transactional bulk upsert records across multiple objects (create or update)
+       * @param {Array} records - Array of objects with object_slug and record properties (id in record required for updates)
+       * @param {boolean} partialUpsert - Whether to enable partial upsert (default: false)
+       * @returns {Promise<Object>} Response object
+       * @example
+       * // Transactional bulk upsert records across multiple objects
+       * const response = await sdk.transactionalBulkUpsert([
+       *   { object_slug: 'user', record: { name: 'John', email: 'john@example.com' } }, // Create
+       *   { object_slug: 'lead', record: { id: 'lead-id', status: 'qualified' } } // Update
+       * ]);
+       */
+      async transactionalBulkUpsert(records, partialUpsert = false) {
+        // Transform records from [{object_slug:'',record:recordData}] to {object_slug: records[]}
+        const transformedValues = {};
+
+        records.forEach((record) => {
+          const { object_slug, record: recordData } = record;
+          if (!transformedValues[object_slug]) {
+            transformedValues[object_slug] = [];
+          }
+          transformedValues[object_slug].push(recordData);
+        });
+
+        return this.request(`/org/objects/record/bulk_upsert`, {
+          method: "POST",
+          body: {
+            values: transformedValues,
+            ignore_duplicates: false,
+            partial_upsert: partialUpsert,
+          },
+          cache: {
+            useCache: false, // Don't cache bulk operations
+          },
+        });
+      }
+    }
+
+    /**
+     * Create a new SDK instance
+     * @param {Object} options - Configuration options
+     * @returns {SuperLeapSDK} SuperLeapSDK instance
+     * @example
+     * // Create SDK instance
+     * const sdk = createSuperLeapSDK({
+     *   apiKey: 'your-api-key',
+     *   baseUrl: 'https://app.superleap.dev/api/v1'
+     * });
+     */
+    function createSuperLeapSDK(options = {}) {
+      return new SuperLeapSDK(options);
+    }
+
+    // Expose to global scope
+    global.SuperLeapSDK = SuperLeapSDK;
+    global.createSuperLeapSDK = createSuperLeapSDK;
+    global.CacheManager = CacheManager;
+    global.CacheEntry = CacheEntry;
+
+    // Support CommonJS and AMD
+    if (typeof module !== "undefined" && module.exports) {
+      module.exports = {
+        SuperLeapSDK,
+        createSuperLeapSDK,
+        DataType,
+        RelationshipType,
+        CacheManager,
+        CacheEntry,
+        Operators,
+        AdvancedDateOperators,
+      };
+    } else if (typeof define === "function" && define.amd) {
+      define([], function () {
+        return {
+          SuperLeapSDK,
+          createSuperLeapSDK,
+          DataType,
+          RelationshipType,
+          CacheManager,
+          CacheEntry,
+          Operators,
+          AdvancedDateOperators,
+        };
+      });
+    }
+  })(typeof window !== "undefined" ? window : undefined);
+
+
+
+  // ============================================
+  // File 2/37: core/superleapClient.js
   // ============================================
 
   /**
@@ -167,7 +2794,7 @@
 
 
   // ============================================
-  // File 2/36: core/bridge.js
+  // File 3/37: core/bridge.js
   // ============================================
 
   /**
@@ -695,7 +3322,7 @@
 
 
   // ============================================
-  // File 3/36: core/crm.js
+  // File 4/37: core/crm.js
   // ============================================
 
   /**
@@ -1037,7 +3664,7 @@
 
 
   // ============================================
-  // File 4/36: components/label.js
+  // File 5/37: components/label.js
   // ============================================
 
   /**
@@ -1154,7 +3781,7 @@
 
 
   // ============================================
-  // File 5/36: core/flow.js
+  // File 6/37: core/flow.js
   // ============================================
 
   /**
@@ -2889,7 +5516,7 @@
 
 
   // ============================================
-  // File 6/36: components/toast.js
+  // File 7/37: components/toast.js
   // ============================================
 
   /**
@@ -3238,7 +5865,7 @@
 
 
   // ============================================
-  // File 7/36: components/alert.js
+  // File 8/37: components/alert.js
   // ============================================
 
   /**
@@ -3526,7 +6153,7 @@
 
 
   // ============================================
-  // File 8/36: components/button.js
+  // File 9/37: components/button.js
   // ============================================
 
   /**
@@ -3733,7 +6360,7 @@
 
 
   // ============================================
-  // File 9/36: components/spinner.js
+  // File 10/37: components/spinner.js
   // ============================================
 
   /**
@@ -3875,7 +6502,7 @@
 
 
   // ============================================
-  // File 10/36: components/badge.js
+  // File 11/37: components/badge.js
   // ============================================
 
   /**
@@ -4016,7 +6643,7 @@
 
 
   // ============================================
-  // File 11/36: components/avatar.js
+  // File 12/37: components/avatar.js
   // ============================================
 
   /**
@@ -4217,7 +6844,7 @@
 
 
   // ============================================
-  // File 12/36: components/icon.js
+  // File 13/37: components/icon.js
   // ============================================
 
   /**
@@ -4423,7 +7050,7 @@
 
 
   // ============================================
-  // File 13/36: components/popover.js
+  // File 14/37: components/popover.js
   // ============================================
 
   /**
@@ -4669,7 +7296,7 @@
 
 
   // ============================================
-  // File 14/36: components/select.js
+  // File 15/37: components/select.js
   // ============================================
 
   /**
@@ -5219,7 +7846,7 @@
 
 
   // ============================================
-  // File 15/36: components/enum-select.js
+  // File 16/37: components/enum-select.js
   // ============================================
 
   /**
@@ -6051,7 +8678,7 @@
 
 
   // ============================================
-  // File 16/36: components/record-select.js
+  // File 17/37: components/record-select.js
   // ============================================
 
   /**
@@ -6968,7 +9595,7 @@
 
 
   // ============================================
-  // File 17/36: components/multiselect.js
+  // File 18/37: components/multiselect.js
   // ============================================
 
   /**
@@ -7325,7 +9952,7 @@
 
 
   // ============================================
-  // File 18/36: components/enum-multiselect.js
+  // File 19/37: components/enum-multiselect.js
   // ============================================
 
   /**
@@ -8195,7 +10822,7 @@
 
 
   // ============================================
-  // File 19/36: components/record-multiselect.js
+  // File 20/37: components/record-multiselect.js
   // ============================================
 
   /**
@@ -9157,7 +11784,7 @@
 
 
   // ============================================
-  // File 20/36: components/input.js
+  // File 21/37: components/input.js
   // ============================================
 
   /**
@@ -9422,7 +12049,7 @@
 
 
   // ============================================
-  // File 21/36: components/currency.js
+  // File 22/37: components/currency.js
   // ============================================
 
   /**
@@ -9655,7 +12282,7 @@
 
 
   // ============================================
-  // File 22/36: components/textarea.js
+  // File 23/37: components/textarea.js
   // ============================================
 
   /**
@@ -9775,7 +12402,7 @@
 
 
   // ============================================
-  // File 23/36: components/checkbox.js
+  // File 24/37: components/checkbox.js
   // ============================================
 
   /**
@@ -10035,7 +12662,7 @@
 
 
   // ============================================
-  // File 24/36: components/radio-group.js
+  // File 25/37: components/radio-group.js
   // ============================================
 
   /**
@@ -10446,7 +13073,7 @@
 
 
   // ============================================
-  // File 25/36: components/enumeration.js
+  // File 26/37: components/enumeration.js
   // ============================================
 
   /**
@@ -10665,7 +13292,7 @@
 
 
   // ============================================
-  // File 26/36: components/time-picker.js
+  // File 27/37: components/time-picker.js
   // ============================================
 
   /**
@@ -11028,7 +13655,7 @@
 
 
   // ============================================
-  // File 27/36: components/duration/duration-utils.js
+  // File 28/37: components/duration/duration-utils.js
   // ============================================
 
   /**
@@ -11198,7 +13825,7 @@
 
 
   // ============================================
-  // File 28/36: components/duration/duration-constants.js
+  // File 29/37: components/duration/duration-constants.js
   // ============================================
 
   /**
@@ -11250,7 +13877,7 @@
 
 
   // ============================================
-  // File 29/36: components/duration/duration.js
+  // File 30/37: components/duration/duration.js
   // ============================================
 
   /**
@@ -11704,7 +14331,7 @@
 
 
   // ============================================
-  // File 30/36: components/date-time-picker/date-time-picker-utils.js
+  // File 31/37: components/date-time-picker/date-time-picker-utils.js
   // ============================================
 
   /**
@@ -11963,7 +14590,7 @@
 
 
   // ============================================
-  // File 31/36: components/date-time-picker/date-time-picker.js
+  // File 32/37: components/date-time-picker/date-time-picker.js
   // ============================================
 
   /**
@@ -12499,7 +15126,7 @@
 
 
   // ============================================
-  // File 32/36: components/phone-input/phone-utils.js
+  // File 33/37: components/phone-input/phone-utils.js
   // ============================================
 
   /**
@@ -12662,7 +15289,7 @@
 
 
   // ============================================
-  // File 33/36: components/phone-input/phone-input.js
+  // File 34/37: components/phone-input/phone-input.js
   // ============================================
 
   /**
@@ -13060,7 +15687,7 @@
 
 
   // ============================================
-  // File 34/36: components/file-input.js
+  // File 35/37: components/file-input.js
   // ============================================
 
   /**
@@ -13599,7 +16226,7 @@
 
 
   // ============================================
-  // File 35/36: components/table.js
+  // File 36/37: components/table.js
   // ============================================
 
   /**
@@ -13940,7 +16567,7 @@
 
 
   // ============================================
-  // File 36/36: index.js
+  // File 37/37: index.js
   // ============================================
 
   /**
@@ -14177,7 +16804,7 @@
             },
           });
           document.dispatchEvent(event);
-          console.log("[Superleap-Flow] Library ready - v2.1.1");
+          console.log("[Superleap-Flow] Library ready - v2.2.2");
         }, 0);
       }
     }