@squidcloud/client 1.0.144-beta → 1.0.145-beta

package/dist/cjs/index.js

@@ -7361,6 +7361,567 @@ __exportStar(__webpack_require__(4356), exports);
 __exportStar(__webpack_require__(9862), exports);
 //# sourceMappingURL=index.js.map
 
+/***/ }),
+
+/***/ 9372:
+/***/ (function(module, exports) {
+
+var global = typeof self !== 'undefined' ? self : this;
+var __self__ = (function () {
+function F() {
+this.fetch = false;
+this.DOMException = global.DOMException
+}
+F.prototype = global;
+return new F();
+})();
+(function(self) {
+
+var irrelevant = (function (exports) {
+
+  var support = {
+    searchParams: 'URLSearchParams' in self,
+    iterable: 'Symbol' in self && 'iterator' in Symbol,
+    blob:
+      'FileReader' in self &&
+      'Blob' in self &&
+      (function() {
+        try {
+          new Blob();
+          return true
+        } catch (e) {
+          return false
+        }
+      })(),
+    formData: 'FormData' in self,
+    arrayBuffer: 'ArrayBuffer' in self
+  };
+
+  function isDataView(obj) {
+    return obj && DataView.prototype.isPrototypeOf(obj)
+  }
+
+  if (support.arrayBuffer) {
+    var viewClasses = [
+      '[object Int8Array]',
+      '[object Uint8Array]',
+      '[object Uint8ClampedArray]',
+      '[object Int16Array]',
+      '[object Uint16Array]',
+      '[object Int32Array]',
+      '[object Uint32Array]',
+      '[object Float32Array]',
+      '[object Float64Array]'
+    ];
+
+    var isArrayBufferView =
+      ArrayBuffer.isView ||
+      function(obj) {
+        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
+      };
+  }
+
+  function normalizeName(name) {
+    if (typeof name !== 'string') {
+      name = String(name);
+    }
+    if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name)) {
+      throw new TypeError('Invalid character in header field name')
+    }
+    return name.toLowerCase()
+  }
+
+  function normalizeValue(value) {
+    if (typeof value !== 'string') {
+      value = String(value);
+    }
+    return value
+  }
+
+  // Build a destructive iterator for the value list
+  function iteratorFor(items) {
+    var iterator = {
+      next: function() {
+        var value = items.shift();
+        return {done: value === undefined, value: value}
+      }
+    };
+
+    if (support.iterable) {
+      iterator[Symbol.iterator] = function() {
+        return iterator
+      };
+    }
+
+    return iterator
+  }
+
+  function Headers(headers) {
+    this.map = {};
+
+    if (headers instanceof Headers) {
+      headers.forEach(function(value, name) {
+        this.append(name, value);
+      }, this);
+    } else if (Array.isArray(headers)) {
+      headers.forEach(function(header) {
+        this.append(header[0], header[1]);
+      }, this);
+    } else if (headers) {
+      Object.getOwnPropertyNames(headers).forEach(function(name) {
+        this.append(name, headers[name]);
+      }, this);
+    }
+  }
+
+  Headers.prototype.append = function(name, value) {
+    name = normalizeName(name);
+    value = normalizeValue(value);
+    var oldValue = this.map[name];
+    this.map[name] = oldValue ? oldValue + ', ' + value : value;
+  };
+
+  Headers.prototype['delete'] = function(name) {
+    delete this.map[normalizeName(name)];
+  };
+
+  Headers.prototype.get = function(name) {
+    name = normalizeName(name);
+    return this.has(name) ? this.map[name] : null
+  };
+
+  Headers.prototype.has = function(name) {
+    return this.map.hasOwnProperty(normalizeName(name))
+  };
+
+  Headers.prototype.set = function(name, value) {
+    this.map[normalizeName(name)] = normalizeValue(value);
+  };
+
+  Headers.prototype.forEach = function(callback, thisArg) {
+    for (var name in this.map) {
+      if (this.map.hasOwnProperty(name)) {
+        callback.call(thisArg, this.map[name], name, this);
+      }
+    }
+  };
+
+  Headers.prototype.keys = function() {
+    var items = [];
+    this.forEach(function(value, name) {
+      items.push(name);
+    });
+    return iteratorFor(items)
+  };
+
+  Headers.prototype.values = function() {
+    var items = [];
+    this.forEach(function(value) {
+      items.push(value);
+    });
+    return iteratorFor(items)
+  };
+
+  Headers.prototype.entries = function() {
+    var items = [];
+    this.forEach(function(value, name) {
+      items.push([name, value]);
+    });
+    return iteratorFor(items)
+  };
+
+  if (support.iterable) {
+    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+  }
+
+  function consumed(body) {
+    if (body.bodyUsed) {
+      return Promise.reject(new TypeError('Already read'))
+    }
+    body.bodyUsed = true;
+  }
+
+  function fileReaderReady(reader) {
+    return new Promise(function(resolve, reject) {
+      reader.onload = function() {
+        resolve(reader.result);
+      };
+      reader.onerror = function() {
+        reject(reader.error);
+      };
+    })
+  }
+
+  function readBlobAsArrayBuffer(blob) {
+    var reader = new FileReader();
+    var promise = fileReaderReady(reader);
+    reader.readAsArrayBuffer(blob);
+    return promise
+  }
+
+  function readBlobAsText(blob) {
+    var reader = new FileReader();
+    var promise = fileReaderReady(reader);
+    reader.readAsText(blob);
+    return promise
+  }
+
+  function readArrayBufferAsText(buf) {
+    var view = new Uint8Array(buf);
+    var chars = new Array(view.length);
+
+    for (var i = 0; i < view.length; i++) {
+      chars[i] = String.fromCharCode(view[i]);
+    }
+    return chars.join('')
+  }
+
+  function bufferClone(buf) {
+    if (buf.slice) {
+      return buf.slice(0)
+    } else {
+      var view = new Uint8Array(buf.byteLength);
+      view.set(new Uint8Array(buf));
+      return view.buffer
+    }
+  }
+
+  function Body() {
+    this.bodyUsed = false;
+
+    this._initBody = function(body) {
+      this._bodyInit = body;
+      if (!body) {
+        this._bodyText = '';
+      } else if (typeof body === 'string') {
+        this._bodyText = body;
+      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+        this._bodyBlob = body;
+      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+        this._bodyFormData = body;
+      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+        this._bodyText = body.toString();
+      } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+        this._bodyArrayBuffer = bufferClone(body.buffer);
+        // IE 10-11 can't handle a DataView body.
+        this._bodyInit = new Blob([this._bodyArrayBuffer]);
+      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+        this._bodyArrayBuffer = bufferClone(body);
+      } else {
+        this._bodyText = body = Object.prototype.toString.call(body);
+      }
+
+      if (!this.headers.get('content-type')) {
+        if (typeof body === 'string') {
+          this.headers.set('content-type', 'text/plain;charset=UTF-8');
+        } else if (this._bodyBlob && this._bodyBlob.type) {
+          this.headers.set('content-type', this._bodyBlob.type);
+        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+        }
+      }
+    };
+
+    if (support.blob) {
+      this.blob = function() {
+        var rejected = consumed(this);
+        if (rejected) {
+          return rejected
+        }
+
+        if (this._bodyBlob) {
+          return Promise.resolve(this._bodyBlob)
+        } else if (this._bodyArrayBuffer) {
+          return Promise.resolve(new Blob([this._bodyArrayBuffer]))
+        } else if (this._bodyFormData) {
+          throw new Error('could not read FormData body as blob')
+        } else {
+          return Promise.resolve(new Blob([this._bodyText]))
+        }
+      };
+
+      this.arrayBuffer = function() {
+        if (this._bodyArrayBuffer) {
+          return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
+        } else {
+          return this.blob().then(readBlobAsArrayBuffer)
+        }
+      };
+    }
+
+    this.text = function() {
+      var rejected = consumed(this);
+      if (rejected) {
+        return rejected
+      }
+
+      if (this._bodyBlob) {
+        return readBlobAsText(this._bodyBlob)
+      } else if (this._bodyArrayBuffer) {
+        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
+      } else if (this._bodyFormData) {
+        throw new Error('could not read FormData body as text')
+      } else {
+        return Promise.resolve(this._bodyText)
+      }
+    };
+
+    if (support.formData) {
+      this.formData = function() {
+        return this.text().then(decode)
+      };
+    }
+
+    this.json = function() {
+      return this.text().then(JSON.parse)
+    };
+
+    return this
+  }
+
+  // HTTP methods whose capitalization should be normalized
+  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];
+
+  function normalizeMethod(method) {
+    var upcased = method.toUpperCase();
+    return methods.indexOf(upcased) > -1 ? upcased : method
+  }
+
+  function Request(input, options) {
+    options = options || {};
+    var body = options.body;
+
+    if (input instanceof Request) {
+      if (input.bodyUsed) {
+        throw new TypeError('Already read')
+      }
+      this.url = input.url;
+      this.credentials = input.credentials;
+      if (!options.headers) {
+        this.headers = new Headers(input.headers);
+      }
+      this.method = input.method;
+      this.mode = input.mode;
+      this.signal = input.signal;
+      if (!body && input._bodyInit != null) {
+        body = input._bodyInit;
+        input.bodyUsed = true;
+      }
+    } else {
+      this.url = String(input);
+    }
+
+    this.credentials = options.credentials || this.credentials || 'same-origin';
+    if (options.headers || !this.headers) {
+      this.headers = new Headers(options.headers);
+    }
+    this.method = normalizeMethod(options.method || this.method || 'GET');
+    this.mode = options.mode || this.mode || null;
+    this.signal = options.signal || this.signal;
+    this.referrer = null;
+
+    if ((this.method === 'GET' || this.method === 'HEAD') && body) {
+      throw new TypeError('Body not allowed for GET or HEAD requests')
+    }
+    this._initBody(body);
+  }
+
+  Request.prototype.clone = function() {
+    return new Request(this, {body: this._bodyInit})
+  };
+
+  function decode(body) {
+    var form = new FormData();
+    body
+      .trim()
+      .split('&')
+      .forEach(function(bytes) {
+        if (bytes) {
+          var split = bytes.split('=');
+          var name = split.shift().replace(/\+/g, ' ');
+          var value = split.join('=').replace(/\+/g, ' ');
+          form.append(decodeURIComponent(name), decodeURIComponent(value));
+        }
+      });
+    return form
+  }
+
+  function parseHeaders(rawHeaders) {
+    var headers = new Headers();
+    // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
+    // https://tools.ietf.org/html/rfc7230#section-3.2
+    var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
+    preProcessedHeaders.split(/\r?\n/).forEach(function(line) {
+      var parts = line.split(':');
+      var key = parts.shift().trim();
+      if (key) {
+        var value = parts.join(':').trim();
+        headers.append(key, value);
+      }
+    });
+    return headers
+  }
+
+  Body.call(Request.prototype);
+
+  function Response(bodyInit, options) {
+    if (!options) {
+      options = {};
+    }
+
+    this.type = 'default';
+    this.status = options.status === undefined ? 200 : options.status;
+    this.ok = this.status >= 200 && this.status < 300;
+    this.statusText = 'statusText' in options ? options.statusText : 'OK';
+    this.headers = new Headers(options.headers);
+    this.url = options.url || '';
+    this._initBody(bodyInit);
+  }
+
+  Body.call(Response.prototype);
+
+  Response.prototype.clone = function() {
+    return new Response(this._bodyInit, {
+      status: this.status,
+      statusText: this.statusText,
+      headers: new Headers(this.headers),
+      url: this.url
+    })
+  };
+
+  Response.error = function() {
+    var response = new Response(null, {status: 0, statusText: ''});
+    response.type = 'error';
+    return response
+  };
+
+  var redirectStatuses = [301, 302, 303, 307, 308];
+
+  Response.redirect = function(url, status) {
+    if (redirectStatuses.indexOf(status) === -1) {
+      throw new RangeError('Invalid status code')
+    }
+
+    return new Response(null, {status: status, headers: {location: url}})
+  };
+
+  exports.DOMException = self.DOMException;
+  try {
+    new exports.DOMException();
+  } catch (err) {
+    exports.DOMException = function(message, name) {
+      this.message = message;
+      this.name = name;
+      var error = Error(message);
+      this.stack = error.stack;
+    };
+    exports.DOMException.prototype = Object.create(Error.prototype);
+    exports.DOMException.prototype.constructor = exports.DOMException;
+  }
+
+  function fetch(input, init) {
+    return new Promise(function(resolve, reject) {
+      var request = new Request(input, init);
+
+      if (request.signal && request.signal.aborted) {
+        return reject(new exports.DOMException('Aborted', 'AbortError'))
+      }
+
+      var xhr = new XMLHttpRequest();
+
+      function abortXhr() {
+        xhr.abort();
+      }
+
+      xhr.onload = function() {
+        var options = {
+          status: xhr.status,
+          statusText: xhr.statusText,
+          headers: parseHeaders(xhr.getAllResponseHeaders() || '')
+        };
+        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
+        var body = 'response' in xhr ? xhr.response : xhr.responseText;
+        resolve(new Response(body, options));
+      };
+
+      xhr.onerror = function() {
+        reject(new TypeError('Network request failed'));
+      };
+
+      xhr.ontimeout = function() {
+        reject(new TypeError('Network request failed'));
+      };
+
+      xhr.onabort = function() {
+        reject(new exports.DOMException('Aborted', 'AbortError'));
+      };
+
+      xhr.open(request.method, request.url, true);
+
+      if (request.credentials === 'include') {
+        xhr.withCredentials = true;
+      } else if (request.credentials === 'omit') {
+        xhr.withCredentials = false;
+      }
+
+      if ('responseType' in xhr && support.blob) {
+        xhr.responseType = 'blob';
+      }
+
+      request.headers.forEach(function(value, name) {
+        xhr.setRequestHeader(name, value);
+      });
+
+      if (request.signal) {
+        request.signal.addEventListener('abort', abortXhr);
+
+        xhr.onreadystatechange = function() {
+          // DONE (success or failure)
+          if (xhr.readyState === 4) {
+            request.signal.removeEventListener('abort', abortXhr);
+          }
+        };
+      }
+
+      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
+    })
+  }
+
+  fetch.polyfill = true;
+
+  if (!self.fetch) {
+    self.fetch = fetch;
+    self.Headers = Headers;
+    self.Request = Request;
+    self.Response = Response;
+  }
+
+  exports.Headers = Headers;
+  exports.Request = Request;
+  exports.Response = Response;
+  exports.fetch = fetch;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+  return exports;
+
+})({});
+})(__self__);
+__self__.fetch.ponyfill = true;
+// Remove "polyfill" property added by whatwg-fetch
+delete __self__.fetch.polyfill;
+// Choose between native implementation (global) or custom implementation (__self__)
+// var ctx = global.fetch ? global : __self__;
+var ctx = __self__; // this line disable service worker support temporarily
+exports = ctx.fetch // To enable: import fetch from 'cross-fetch'
+exports["default"] = ctx.fetch // For TypeScript consumers without esModuleInterop.
+exports.fetch = ctx.fetch // To enable: import {fetch} from 'cross-fetch'
+exports.Headers = ctx.Headers
+exports.Request = ctx.Request
+exports.Response = ctx.Response
+module.exports = exports
+
+
 /***/ }),
 
 /***/ 2091:
