@squidcloud/client 1.0.170 → 1.0.171

package/dist/cjs/index.js

@@ -1973,527 +1973,6 @@ exports.Response = ctx.Response
 module.exports = exports
 
 
-/***/ }),
-
-/***/ 2091:
-/***/ (function(module, exports, __webpack_require__) {
-
-var __WEBPACK_AMD_DEFINE_RESULT__;;(function(root, factory) { // eslint-disable-line no-extra-semi
-  var deepDiff = factory(root);
-  // eslint-disable-next-line no-undef
-  if (true) {
-      // AMD
-      !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { // eslint-disable-line no-undef
-          return deepDiff;
-      }).call(exports, __webpack_require__, exports, module),
-		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
-  } else { var _deepdiff; }
-}(this, function(root) {
-  var validKinds = ['N', 'E', 'A', 'D'];
-
-  // nodejs compatible on server side and in the browser.
-  function inherits(ctor, superCtor) {
-    ctor.super_ = superCtor;
-    ctor.prototype = Object.create(superCtor.prototype, {
-      constructor: {
-        value: ctor,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-  }
-
-  function Diff(kind, path) {
-    Object.defineProperty(this, 'kind', {
-      value: kind,
-      enumerable: true
-    });
-    if (path && path.length) {
-      Object.defineProperty(this, 'path', {
-        value: path,
-        enumerable: true
-      });
-    }
-  }
-
-  function DiffEdit(path, origin, value) {
-    DiffEdit.super_.call(this, 'E', path);
-    Object.defineProperty(this, 'lhs', {
-      value: origin,
-      enumerable: true
-    });
-    Object.defineProperty(this, 'rhs', {
-      value: value,
-      enumerable: true
-    });
-  }
-  inherits(DiffEdit, Diff);
-
-  function DiffNew(path, value) {
-    DiffNew.super_.call(this, 'N', path);
-    Object.defineProperty(this, 'rhs', {
-      value: value,
-      enumerable: true
-    });
-  }
-  inherits(DiffNew, Diff);
-
-  function DiffDeleted(path, value) {
-    DiffDeleted.super_.call(this, 'D', path);
-    Object.defineProperty(this, 'lhs', {
-      value: value,
-      enumerable: true
-    });
-  }
-  inherits(DiffDeleted, Diff);
-
-  function DiffArray(path, index, item) {
-    DiffArray.super_.call(this, 'A', path);
-    Object.defineProperty(this, 'index', {
-      value: index,
-      enumerable: true
-    });
-    Object.defineProperty(this, 'item', {
-      value: item,
-      enumerable: true
-    });
-  }
-  inherits(DiffArray, Diff);
-
-  function arrayRemove(arr, from, to) {
-    var rest = arr.slice((to || from) + 1 || arr.length);
-    arr.length = from < 0 ? arr.length + from : from;
-    arr.push.apply(arr, rest);
-    return arr;
-  }
-
-  function realTypeOf(subject) {
-    var type = typeof subject;
-    if (type !== 'object') {
-      return type;
-    }
-
-    if (subject === Math) {
-      return 'math';
-    } else if (subject === null) {
-      return 'null';
-    } else if (Array.isArray(subject)) {
-      return 'array';
-    } else if (Object.prototype.toString.call(subject) === '[object Date]') {
-      return 'date';
-    } else if (typeof subject.toString === 'function' && /^\/.*\//.test(subject.toString())) {
-      return 'regexp';
-    }
-    return 'object';
-  }
-
-  // http://werxltd.com/wp/2010/05/13/javascript-implementation-of-javas-string-hashcode-method/
-  function hashThisString(string) {
-    var hash = 0;
-    if (string.length === 0) { return hash; }
-    for (var i = 0; i < string.length; i++) {
-      var char = string.charCodeAt(i);
-      hash = ((hash << 5) - hash) + char;
-      hash = hash & hash; // Convert to 32bit integer
-    }
-    return hash;
-  }
-
-  // Gets a hash of the given object in an array order-independent fashion
-  // also object key order independent (easier since they can be alphabetized)
-  function getOrderIndependentHash(object) {
-    var accum = 0;
-    var type = realTypeOf(object);
-
-    if (type === 'array') {
-      object.forEach(function (item) {
-        // Addition is commutative so this is order indep
-        accum += getOrderIndependentHash(item);
-      });
-
-      var arrayString = '[type: array, hash: ' + accum + ']';
-      return accum + hashThisString(arrayString);
-    }
-
-    if (type === 'object') {
-      for (var key in object) {
-        if (object.hasOwnProperty(key)) {
-          var keyValueString = '[ type: object, key: ' + key + ', value hash: ' + getOrderIndependentHash(object[key]) + ']';
-          accum += hashThisString(keyValueString);
-        }
-      }
-
-      return accum;
-    }
-
-    // Non object, non array...should be good?
-    var stringToHash = '[ type: ' + type + ' ; value: ' + object + ']';
-    return accum + hashThisString(stringToHash);
-  }
-
-  function deepDiff(lhs, rhs, changes, prefilter, path, key, stack, orderIndependent) {
-    changes = changes || [];
-    path = path || [];
-    stack = stack || [];
-    var currentPath = path.slice(0);
-    if (typeof key !== 'undefined' && key !== null) {
-      if (prefilter) {
-        if (typeof (prefilter) === 'function' && prefilter(currentPath, key)) {
-          return;
-        } else if (typeof (prefilter) === 'object') {
-          if (prefilter.prefilter && prefilter.prefilter(currentPath, key)) {
-            return;
-          }
-          if (prefilter.normalize) {
-            var alt = prefilter.normalize(currentPath, key, lhs, rhs);
-            if (alt) {
-              lhs = alt[0];
-              rhs = alt[1];
-            }
-          }
-        }
-      }
-      currentPath.push(key);
-    }
-
-    // Use string comparison for regexes
-    if (realTypeOf(lhs) === 'regexp' && realTypeOf(rhs) === 'regexp') {
-      lhs = lhs.toString();
-      rhs = rhs.toString();
-    }
-
-    var ltype = typeof lhs;
-    var rtype = typeof rhs;
-    var i, j, k, other;
-
-    var ldefined = ltype !== 'undefined' ||
-      (stack && (stack.length > 0) && stack[stack.length - 1].lhs &&
-        Object.getOwnPropertyDescriptor(stack[stack.length - 1].lhs, key));
-    var rdefined = rtype !== 'undefined' ||
-      (stack && (stack.length > 0) && stack[stack.length - 1].rhs &&
-        Object.getOwnPropertyDescriptor(stack[stack.length - 1].rhs, key));
-
-    if (!ldefined && rdefined) {
-      changes.push(new DiffNew(currentPath, rhs));
-    } else if (!rdefined && ldefined) {
-      changes.push(new DiffDeleted(currentPath, lhs));
-    } else if (realTypeOf(lhs) !== realTypeOf(rhs)) {
-      changes.push(new DiffEdit(currentPath, lhs, rhs));
-    } else if (realTypeOf(lhs) === 'date' && (lhs - rhs) !== 0) {
-      changes.push(new DiffEdit(currentPath, lhs, rhs));
-    } else if (ltype === 'object' && lhs !== null && rhs !== null) {
-      for (i = stack.length - 1; i > -1; --i) {
-        if (stack[i].lhs === lhs) {
-          other = true;
-          break;
-        }
-      }
-      if (!other) {
-        stack.push({ lhs: lhs, rhs: rhs });
-        if (Array.isArray(lhs)) {
-          // If order doesn't matter, we need to sort our arrays
-          if (orderIndependent) {
-            lhs.sort(function (a, b) {
-              return getOrderIndependentHash(a) - getOrderIndependentHash(b);
-            });
-
-            rhs.sort(function (a, b) {
-              return getOrderIndependentHash(a) - getOrderIndependentHash(b);
-            });
-          }
-          i = rhs.length - 1;
-          j = lhs.length - 1;
-          while (i > j) {
-            changes.push(new DiffArray(currentPath, i, new DiffNew(undefined, rhs[i--])));
-          }
-          while (j > i) {
-            changes.push(new DiffArray(currentPath, j, new DiffDeleted(undefined, lhs[j--])));
-          }
-          for (; i >= 0; --i) {
-            deepDiff(lhs[i], rhs[i], changes, prefilter, currentPath, i, stack, orderIndependent);
-          }
-        } else {
-          var akeys = Object.keys(lhs);
-          var pkeys = Object.keys(rhs);
-          for (i = 0; i < akeys.length; ++i) {
-            k = akeys[i];
-            other = pkeys.indexOf(k);
-            if (other >= 0) {
-              deepDiff(lhs[k], rhs[k], changes, prefilter, currentPath, k, stack, orderIndependent);
-              pkeys[other] = null;
-            } else {
-              deepDiff(lhs[k], undefined, changes, prefilter, currentPath, k, stack, orderIndependent);
-            }
-          }
-          for (i = 0; i < pkeys.length; ++i) {
-            k = pkeys[i];
-            if (k) {
-              deepDiff(undefined, rhs[k], changes, prefilter, currentPath, k, stack, orderIndependent);
-            }
-          }
-        }
-        stack.length = stack.length - 1;
-      } else if (lhs !== rhs) {
-        // lhs is contains a cycle at this element and it differs from rhs
-        changes.push(new DiffEdit(currentPath, lhs, rhs));
-      }
-    } else if (lhs !== rhs) {
-      if (!(ltype === 'number' && isNaN(lhs) && isNaN(rhs))) {
-        changes.push(new DiffEdit(currentPath, lhs, rhs));
-      }
-    }
-  }
-
-  function observableDiff(lhs, rhs, observer, prefilter, orderIndependent) {
-    var changes = [];
-    deepDiff(lhs, rhs, changes, prefilter, null, null, null, orderIndependent);
-    if (observer) {
-      for (var i = 0; i < changes.length; ++i) {
-        observer(changes[i]);
-      }
-    }
-    return changes;
-  }
-
-  function orderIndependentDeepDiff(lhs, rhs, changes, prefilter, path, key, stack) {
-    return deepDiff(lhs, rhs, changes, prefilter, path, key, stack, true);
-  }
-
-  function accumulateDiff(lhs, rhs, prefilter, accum) {
-    var observer = (accum) ?
-      function (difference) {
-        if (difference) {
-          accum.push(difference);
-        }
-      } : undefined;
-    var changes = observableDiff(lhs, rhs, observer, prefilter);
-    return (accum) ? accum : (changes.length) ? changes : undefined;
-  }
-
-  function accumulateOrderIndependentDiff(lhs, rhs, prefilter, accum) {
-    var observer = (accum) ?
-      function (difference) {
-        if (difference) {
-          accum.push(difference);
-        }
-      } : undefined;
-    var changes = observableDiff(lhs, rhs, observer, prefilter, true);
-    return (accum) ? accum : (changes.length) ? changes : undefined;
-  }
-
-  function applyArrayChange(arr, index, change) {
-    if (change.path && change.path.length) {
-      var it = arr[index],
-        i, u = change.path.length - 1;
-      for (i = 0; i < u; i++) {
-        it = it[change.path[i]];
-      }
-      switch (change.kind) {
-        case 'A':
-          applyArrayChange(it[change.path[i]], change.index, change.item);
-          break;
-        case 'D':
-          delete it[change.path[i]];
-          break;
-        case 'E':
-        case 'N':
-          it[change.path[i]] = change.rhs;
-          break;
-      }
-    } else {
-      switch (change.kind) {
-        case 'A':
-          applyArrayChange(arr[index], change.index, change.item);
-          break;
-        case 'D':
-          arr = arrayRemove(arr, index);
-          break;
-        case 'E':
-        case 'N':
-          arr[index] = change.rhs;
-          break;
-      }
-    }
-    return arr;
-  }
-
-  function applyChange(target, source, change) {
-    if (typeof change === 'undefined' && source && ~validKinds.indexOf(source.kind)) {
-      change = source;
-    }
-    if (target && change && change.kind) {
-      var it = target,
-        i = -1,
-        last = change.path ? change.path.length - 1 : 0;
-      while (++i < last) {
-        if (typeof it[change.path[i]] === 'undefined') {
-          it[change.path[i]] = (typeof change.path[i + 1] !== 'undefined' && typeof change.path[i + 1] === 'number') ? [] : {};
-        }
-        it = it[change.path[i]];
-      }
-      switch (change.kind) {
-        case 'A':
-          if (change.path && typeof it[change.path[i]] === 'undefined') {
-            it[change.path[i]] = [];
-          }
-          applyArrayChange(change.path ? it[change.path[i]] : it, change.index, change.item);
-          break;
-        case 'D':
-          delete it[change.path[i]];
-          break;
-        case 'E':
-        case 'N':
-          it[change.path[i]] = change.rhs;
-          break;
-      }
-    }
-  }
-
-  function revertArrayChange(arr, index, change) {
-    if (change.path && change.path.length) {
-      // the structure of the object at the index has changed...
-      var it = arr[index],
-        i, u = change.path.length - 1;
-      for (i = 0; i < u; i++) {
-        it = it[change.path[i]];
-      }
-      switch (change.kind) {
-        case 'A':
-          revertArrayChange(it[change.path[i]], change.index, change.item);
-          break;
-        case 'D':
-          it[change.path[i]] = change.lhs;
-          break;
-        case 'E':
-          it[change.path[i]] = change.lhs;
-          break;
-        case 'N':
-          delete it[change.path[i]];
-          break;
-      }
-    } else {
-      // the array item is different...
-      switch (change.kind) {
-        case 'A':
-          revertArrayChange(arr[index], change.index, change.item);
-          break;
-        case 'D':
-          arr[index] = change.lhs;
-          break;
-        case 'E':
-          arr[index] = change.lhs;
-          break;
-        case 'N':
-          arr = arrayRemove(arr, index);
-          break;
-      }
-    }
-    return arr;
-  }
-
-  function revertChange(target, source, change) {
-    if (target && source && change && change.kind) {
-      var it = target,
-        i, u;
-      u = change.path.length - 1;
-      for (i = 0; i < u; i++) {
-        if (typeof it[change.path[i]] === 'undefined') {
-          it[change.path[i]] = {};
-        }
-        it = it[change.path[i]];
-      }
-      switch (change.kind) {
-        case 'A':
-          // Array was modified...
-          // it will be an array...
-          revertArrayChange(it[change.path[i]], change.index, change.item);
-          break;
-        case 'D':
-          // Item was deleted...
-          it[change.path[i]] = change.lhs;
-          break;
-        case 'E':
-          // Item was edited...
-          it[change.path[i]] = change.lhs;
-          break;
-        case 'N':
-          // Item is new...
-          delete it[change.path[i]];
-          break;
-      }
-    }
-  }
-
-  function applyDiff(target, source, filter) {
-    if (target && source) {
-      var onChange = function (change) {
-        if (!filter || filter(target, source, change)) {
-          applyChange(target, source, change);
-        }
-      };
-      observableDiff(target, source, onChange);
-    }
-  }
-
-  Object.defineProperties(accumulateDiff, {
-
-    diff: {
-      value: accumulateDiff,
-      enumerable: true
-    },
-    orderIndependentDiff: {
-      value: accumulateOrderIndependentDiff,
-      enumerable: true
-    },
-    observableDiff: {
-      value: observableDiff,
-      enumerable: true
-    },
-    orderIndependentObservableDiff: {
-      value: orderIndependentDeepDiff,
-      enumerable: true
-    },
-    orderIndepHash: {
-      value: getOrderIndependentHash,
-      enumerable: true
-    },
-    applyDiff: {
-      value: applyDiff,
-      enumerable: true
-    },
-    applyChange: {
-      value: applyChange,
-      enumerable: true
-    },
-    revertChange: {
-      value: revertChange,
-      enumerable: true
-    },
-    isConflict: {
-      value: function () {
-        return typeof $conflict !== 'undefined';
-      },
-      enumerable: true
-    }
-  });
-
-  // hackish...
-  accumulateDiff.DeepDiff = accumulateDiff;
-  // ...but works with:
-  // import DeepDiff from 'deep-diff'
-  // import { DeepDiff } from 'deep-diff'
-  // const DeepDiff = require('deep-diff');
-  // const { DeepDiff } = require('deep-diff');
-
-  if (root) {
-    root.DeepDiff = accumulateDiff;
-  }
-
-  return accumulateDiff;
-}));
-
-
 /***/ }),
 
 /***/ 8784:
@@ -28041,6 +27520,7 @@ __webpack_require__.d(__webpack_exports__, {
   QueryBuilder: () => (/* reexport */ QueryBuilder),
   QueryContext: () => (/* reexport */ QueryContext),
   QueueIntegrationTypes: () => (/* reexport */ QueueIntegrationTypes),
+  SQUID_REGIONS: () => (/* reexport */ SQUID_REGIONS),
   SUPPORTED_SQUID_REGIONS: () => (/* reexport */ SUPPORTED_SQUID_REGIONS),
   Squid: () => (/* reexport */ Squid),
   allEnvironmentIds: () => (/* reexport */ allEnvironmentIds),
@@ -28906,7 +28386,7 @@ function sortKeys(json) {
     });
     return result;
 }
-function serialization_normalizeJsonAsString(json) {
+function normalizeJsonAsString(json) {
     return serializeObj(sortKeys(json));
 }
 function serializeObj(obj) {
@@ -28984,7 +28464,7 @@ function decodeValueForMapping(encodedString) {
  */
 /** @internal */
 function encodeCondition(condition) {
-    return serialization_normalizeJsonAsString(condition);
+    return normalizeJsonAsString(condition);
 }
 /** @internal */
 class QueryMappingManager {
@@ -29342,10 +28822,10 @@ class QueryContext {
 }
 
 ;// CONCATENATED MODULE: ../internal-common/src/public-types/regions.public-types.ts
-/**
- * The list of supported Squid regions.
- */
-const SUPPORTED_SQUID_REGIONS = ['us-east-1.aws'];
+/** The list of regions in Squid. */
+const SQUID_REGIONS = ['us-east-1.aws'];
+/** @deprecated: Use 'SQUID_REGIONS'. */
+const SUPPORTED_SQUID_REGIONS = SQUID_REGIONS;
 
 ;// CONCATENATED MODULE: ../internal-common/src/public-types/socket.public-types.ts
 var ClientConnectionState;
@@ -30722,7 +30202,7 @@ function assert_validateTruthy(value, message, statusCode = HttpStatus.BAD_REQUE
 
 
 
-class validation_ValidationError extends (/* unused pure expression or super */ null && (Error)) {
+class validation_ValidationError extends Error {
     constructor(error, statusCode, details) {
         super(error);
         this.statusCode = statusCode;
@@ -30929,12 +30409,8 @@ function hasOnlyKeys(obj, keys) {
     return !Array.isArray(obj) && [...Object.keys(obj)].every(key => keys.includes(key));
 }
 
-// EXTERNAL MODULE: ../node_modules/deep-diff/index.js
-var deep_diff = __webpack_require__(2091);
 ;// CONCATENATED MODULE: ../internal-common/src/types/document.types.ts
 
-
-
 /** @internal */
 const SquidPlaceholderId = '__squidId';
 /** @internal */
@@ -30954,45 +30430,7 @@ function getSquidDocId(...args) {
     // Handle nulls and empty strings
     if (!squidDocIdObjObj.integrationId)
         squidDocIdObjObj.integrationId = undefined;
-    return serialization_normalizeJsonAsString(squidDocIdObjObj);
-}
-/**
- * Determines whether a beforeDoc and an afterDoc have the same properties.
- * Our internal properties such as __docId__ and __ts__ are excluded from the
- * comparison, as well as any primary keys changes.
- * @internal
- */
-function hasDocumentDiff(beforeDoc, afterDoc) {
-    const diffs = deepDiff(beforeDoc, afterDoc) || [];
-    const ignoredKeys = ['__docId__', '__ts__'];
-    const docIdDiff = diffs.find((diff) => {
-        var _a;
-        return ((_a = diff.path) === null || _a === void 0 ? void 0 : _a[0]) === '__docId__';
-    });
-    if (docIdDiff) {
-        if (docIdDiff.kind !== 'E' || !docIdDiff.rhs) {
-            throw new Error(`Unexpected diff for __docId__: ${normalizeJsonAsString(docIdDiff)}`);
-        }
-        const docIdObj = parseSquidDocId(docIdDiff.rhs + '');
-        ignoredKeys.push(...Object.keys(docIdObj));
-    }
-    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]))
-            return false;
-        switch (diff.kind) {
-            case 'N':
-                // If a new property has been added, and it's defined, the document is changed.
-                return isNonNullable(diff.rhs);
-            case 'E':
-            case 'D':
-            case 'A':
-                return true;
-        }
-        return false;
-    });
-    return !!diff;
+    return normalizeJsonAsString(squidDocIdObjObj);
 }
 
 ;// CONCATENATED MODULE: ./src/query/query-builder.factory.ts
@@ -31805,9 +31243,9 @@ class CollectionReference {
             docId = { __id: docId || generateId() };
         }
         else {
-            docId = { __id: serialization_normalizeJsonAsString(docId) };
+            docId = { __id: normalizeJsonAsString(docId) };
         }
-        const docIdAsJsonString = serialization_normalizeJsonAsString(docId);
+        const docIdAsJsonString = normalizeJsonAsString(docId);
         const squidDocId = getSquidDocId(docIdAsJsonString, this.collectionName, this.integrationId);
         return this.documentReferenceFactory.create(squidDocId, this.queryBuilderFactory);
     }
@@ -49115,8 +48553,8 @@ class DataManager {
         if ((!existingDoc && !doc) || existingDoc === doc)
             return false;
         if (existingDoc && doc) {
-            const serializedDoc = serialization_normalizeJsonAsString(Object.assign(Object.assign({}, doc), { __ts__: undefined }));
-            const serializedExistingDoc = serialization_normalizeJsonAsString(existingDoc);
+            const serializedDoc = normalizeJsonAsString(Object.assign(Object.assign({}, doc), { __ts__: undefined }));
+            const serializedExistingDoc = normalizeJsonAsString(existingDoc);
             if (serializedDoc === serializedExistingDoc)
                 return false;
         }
@@ -49617,7 +49055,7 @@ class DocumentStore {
     }
     group(sortedDocs, sortFieldNames) {
         return Object.values(lodash_default().groupBy(sortedDocs, doc => {
-            return serialization_normalizeJsonAsString(sortFieldNames.map(fieldName => getInPath(doc, fieldName)));
+            return normalizeJsonAsString(sortFieldNames.map(fieldName => getInPath(doc, fieldName)));
         }));
     }
     sortAndLimitDocs(docIdSet, query) {
@@ -51164,7 +50602,7 @@ class SocketManager {
         DebugLogger.debug('Connecting to socket at:', endpoint);
         const socketUri = `${endpoint}?clientId=${this.clientIdService.getClientId()}`;
         this.socket = createWebSocketWrapper(socketUri, {
-            timeout: 5000,
+            timeout: 5000, // 5 seconds
             onmessage: (e) => this.onMessage(e.data),
             onopen: () => {
                 DebugLogger.debug(`Connection to socket established. Endpoint: ${endpoint}`);
@@ -51824,7 +51262,7 @@ class Squid {
      * @returns A global Squid instance with the given options.
      */
     static getInstance(options) {
-        const optionsStr = serialization_normalizeJsonAsString(options);
+        const optionsStr = normalizeJsonAsString(options);
         let instance = Squid.squidInstancesMap[optionsStr];
         if (instance)
             return instance;

package/dist/internal-common/src/public-types/regions.public-types.d.ts

@@ -1,5 +1,8 @@
-/**
- * The list of supported Squid regions.
- */
+/** The list of regions in Squid. */
+export declare const SQUID_REGIONS: readonly ["us-east-1.aws"];
+/** Region type used by Squid. */
+export type SquidRegion = (typeof SQUID_REGIONS)[number];
+/** @deprecated: Use 'SQUID_REGIONS'. */
 export declare const SUPPORTED_SQUID_REGIONS: readonly ["us-east-1.aws"];
-export type SupportedSquidRegion = (typeof SUPPORTED_SQUID_REGIONS)[number];
+/** @deprecated: Use 'SquidRegion'. */
+export type SupportedSquidRegion = SquidRegion;

package/dist/typescript-client/src/graphql-client.d.ts

@@ -1,12 +1,12 @@
 import { RpcManager } from './rpc.manager';
-import { GraphQLRequest, IntegrationId, SupportedSquidRegion } from './public-types';
+import { GraphQLRequest, IntegrationId, SquidRegion } from './public-types';
 /** A GraphQL client that can be used to query and mutate data. */
 export declare class GraphQLClient {
     private readonly rpcManager;
     private readonly region;
     private readonly appId;
     private readonly client;
-    constructor(rpcManager: RpcManager, integrationId: IntegrationId, region: SupportedSquidRegion, appId: string);
+    constructor(rpcManager: RpcManager, integrationId: IntegrationId, region: SquidRegion, appId: string);
     /** Executes a GraphQL query and returns a promise with the result. */
     query<T = any>(request: GraphQLRequest): Promise<T>;
     /** Executes a GraphQL mutation and returns a promise with the result. */

package/dist/typescript-client/src/graphql-client.factory.d.ts

@@ -1,11 +1,11 @@
 import { GraphQLClient } from './graphql-client';
 import { RpcManager } from './rpc.manager';
-import { IntegrationId, SupportedSquidRegion } from './public-types';
+import { IntegrationId, SquidRegion } from './public-types';
 export declare class GraphQLClientFactory {
     private readonly rpcManager;
     private readonly region;
     private readonly appId;
     private readonly clientsMap;
-    constructor(rpcManager: RpcManager, region: SupportedSquidRegion, appId: string);
+    constructor(rpcManager: RpcManager, region: SquidRegion, appId: string);
     get(integrationId: IntegrationId): GraphQLClient;
 }

package/dist/typescript-client/src/rpc.manager.d.ts

@@ -2,7 +2,7 @@ import { AuthManager } from './auth.manager';
 import { ClientIdService } from './client-id.service';
 import { DestructManager } from './destruct.manager';
 import { BlobAndFilename } from './types';
-import { SupportedSquidRegion } from './public-types';
+import { SquidRegion } from './public-types';
 export declare class RpcManager {
     private readonly region;
     private readonly appId;
@@ -11,7 +11,7 @@ export declare class RpcManager {
     private readonly staticHeaders;
     private readonly onGoingRpcCounter;
     private readonly rateLimiters;
-    constructor(region: SupportedSquidRegion, appId: string, destructManager: DestructManager, headers: Record<string, string> | undefined, authManager: AuthManager, clientIdService: ClientIdService);
+    constructor(region: SquidRegion, appId: string, destructManager: DestructManager, headers: Record<string, string> | undefined, authManager: AuthManager, clientIdService: ClientIdService);
     private getAuthHeaders;
     awaitAllSettled(): Promise<void>;
     setStaticHeader(key: string, value: string): void;

package/dist/typescript-client/src/squid.d.ts

@@ -5,7 +5,7 @@ import { GraphQLClient } from './graphql-client';
 import { SecretClient } from './secret.client';
 import { TransactionId } from './types';
 import { AiClient } from './ai.types';
-import { ApiEndpointId, ApiKey, AppId, CollectionName, DocumentData, EnvironmentId, IntegrationId, SquidDeveloperId, SupportedSquidRegion } from './public-types';
+import { ApiEndpointId, ApiKey, AppId, CollectionName, DocumentData, EnvironmentId, IntegrationId, SquidDeveloperId, SquidRegion } from './public-types';
 import { QueueManager } from './queue.manager';
 /** The different options that can be used to initialize a Squid instance. */
 export interface SquidOptions {
@@ -39,7 +39,7 @@ export interface SquidOptions {
     /**
      * The region that the application is running in. This is used to determine the URL of the Squid Cloud API.
      */
-    region: SupportedSquidRegion;
+    region: SquidRegion;
     /**
      * The environment ID to work with, if not specified the default environment (prod) will be used.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/client",
-  "version": "1.0.170",
+  "version": "1.0.171",
   "description": "A typescript implementation of the Squid client",
   "main": "dist/cjs/index.js",
   "types": "dist/typescript-client/src/index.d.ts",