@@ -26754,6 +27315,8 @@ const AiChatbotChatRequestSchema = {
 };
 
 ;// CONCATENATED MODULE: ../common/src/ai-chatbot.types.ts
+/** The supported AI model names. */
+const AI_MODEL_NAMES = (/* unused pure expression or super */ null && (['gpt-3.5-turbo', 'gpt-4', 'claude-2', 'gpt-4-1106-preview']));
 /** @internal */
 const AiModelData = {
     'gpt-4': {
@@ -27073,60 +27636,6 @@ const OpenApiDiscoveryOptionsSchema = {
         openApiSpecUrl: { type: 'string', nullable: true },
     },
 };
-/** Generated using openai */
-const ApiEndpointsSchema = {
-    type: 'object',
-    patternProperties: {
-        '^\\S+$': {
-            type: 'object',
-            required: ['relativePath', 'method'],
-            properties: {
-                relativePath: {
-                    type: 'string',
-                },
-                method: {
-                    type: 'string',
-                    enum: ['post', 'get', 'delete', 'patch', 'put'],
-                },
-                requestSchema: {
-                    type: 'object',
-                    patternProperties: {
-                        '^\\S+$': {
-                            type: 'object',
-                            properties: {
-                                location: {
-                                    type: 'string',
-                                    enum: ['query', 'body', 'header', 'path'],
-                                },
-                                fieldNameInRequest: {
-                                    type: 'string',
-                                },
-                            },
-                        },
-                    },
-                },
-                responseSchema: {
-                    type: 'object',
-                    patternProperties: {
-                        '^\\S+$': {
-                            type: 'object',
-                            required: ['location'],
-                            properties: {
-                                location: {
-                                    type: 'string',
-                                    enum: ['body', 'header'],
-                                },
-                                path: {
-                                    type: 'string',
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        },
-    },
-};
 const SnowflakeConnectionOptionsSchema = {
     type: 'object',
     required: [],
@@ -28138,80 +28647,6 @@ function isSimpleCondition(condition) {
 function encodeCondition(condition) {
     return serialization_normalizeJsonAsString(condition);
 }
-const sampleQueryMapping = {
-    unconditional: ['cid_123'],
-    conditional: {
-        [encodeCondition({
-            fields: [
-                {
-                    fieldName: 'name',
-                    operator: '>',
-                    value: 'Yossi',
-                },
-                {
-                    fieldName: 'age',
-                    operator: '<',
-                    value: 10,
-                },
-            ],
-        })]: ['cid_sort_order'],
-        [encodeCondition({
-            fieldName: 'age',
-            operator: '==',
-            value: 10,
-        })]: ['cid_321'],
-        [encodeCondition({
-            fieldName: 'age',
-            operator: '==',
-            value: 11,
-        })]: ['cid_321'],
-        [encodeCondition({
-            fieldName: 'age',
-            operator: '==',
-            value: 12,
-        })]: ['cid_321'],
-        [encodeCondition({
-            fieldName: 'age',
-            operator: '>',
-            value: 20,
-        })]: ['cid_456', 'cid_789'],
-        [encodeCondition({
-            fieldName: 'age',
-            operator: '<',
-            value: 20,
-        })]: ['cid_789'],
-        [encodeCondition({
-            fieldName: 'name',
-            operator: '!=',
-            value: 'Yossi',
-        })]: ['cid_not_in'],
-        [encodeCondition({
-            fieldName: 'name',
-            operator: '!=',
-            value: 'Nir',
-        })]: ['cid_not_in'],
-    },
-    queriesMetadata: {
-        cid_123: {
-            condCount: 0,
-        },
-        cid_321: {
-            condCount: 1,
-        },
-        cid_456: {
-            condCount: 1,
-        },
-        cid_789: {
-            condCount: 2,
-        },
-        cid_sort_order: {
-            condCount: 1,
-        },
-        cid_not_in: {
-            condCount: 2,
-        },
-    },
-};
 /** @internal */
 class QueryMappingManager {
 }
@@ -28904,7 +29339,7 @@ class Pagination {
         // It is possible that we get here and unsubscribe() was called. In that case we might not get any new state,
         // so to avoid stalling we return an empty page in that situation. (We can't return the last page we saw
         // because that has already been deleted, and also because it's possible that we've never seen any data.)
-        this.isDestroyed.pipe((0,external_rxjs_namespaceObject.filter)(Boolean), (0,external_rxjs_namespaceObject.map)(_ => ({
+        this.isDestroyed.pipe((0,external_rxjs_namespaceObject.filter)(Boolean), (0,external_rxjs_namespaceObject.map)(() => ({
             data: [],
             extractedData: [],
             numBefore: 0,
@@ -28929,7 +29364,7 @@ class Pagination {
         this.snapshotSubject.complete();
     }
     prevInternal(internalState) {
-        const { numBefore, numAfter, data, extractedData } = internalState;
+        const { numBefore, numAfter, extractedData } = internalState;
         this.firstElement = null;
         this.lastElement = extractedData[numBefore - 1];
         this.internalStateObserver.next(null);
@@ -29186,7 +29621,7 @@ function hasDocumentDiff(beforeDoc, afterDoc) {
         const docIdObj = parseSquidDocId(docIdDiff.rhs + '');
         ignoredKeys.push(...Object.keys(docIdObj));
     }
-    const diff = diffs === null || diffs === void 0 ? void 0 : diffs.find((diff, index) => {
+    const diff = diffs === null || diffs === void 0 ? void 0 : diffs.find((diff) => {
         var _a;
         // Ignore changes to the docId, ts and primaryKeys.
         if (ignoredKeys.includes((_a = diff.path) === null || _a === void 0 ? void 0 : _a[0]))
@@ -29689,18 +30124,6 @@ function validateFieldName(fieldName) {
             fieldName);
     }
 }
-// TODO: remove if not used
-function validateQueryCondition(condition) {
-    if (!condition) {
-        throw new Error('Condition cannot be empty');
-    }
-    if (!condition.operator ||
-        !['==', '!=', '>', '>=', '<', '<=', 'like', 'not like', 'like_cs', 'not like_cs'].includes(condition.operator)) {
-        throw new Error('Unsupported operator: ' + condition.operator);
-    }
-    validateFieldName(condition.fieldName);
-    // TODO - figure out how to validate the value
-}
 function validateFieldSort(fieldSort) {
     if (!(fieldSort instanceof Object)) {
         throw new Error('Field sort has to be an object');
@@ -29929,13 +30352,13 @@ schema_types_ajv.addKeyword({
 });
 schema_types_ajv.addKeyword({
     keyword: 'applyDefaultValueOn',
-    validate: (applyDefaultValueOn, value) => {
+    validate: (applyDefaultValueOn) => {
         return applyDefaultValueOn ? ['always', 'empty', 'updateOrEmpty'].includes(applyDefaultValueOn) : true;
     },
 });
 schema_types_ajv.addKeyword({
     keyword: 'dataType',
-    validate: (dataType, value) => {
+    validate: () => {
         return true;
     },
 });
@@ -30033,7 +30456,7 @@ function findMatchingPropertiesForKey(schema, key) {
             .filter(([pattern]) => {
             return new RegExp(pattern).test(key);
         })
-            .map(([_, matchedProperty]) => matchedProperty));
+            .map(([, matchedProperty]) => matchedProperty));
     }
     return matchingProperties;
 }
@@ -30135,6 +30558,18 @@ const SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR;
 const SECONDS_PER_WEEK = 7 * SECONDS_PER_DAY;
 /** @internal */
 const SECONDS_PER_MONTH = 30 * SECONDS_PER_DAY;
+/** @internal */
+const MILLIS_PER_SECOND = 1000;
+/** @internal */
+const MILLIS_PER_MINUTE = SECONDS_PER_MINUTE * MILLIS_PER_SECOND;
+/** @internal */
+const MILLIS_PER_HOUR = SECONDS_PER_HOUR * MILLIS_PER_SECOND;
+/** @internal */
+const MILLIS_PER_DAY = SECONDS_PER_DAY * MILLIS_PER_SECOND;
+/** @internal */
+const MILLIS_PER_WEEK = SECONDS_PER_WEEK * MILLIS_PER_SECOND;
+/** @internal */
+const MILLIS_PER_MONTH = SECONDS_PER_MONTH * MILLIS_PER_SECOND;
 
 ;// CONCATENATED MODULE: ../common/src/utils/array.ts
 
@@ -30287,7 +30722,7 @@ class LockManager {
         }
         const relevantLocks = Object.entries(this.locks)
             .filter(([mutex]) => mutexes.includes(mutex))
-            .map(([ignored, isLockedSubject]) => isLockedSubject);
+            .map(([, isLockedSubject]) => isLockedSubject);
         await (0,external_rxjs_namespaceObject.lastValueFrom)((0,external_rxjs_namespaceObject.combineLatest)(relevantLocks).pipe((0,external_rxjs_namespaceObject.filter)((isLockedArray) => !isLockedArray.includes(true)), (0,external_rxjs_namespaceObject.take)(1)));
         await this.lock(...mutexes);
     }
@@ -30399,7 +30834,7 @@ function createWebSocketWrapper(url, opts = {}) {
             };
             ws.onclose = function (e) {
                 $.connected = false;
-                if (e.code !== 4999) {
+                if (e.code !== 4999 && e.code !== 4001) {
                     DebugLogger.debug('WebSocket closed. Reconnecting. Close code: ', e.code);
                     (opts.onclose || noop)(e);
                     $.reconnect(e);
@@ -32999,12 +33434,13 @@ class AiChatbotClientFactory {
         this.socketManager = socketManager;
         this.chatbotsMap = new Map();
     }
-    getChatbot(integrationId) {
-        let client = this.chatbotsMap.get(integrationId);
+    /** @internal */
+    getChatbot(aiIntegrationId) {
+        let client = this.chatbotsMap.get(aiIntegrationId);
         if (client)
             return client;
-        client = new AiChatbotClient(this.rpcManager, this.socketManager, integrationId);
-        this.chatbotsMap.set(integrationId, client);
+        client = new AiChatbotClient(this.rpcManager, this.socketManager, aiIntegrationId);
+        this.chatbotsMap.set(aiIntegrationId, client);
         return client;
     }
 }
@@ -33027,11 +33463,12 @@ class ApiManager {
             serverUrlOverride: this.apiServerUrlOverrideMapping[integrationId],
         };
         return (0,external_rxjs_namespaceObject.race)((0,external_rxjs_namespaceObject.from)(this.rpcManager.post('api/call', callApiRequest)).pipe(map_map(response => {
+            const parsedPayload = response.payload ? deserializeObj(response.payload) : undefined;
             if (response.success) {
-                return deserializeObj(response.payload);
+                return parsedPayload;
             }
             else {
-                throw new Error(`Got error while calling API (HTTP Status ${response.httpStatus})`);
+                throw new Error(`Got error while calling API (HTTP Status ${response.httpStatus}). Message: ${parsedPayload === null || parsedPayload === void 0 ? void 0 : parsedPayload['message']}`);
             }
         })), this.clientIdService.observeClientTooOld().pipe(map_map(() => {
             throw new Error('CLIENT_NOT_CONNECTED');
@@ -33039,52 +33476,12 @@ class ApiManager {
     }
 }
 
-;// CONCATENATED MODULE: ../node_modules/rxjs/dist/esm5/internal/util/isPromise.js
-
-function isPromise(value) {
-    return isFunction(value === null || value === void 0 ? void 0 : value.then);
-}
-//# sourceMappingURL=isPromise.js.map
 ;// CONCATENATED MODULE: ./src/auth.manager.ts
-
-
-
 class AuthManager {
     constructor(apiKey, authProvider) {
         this.apiKey = apiKey;
         this.authProvider = authProvider;
     }
-    /**
-     * Sets a new ID token or an ID token provider.
-     * @deprecated: Pass the provider via constructor options parameters or `setAuthTokenProvider()`.
-     */
-    setAuthIdToken(tokenArg, integrationId) {
-        // Using this warning in Datadog, we can track how many active clients use the deprecated API.
-        console.warn('Using a deprecated setAuthIdToken method.');
-        // Convert the input into AuthTokenProvider.
-        if (typeof tokenArg === 'string' || tokenArg === undefined) {
-            this.setAuthProviderForDeprecatedCode(async () => tokenArg, integrationId);
-            return;
-        }
-        if (typeof tokenArg === 'function') {
-            this.setAuthProviderForDeprecatedCode(tokenArg, integrationId);
-            return;
-        }
-        (0,dist.assertTruthy)(typeof tokenArg === 'object');
-        if ((0,external_rxjs_namespaceObject.isObservable)(tokenArg)) {
-            this.setAuthProviderForDeprecatedCode(() => (0,external_rxjs_namespaceObject.firstValueFrom)(tokenArg), integrationId);
-            return;
-        }
-        if (isPromise(tokenArg)) {
-            this.setAuthProviderForDeprecatedCode(() => tokenArg, integrationId);
-            return;
-        }
-        // tokenArg is AuthTokenProvider.
-        this.setAuthProviderForDeprecatedCode(tokenArg.getToken, tokenArg.integrationId || integrationId);
-    }
-    setAuthProviderForDeprecatedCode(getToken, integrationId) {
-        this.authProvider = { getToken, integrationId };
-    }
     /**
      * Sets a new auth-token provider to Squid.
      * All future squid backend requests will use this token provider.
@@ -33184,7 +33581,7 @@ class ClientIdService {
     observeClientReadyToBeRegenerated() {
         return this.clientTooOldSubject.pipe(
         // skip the initial connection
-        (0,external_rxjs_namespaceObject.skip)(1), (0,external_rxjs_namespaceObject.filter)(v => !v), (0,external_rxjs_namespaceObject.map)(v => undefined));
+        (0,external_rxjs_namespaceObject.skip)(1), (0,external_rxjs_namespaceObject.filter)(v => !v), (0,external_rxjs_namespaceObject.map)(() => undefined));
     }
     getClientId() {
         return this.clientIdSubject.value;
@@ -33845,7 +34242,7 @@ class DataManager {
     }
     groupOutgoingMutationsByIntegrationId() {
         const outgoingMutationsByIntegrationId = {};
-        for (const [_, outgoingMutations] of [...this.pendingOutgoingMutations.entries()]) {
+        for (const [, outgoingMutations] of [...this.pendingOutgoingMutations.entries()]) {
             const latestOutgoingMutation = outgoingMutations[outgoingMutations.length - 1];
             if (latestOutgoingMutation && !latestOutgoingMutation.sentToServer) {
                 const integrationId = latestOutgoingMutation.mutation.squidDocIdObj.integrationId;
@@ -34132,7 +34529,7 @@ class DocumentReferenceFactory {
      * @internal
      */
     migrateDocIds(idResolutionMap) {
-        for (const [_, reference] of this.documents) {
+        for (const [, reference] of this.documents) {
             reference.migrateDocIds(idResolutionMap);
         }
         Object.entries(idResolutionMap).forEach(([squidDocId, newSquidDocId]) => {
@@ -47446,9 +47843,9 @@ var extras = {
 gql["default"] = gql;
 /* harmony default export */ const lib = ((/* unused pure expression or super */ null && (gql)));
 //# sourceMappingURL=index.js.map
-;// CONCATENATED MODULE: external "cross-fetch"
-const external_cross_fetch_namespaceObject = require("cross-fetch");
-var external_cross_fetch_default = /*#__PURE__*/__webpack_require__.n(external_cross_fetch_namespaceObject);
+// EXTERNAL MODULE: ../node_modules/cross-fetch/dist/browser-ponyfill.js
+var browser_ponyfill = __webpack_require__(9372);
+var browser_ponyfill_default = /*#__PURE__*/__webpack_require__.n(browser_ponyfill);
 ;// CONCATENATED MODULE: ./src/graphql-client.ts
 
 
@@ -47464,7 +47861,7 @@ class GraphQLClient {
             link: new HttpLink({
                 uri: url,
                 headers: this.rpcManager.getStaticHeaders(),
-                fetch: (external_cross_fetch_default()),
+                fetch: (browser_ponyfill_default()),
             }),
             cache: new InMemoryCache(),
         });
@@ -48377,7 +48774,7 @@ class QuerySubscriptionManager {
                 return this.allOngoingQueriesGotInitialResult(rootOngoingQuery);
             }), (0,external_rxjs_namespaceObject.startWith)(undefined), (0,external_rxjs_namespaceObject.pairwise)(), filter(([before, after]) => {
                 return !lodash.isEqual(before, after);
-            }), map_map(([_ignored, after]) => after), 
+            }), map_map(([, after]) => after), 
             // This handles 'subscribe = false'
             subscribe ? (0,external_rxjs_namespaceObject.tap)() : (0,external_rxjs_namespaceObject.take)(1), (0,external_rxjs_namespaceObject.finalize)(() => {
                 var _a;
@@ -49021,6 +49418,9 @@ class RateLimiter {
     }
 }
 
+;// CONCATENATED MODULE: external "axios"
+const external_axios_namespaceObject = require("axios");
+var external_axios_default = /*#__PURE__*/__webpack_require__.n(external_axios_namespaceObject);
 ;// CONCATENATED MODULE: ./src/rpc.manager.ts
 
 
@@ -49083,7 +49483,7 @@ class RpcManager {
     getStaticHeaders() {
         return this.staticHeaders;
     }
-    async post(path, message, files = []) {
+    async post(path, message, files = [], filesFieldName = 'files') {
         this.onGoingRpcCounter.next(this.onGoingRpcCounter.value + 1);
         try {
             await this.getRateLimiterBucket(path).consume();
@@ -49095,57 +49495,64 @@ class RpcManager {
             headers = Object.assign(Object.assign({}, headers), authHeaders);
             DebugLogger.debug(`sending request: path: ${path} message: ${JSON.stringify(message)}`);
             const url = getApplicationUrl(this.region, this.appId, path);
-            let response;
-            if (files.length) {
-                const formData = new FormData();
-                files.forEach(file => {
-                    formData.append('files', file);
-                });
-                formData.append('body', serialization_serializeObj(message));
-                // Make the fetch call
-                response = await external_cross_fetch_default()(url, {
-                    method: 'POST',
-                    body: formData,
-                    headers,
-                });
+            let axiosResponse;
+            try {
+                if (files.length) {
+                    const formData = new FormData();
+                    files.forEach(file => {
+                        const blob = file instanceof Blob ? file : file.blob;
+                        const filename = file instanceof Blob ? undefined : file.name;
+                        formData.append(filesFieldName, blob, filename);
+                    });
+                    formData.append('body', serialization_serializeObj(message));
+                    // Make the axios call
+                    axiosResponse = await external_axios_default().post(url, formData, {
+                        headers: Object.assign({}, headers),
+                        responseType: 'text',
+                    });
+                }
+                else {
+                    axiosResponse = await external_axios_default().post(url, serialization_serializeObj(message), {
+                        headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }),
+                        responseType: 'text',
+                    });
+                }
             }
-            else {
-                headers['Content-Type'] = 'application/json';
-                response = await external_cross_fetch_default()(url, {
-                    method: 'POST',
-                    body: serialization_serializeObj(message),
-                    headers,
-                });
+            catch (e) {
+                if (e instanceof external_axios_namespaceObject.AxiosError) {
+                    const response = e.response;
+                    if (!response)
+                        throw e;
+                    let message;
+                    try {
+                        const errorResponse = this.tryDeserializing(response.data);
+                        message = typeof errorResponse === 'string' ? errorResponse : errorResponse['message'];
+                    }
+                    catch (_a) { }
+                    if (!message)
+                        message = response.statusText;
+                    throw new RpcError(response.status, response.statusText, response.headers, url, message);
+                }
+                else {
+                    throw e;
+                }
             }
-            const parsedResponse = await this.parseResponse(response);
+            const parsedResponse = this.tryDeserializing(axiosResponse.data);
             DebugLogger.debug(`received response: ${JSON.stringify(parsedResponse)}`);
             return parsedResponse;
         }
-        catch (e) {
-            DebugLogger.debug(`received error: ${JSON.stringify(e)}`);
-            throw e;
-        }
         finally {
             this.onGoingRpcCounter.next(this.onGoingRpcCounter.value - 1);
         }
     }
-    async parseResponse(response) {
-        let text;
-        let json;
+    tryDeserializing(text) {
+        if (!text)
+            return undefined;
         try {
-            text = await response.text();
-            try {
-                json = deserializeObj(text);
-            }
-            catch (_a) { }
-        }
-        catch (_b) {
-            text = 'Cannot read body';
-        }
-        if (!response.ok) {
-            throw new RpcError(response.status, response.statusText, response.headers, response.url, json === null || json === void 0 ? void 0 : json['message']);
+            return deserializeObj(text);
         }
-        return (json || text);
+        catch (_a) { }
+        return text;
     }
     getRateLimiterBucket(path) {
         if (path.startsWith('ai/chatbot')) {
@@ -49350,14 +49757,14 @@ class SocketManager {
         this.socket = createWebSocketWrapper(socketUri, {
             timeout: 5000,
             onmessage: (e) => this.onMessage(e.data),
-            onopen: (_e) => {
+            onopen: () => {
                 DebugLogger.debug(`Connection to socket established. Endpoint: ${endpoint}`);
             },
-            onreconnect: (_e) => {
+            onreconnect: () => {
                 DebugLogger.debug(`WebSocket reconnect event triggered`);
                 this.connectionReady.next(false);
             },
-            onclose: (_e) => {
+            onclose: () => {
                 DebugLogger.debug(`WebSocket onclose event triggered`);
                 this.connectionReady.next(false);
             },
@@ -49521,10 +49928,25 @@ class NativeQueryManager {
 }
 
 ;// CONCATENATED MODULE: ./src/ai-assistant-client.ts
+/**
+ * Client class for interacting with an AI Assistant server.
+ * Provides functionalities like creating and deleting assistants and threads,
+ * querying assistants, and managing files associated with assistants and threads.
+ */
 class AiAssistantClient {
     constructor(rpcManager) {
         this.rpcManager = rpcManager;
     }
+    /**
+     * Creates a new AI assistant with specified characteristics.
+     * @param name - The name of the assistant.
+     * @param instructions - Instructions for the assistant.
+     * @param functions - Array of function names annotated with "@aiFunction" in your Squid backend that will be
+     *   available tol the assistant.
+     * @param toolTypes - Optional array of tool types. If you want to use files for retrieval, you must add them using
+     *   the addFileToAssistant method.
+     * @returns A promise that resolves to the created assistant's ID.
+     */
     async createAssistant(name, instructions, functions, toolTypes) {
         const request = {
             name,
@@ -49535,12 +49957,23 @@ class AiAssistantClient {
         const response = await this.rpcManager.post('ai/assistant/createAssistant', request);
         return response.assistantId;
     }
+    /**
+     * Deletes an AI assistant.
+     * @param assistantId - The ID of the assistant to be deleted.
+     * @returns A promise that resolves when the assistant is deleted.
+     */
     async deleteAssistant(assistantId) {
         const request = {
             assistantId,
         };
         await this.rpcManager.post('ai/assistant/deleteAssistant', request);
     }
+    /**
+     * Creates a new thread for an AI assistant. A thread is a long-lived conversation with the assistant that you can
+     * always send questions to.
+     * @param assistantId - The ID of the assistant for which the thread is created.
+     * @returns A promise that resolves to the created thread's ID.
+     */
     async createThread(assistantId) {
         const request = {
             assistantId,
@@ -49548,35 +49981,98 @@ class AiAssistantClient {
         const response = await this.rpcManager.post('ai/assistant/createThread', request);
         return response.threadId;
     }
+    /**
+     * Deletes a thread of an AI assistant.
+     * @param threadId - The ID of the thread to be deleted.
+     * @returns A promise that resolves when the thread is deleted.
+     */
     async deleteThread(threadId) {
         const request = {
             threadId,
         };
         await this.rpcManager.post('ai/assistant/deleteThread', request);
     }
-    async queryAssistant(assistantId, threadId, prompt, fileContent) {
+    /**
+     * Queries an AI assistant within a specific thread.
+     * @param assistantId - The ID of the assistant.
+     * @param threadId - The ID of the thread.
+     * @param prompt - The query prompt.
+     * @param fileIds - Optional array of file IDs to include in the query. These file IDs need to be added using the
+     *   addFileToThread method.
+     * @returns A promise that resolves to the assistant's response.
+     */
+    async queryAssistant(assistantId, threadId, prompt, fileIds) {
         const request = {
             assistantId,
             threadId,
             prompt,
-            fileContent,
+            fileIds,
         };
         const response = await this.rpcManager.post('ai/assistant/queryAssistant', request);
         return response.answer;
     }
+    /**
+     * Adds a file to an AI assistant that can be available for retrieval or code analyzer.
+     * @param assistantId - The ID of the assistant.
+     * @param file - The file or blob and filename to be added.
+     * @returns A promise that resolves to the ID of the added file.
+     */
+    async addFileToAssistant(assistantId, file) {
+        const request = { assistantId };
+        const response = await this.rpcManager.post(`ai/assistant/addFileToAssistant`, request, [file], 'file');
+        return response.fileId;
+    }
+    /**
+     * Removes a file from an AI assistant.
+     * @param assistantId - The ID of the assistant.
+     * @param fileId - The ID of the file to be removed.
+     * @returns A promise that resolves when the file is removed.
+     */
+    async removeFileFromAssistant(assistantId, fileId) {
+        const request = {
+            assistantId,
+            fileId,
+        };
+        await this.rpcManager.post('ai/assistant/removeFileFromAssistant', request);
+    }
+    /**
+     * Adds a file to a specific thread of an AI assistant. These files can be used when asking a question in the thread.
+     * @param threadId - The ID of the thread.
+     * @param file - The file or blob and filename to be added.
+     * @returns A promise that resolves to the ID of the added file.
+     */
+    async addFileToThread(threadId, file) {
+        const request = { threadId };
+        const response = await this.rpcManager.post(`ai/assistant/addFileToThread`, request, [file], 'file');
+        return response.fileId;
+    }
 }
 
 ;// CONCATENATED MODULE: ./src/ai.types.ts
 
+/**
+ * AiClient class serves as a facade for interacting with different AI services.
+ * It provides simplified access to AI chatbot and assistant functionalities
+ * through its methods.
+ */
 class AiClient {
     constructor(aiChatbotClientFactory, rpcManager) {
         this.aiChatbotClientFactory = aiChatbotClientFactory;
         this.rpcManager = rpcManager;
         this.aiAssistantClient = new AiAssistantClient(this.rpcManager);
     }
-    chatbot(integrationId) {
-        return this.aiChatbotClientFactory.getChatbot(integrationId);
+    /**
+     * Retrieves an AI chatbot client for a specific AI integration.
+     * @param aiIntegrationId - The identifier for the AI integration.
+     * @returns An instance of AiChatbotClient associated with the given AI integration ID.
+     */
+    chatbot(aiIntegrationId) {
+        return this.aiChatbotClientFactory.getChatbot(aiIntegrationId);
     }
+    /**
+     * Retrieves the AI assistant client.
+     * @returns An instance of AiAssistantClient.
+     */
     assistant() {
         return this.aiAssistantClient;
     }
@@ -49655,23 +50151,6 @@ class Squid {
     constructor(options) {
         this.options = options;
         this.destructManager = new DestructManager();
-        // Note: The following methods are bound using arrow functions to ensure that if a user accesses the methods via
-        // destructuring (i.e. `{ setAuthIdToken } = squid`) then `this` will still be bound to the Squid class.
-        /**
-         * Sets the authorization access token (OAuth2.0) that will be sent to the server and will be used for providing the
-         * `auth` object to the security rules.
-         *
-         * @deprecated: pass `AuthTokenProvider` in the constructor of the class.
-         *
-         * @param accessToken The OAuth2.0 access token or a promise that resolves with the access token.
-         * When undefined, no authorization information is sent.
-         * The Observable variant of the parameter is deprecated and will be removed soon.
-         * @param integrationId The id of the integration.
-         * @returns void
-         */
-        this.setAuthIdToken = (accessToken, integrationId) => {
-            this.authManager.setAuthIdToken(accessToken, integrationId);
-        };
         /**
          * Returns a reference to the collection in the provided integration.
          *
@@ -49909,6 +50388,8 @@ class Squid {
     static getInstances() {
         return Object.values(Squid.squidInstancesMap);
     }
+    // Note: The following methods are bound using arrow functions to ensure that if a user accesses the methods via
+    // destructuring (i.e. `{ setAuthProvider } = squid`) then `this` will still be bound to the Squid class.
     /**
      * Sets the authorization access token (OAuth2.0) provider that will be sent to the server and will be used for
      * providing the `auth` object to the security rules.