@osdk/client 2.0.0-beta.11 → 2.0.0-beta.13

package/build/esm/{chunk-WGFCR4UM.js → chunk-MQTCPUPF.js}

@@ -1,10 +1,12 @@
 import { symbolClientContext } from '@osdk/shared.client';
 import { PalantirApiError, UnknownError } from '@osdk/shared.net.errors';
 import { createFetchHeaderMutator } from '@osdk/shared.net.fetch';
-import invariant from 'tiny-invariant';
-import { DistanceUnitMapping, TimeSeriesProperty, DurationMapping, TimeseriesDurationMapping } from '@osdk/client.api';
-import { createSharedClientContext } from '@osdk/shared.client.impl';
-import { wireObjectTypeFullMetadataToSdkObjectTypeDefinition, __UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition, wireQueryTypeV2ToSdkQueryDefinition } from '@osdk/generator-converters';
+import invariant5 from 'tiny-invariant';
+import { DistanceUnitMapping, DurationMapping, TimeSeriesProperty, TimeseriesDurationMapping } from '@osdk/client.api';
+import { __EXPERIMENTAL__NOT_SUPPORTED_YET_subscribe } from '@osdk/client.api/unstable';
+import { createTemporaryObjectSet, getLinkTypesForObjectTypes, bulkLoadOntologyEntities, loadAllOntologies } from '@osdk/client.unstable';
+import { batchEnableWatcher } from '@osdk/client.unstable.osw';
+import WebSocket from 'isomorphic-ws';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -12,14 +14,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/actions/ActionValidationError.ts
-var ActionValidationError = class extends Error {
-  constructor(validation) {
-    super("Validation Error");
-    this.validation = validation;
-  }
-};
-
 // ../internal.foundry.datasets/build/esm/chunk-PZ5AY32C.js
 var __defProp2 = Object.defineProperty;
 var __export2 = (target, all) => {
@@ -696,19 +690,6 @@ function createAttachmentFromRid(client, rid) {
     }
   };
 }
-
-// src/object/AttachmentUpload.ts
-function isAttachmentUpload(o) {
-  return o instanceof Blob && "name" in o;
-}
-function createAttachmentUpload(data, name) {
-  const attachmentUpload = Object.create(data, {
-    name: {
-      value: name
-    }
-  });
-  return attachmentUpload;
-}
 var addUserAgentAndRequestContextHeaders = (client, withMetadata) => ({
   ...client,
   fetch: createFetchHeaderMutator(client.fetch, (headers) => {
@@ -1125,7 +1106,7 @@ function makeGeoFilterPolygon(field, coordinates, filterType) {
   };
 }
 function handleWherePair([field, filter]) {
-  !(filter != null) ? process.env.NODE_ENV !== "production" ? invariant(false, "Defined key values are only allowed when they are not undefined.") : invariant(false) : void 0;
+  !(filter != null) ? process.env.NODE_ENV !== "production" ? invariant5(false, "Defined key values are only allowed when they are not undefined.") : invariant5(false) : void 0;
   if (typeof filter === "string" || typeof filter === "number" || typeof filter === "boolean") {
     return {
       type: "eq",
@@ -1135,12 +1116,12 @@ function handleWherePair([field, filter]) {
   }
   const keysOfFilter = Object.keys(filter);
   const hasDollarSign = keysOfFilter.some((key) => key.startsWith("$"));
-  !(!hasDollarSign || keysOfFilter.length === 1) ? process.env.NODE_ENV !== "production" ? invariant(false, "WhereClause Filter with multiple clauses isn't allowed") : invariant(false) : void 0;
+  !(!hasDollarSign || keysOfFilter.length === 1) ? process.env.NODE_ENV !== "production" ? invariant5(false, "WhereClause Filter with multiple clauses isn't allowed") : invariant5(false) : void 0;
   if (!hasDollarSign) {
     throw new Error(`Unsupported filter. Did you forget to use a $-prefixed filter? (${JSON.stringify(filter)})`);
   }
   const firstKey = keysOfFilter[0];
-  !(filter[firstKey] != null) ? process.env.NODE_ENV !== "production" ? invariant(false) : invariant(false) : void 0;
+  !(filter[firstKey] != null) ? process.env.NODE_ENV !== "production" ? invariant5(false) : invariant5(false) : void 0;
   if (firstKey === "$ne") {
     return {
       type: "not",
@@ -1200,7 +1181,7 @@ function legacyToModernSingleAggregationResult(entry) {
     if (parts[0] === "count") {
       return accumulator;
     }
-    !(parts.length === 2) ? process.env.NODE_ENV !== "production" ? invariant(false, "assumed we were getting a `${key}.${type}`") : invariant(false) : void 0;
+    !(parts.length === 2) ? process.env.NODE_ENV !== "production" ? invariant5(false, "assumed we were getting a `${key}.${type}`") : invariant5(false) : void 0;
     const property = parts[0];
     const metricType = parts[1];
     if (!(property in accumulator)) {
@@ -1300,7 +1281,7 @@ async function aggregate(clientCtx, objectType, objectSet = {
     aggregation: body.aggregation
   });
   if (!req.$groupBy) {
-    !(result.data.length === 1) ? process.env.NODE_ENV !== "production" ? invariant(false, "no group by clause should mean only one data result") : invariant(false) : void 0;
+    !(result.data.length === 1) ? process.env.NODE_ENV !== "production" ? invariant5(false, "no group by clause should mean only one data result") : invariant5(false) : void 0;
     return {
       ...aggregationToCountResult(result.data[0]),
       ...legacyToModernSingleAggregationResult(result.data[0])
@@ -1367,6 +1348,721 @@ function isWireObjectSet(o) {
   return o != null && typeof o === "object" && WIRE_OBJECT_SET_TYPES.has(o.type);
 }
 
+// src/ontology/makeConjureContext.ts
+function makeConjureContext({
+  baseUrl,
+  fetch: fetchFn,
+  tokenProvider
+}, servicePath) {
+  return {
+    baseUrl,
+    servicePath,
+    fetchFn,
+    tokenProvider
+  };
+}
+
+// src/__unstable/ConjureSupport.ts
+var cachedAllOntologies;
+async function getOntologyVersionForRid(ctx, ontologyRid) {
+  cachedAllOntologies ??= await loadAllOntologies(ctx, {});
+  !cachedAllOntologies.ontologies[ontologyRid] ? process.env.NODE_ENV !== "production" ? invariant5(false, "ontology should be loaded") : invariant5(false) : void 0;
+  return cachedAllOntologies.ontologies[ontologyRid].currentOntologyVersion;
+}
+var strongMemoAsync = (fn) => createSimpleAsyncCache("strong", fn).get;
+var weakMemoAsync = (fn) => createSimpleAsyncCache("weak", fn).get;
+var MetadataClient = class {
+  #client;
+  #ctx;
+  #logger;
+  constructor(client) {
+    this.#client = client;
+    this.#ctx = makeConjureContext(client, "/ontology-metadata/api");
+    this.#client.ontologyProvider.getObjectDefinition;
+    this.#logger = this.#client.logger?.child({
+      mcc: true
+    });
+  }
+  forObjectByRid = strongMemoAsync(async (rid) => {
+    return Promise.resolve({
+      getPropertyMapping: this.#objectPropertyMapping.bind(this, rid),
+      getLinkMapping: this.#objectLinkMapping.bind(this, rid),
+      getRid: () => rid,
+      getApiName: async () => (await this.#getConjureObjectType(rid)).apiName
+    });
+  });
+  forObjectByApiName = strongMemoAsync(async (objectApiName) => {
+    const objectDef = await this.#client.ontologyProvider.getObjectDefinition(objectApiName);
+    return this.forObjectByRid(objectDef.rid);
+  });
+  #objectPropertyMapping = strongMemoAsync(async (objectTypeRid) => {
+    const conjureObjectType = await this.#getConjureObjectType(objectTypeRid);
+    return createObjectPropertyMapping(conjureObjectType);
+  });
+  #objectLinkMapping = strongMemoAsync(async (objectTypeRid) => {
+    const linkTypes = await getLinkTypesForObjectTypes(this.#ctx, {
+      includeObjectTypesWithoutSearchableDatasources: true,
+      loadRedacted: false,
+      objectTypeBranches: {},
+      objectTypeVersions: {
+        [objectTypeRid]: await this.ontologyVersion("")
+      }
+    });
+    !linkTypes.linkTypes[objectTypeRid] ? process.env.NODE_ENV !== "production" ? invariant5(false, "link type should be loaded") : invariant5(false) : void 0;
+    const ret = {};
+    for (const l of linkTypes.linkTypes[objectTypeRid]) {
+      const helper = ({
+        apiName
+      }, linkSide, otherObjectType) => {
+        if (apiName) {
+          ret[apiName] = {
+            apiName,
+            directedLinkTypeRid: {
+              linkTypeRid: l.rid,
+              linkSide
+            },
+            otherObjectType
+          };
+        }
+      };
+      if (l.definition.type === "oneToMany") {
+        const {
+          oneToMany: {
+            objectTypeRidManySide,
+            manyToOneLinkMetadata,
+            objectTypeRidOneSide,
+            oneToManyLinkMetadata
+          }
+        } = l.definition;
+        if (objectTypeRidManySide === objectTypeRid) {
+          helper(manyToOneLinkMetadata, "TARGET", objectTypeRidOneSide);
+        }
+        if (objectTypeRidOneSide === objectTypeRid) {
+          helper(oneToManyLinkMetadata, "SOURCE", objectTypeRidManySide);
+        }
+      } else if (l.definition.type === "manyToMany") {
+        const {
+          manyToMany: {
+            objectTypeRidA,
+            objectTypeAToBLinkMetadata,
+            objectTypeRidB,
+            objectTypeBToALinkMetadata
+          }
+        } = l.definition;
+        if (objectTypeRidA === objectTypeRid) {
+          helper(objectTypeAToBLinkMetadata, "SOURCE", objectTypeRidB);
+        }
+        if (objectTypeRidB === objectTypeRid) {
+          helper(objectTypeBToALinkMetadata, "TARGET", objectTypeRidA);
+        }
+      }
+    }
+    return ret;
+  });
+  #getConjureObjectType = strongMemoAsync(async (objectTypeRid) => {
+    this.#logger?.debug(`getConjureObjectType(${objectTypeRid})`);
+    const body = {
+      datasourceTypes: [],
+      objectTypes: [{
+        identifier: {
+          type: "objectTypeRid",
+          objectTypeRid
+        },
+        versionReference: {
+          type: "ontologyVersion",
+          ontologyVersion: await this.ontologyVersion("")
+        }
+      }],
+      linkTypes: [],
+      sharedPropertyTypes: [],
+      interfaceTypes: [],
+      typeGroups: [],
+      loadRedacted: false,
+      includeObjectTypeCount: void 0,
+      includeObjectTypesWithoutSearchableDatasources: true,
+      includeEntityMetadata: void 0
+    };
+    const entities = await bulkLoadOntologyEntities(this.#ctx, void 0, body);
+    !entities.objectTypes[0]?.objectType ? process.env.NODE_ENV !== "production" ? invariant5(false, "object type should be loaded") : invariant5(false) : void 0;
+    return entities.objectTypes[0].objectType;
+  });
+  ontologyVersion = strongMemoAsync(async (_) => getOntologyVersionForRid(this.#ctx, await this.#client.ontologyRid));
+};
+var metadataCacheClient = weakMemoAsync((client) => Promise.resolve(new MetadataClient(client)));
+function createObjectPropertyMapping(conjureOT) {
+  !(conjureOT.primaryKeys.length === 1) ? process.env.NODE_ENV !== "production" ? invariant5(false, `only one primary key supported, got ${conjureOT.primaryKeys.length}`) : invariant5(false) : void 0;
+  const pkRid = conjureOT.primaryKeys[0];
+  const pkProperty = Object.values(conjureOT.propertyTypes).find((a) => a.rid === pkRid);
+  if (!pkProperty) {
+    throw new Error(`Could not find PK property by rid: ${pkRid}`);
+  }
+  const propertyIdToApiNameMapping = Object.fromEntries(Object.values(conjureOT.propertyTypes).map((property) => {
+    return [property.id, property.apiName];
+  }));
+  const propertyApiNameToIdMapping = Object.fromEntries(Object.values(conjureOT.propertyTypes).map((property) => {
+    return [property.apiName, property.id];
+  }));
+  return {
+    apiName: conjureOT.apiName,
+    id: conjureOT.id,
+    propertyIdToApiNameMapping,
+    propertyApiNameToIdMapping,
+    pk: {
+      rid: pkRid,
+      apiName: pkProperty.apiName,
+      type: pkProperty.type
+    }
+  };
+}
+
+// src/objectSet/conjureUnionType.ts
+function conjureUnionType(type, value) {
+  return {
+    type,
+    [type]: value
+  };
+}
+
+// src/objectSet/toConjureObjectSet.ts
+function toConjureObjectSet(objectSet, objectPropertyMapping) {
+  switch (objectSet.type) {
+    case "base":
+      return conjureUnionType("base", {
+        objectTypeId: objectPropertyMapping.id
+      });
+    case "static":
+      return conjureUnionType("static", {
+        objectRids: objectSet.objects,
+        provenance: void 0
+      });
+    case "reference":
+      return conjureUnionType("referenced", {
+        objectSetRid: objectSet.reference
+      });
+    case "filter":
+      return conjureUnionType("filtered", {
+        objectSet: toConjureObjectSet(objectSet.objectSet, objectPropertyMapping),
+        runtimeDerivedProperties: void 0,
+        filter: mapWhereClauseToObjectSetFilter(objectSet.where, objectPropertyMapping)
+      });
+    case "union":
+      return conjureUnionType("unioned", {
+        objectSets: objectSet.objectSets.map((os) => toConjureObjectSet(os, objectPropertyMapping))
+      });
+    case "intersect":
+      return conjureUnionType("intersected", {
+        objectSets: objectSet.objectSets.map((os) => toConjureObjectSet(os, objectPropertyMapping))
+      });
+    case "subtract":
+      return conjureUnionType("subtracted", {
+        objectSets: objectSet.objectSets.map((os) => toConjureObjectSet(os, objectPropertyMapping))
+      });
+    case "searchAround":
+      throw new Error("not implemented");
+  }
+}
+async function getObjectSetBaseType(objectSet) {
+  switch (objectSet.type) {
+    case "base":
+      return objectSet.objectType;
+    case "static":
+      throw new Error("not implemented");
+    case "reference":
+      throw new Error("not implemented");
+    case "filter":
+      return getObjectSetBaseType(objectSet.objectSet);
+    case "union":
+      return getObjectSetBaseType(objectSet.objectSets[0]);
+    case "intersect":
+      return getObjectSetBaseType(objectSet.objectSets[0]);
+    case "subtract":
+      return getObjectSetBaseType(objectSet.objectSets[0]);
+    case "searchAround":
+      throw new Error("not implemented");
+  }
+}
+function mapWhereClauseToObjectSetFilter(objectSetFilter, propertyMapping) {
+  switch (objectSetFilter.type) {
+    case "lt":
+      return conjureUnionType("range", {
+        propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
+        lt: objectSetFilter.value,
+        lte: void 0,
+        gt: void 0,
+        gte: void 0
+      });
+    case "gt":
+      return conjureUnionType("range", {
+        propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
+        gt: objectSetFilter.value,
+        lte: void 0,
+        lt: void 0,
+        gte: void 0
+      });
+    case "lte":
+      return conjureUnionType("range", {
+        propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
+        lte: objectSetFilter.value,
+        lt: void 0,
+        gt: void 0,
+        gte: void 0
+      });
+    case "gte":
+      return conjureUnionType("range", {
+        propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
+        gte: objectSetFilter.value,
+        lt: void 0,
+        lte: void 0,
+        gt: void 0
+      });
+    case "eq":
+      return conjureUnionType("exactMatch", {
+        propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
+        terms: [objectSetFilter.value]
+      });
+    case "and":
+      return conjureUnionType("and", {
+        filters: objectSetFilter.value.map((filter) => mapWhereClauseToObjectSetFilter(filter, propertyMapping))
+      });
+    case "or":
+      return conjureUnionType("or", {
+        filters: objectSetFilter.value.map((filter) => mapWhereClauseToObjectSetFilter(filter, propertyMapping))
+      });
+    case "isNull":
+      return conjureUnionType("not", {
+        filter: {
+          type: "hasProperty",
+          hasProperty: {
+            propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field]
+          }
+        }
+      });
+    case "not":
+      return conjureUnionType("not", {
+        filter: mapWhereClauseToObjectSetFilter(objectSetFilter.value, propertyMapping)
+      });
+    case "contains":
+    case "startsWith":
+    case "containsAllTermsInOrder":
+    case "containsAnyTerm":
+    case "containsAllTerms":
+    case "withinDistanceOf":
+    case "withinBoundingBox":
+    case "intersectsBoundingBox":
+    case "doesNotIntersectBoundingBox":
+    case "withinPolygon":
+    case "intersectsPolygon":
+    case "doesNotIntersectPolygon":
+    case "containsAllTermsInOrderPrefixLastTerm":
+    case "in":
+      throw new Error("not implemented");
+  }
+}
+
+// src/objectSet/ObjectSetListenerWebsocket.ts
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var MINIMUM_RECONNECT_DELAY_MS = 5 * 1e3;
+function doNothing() {
+}
+function fillOutListener({
+  onChange = doNothing,
+  onError = doNothing,
+  onOutOfDate = doNothing
+}) {
+  return {
+    onChange,
+    onError,
+    onOutOfDate
+  };
+}
+function isReady(sub) {
+  return sub.temporaryObjectSetId != null;
+}
+function subscriptionIsDone(sub) {
+  return sub.status === "done" || sub.status === "error";
+}
+var ObjectSetListenerWebsocket = class _ObjectSetListenerWebsocket {
+  static #instances = /* @__PURE__ */ new WeakMap();
+  // FIXME
+  static getInstance(client) {
+    let instance = _ObjectSetListenerWebsocket.#instances.get(client.clientCacheKey);
+    if (instance == null) {
+      instance = new _ObjectSetListenerWebsocket(client);
+      _ObjectSetListenerWebsocket.#instances.set(client.clientCacheKey, instance);
+    }
+    return instance;
+  }
+  #ws;
+  #lastWsConnect = 0;
+  #client;
+  #logger;
+  /**
+   * map of requestId to all active subscriptions at the time of the request
+   */
+  #pendingSubscriptions = /* @__PURE__ */ new Map();
+  /**
+   * Map of subscriptionId to Subscription. Note: the subscriptionId may be
+   * temporary and not the actual subscriptionId from the server.
+   */
+  #subscriptions = /* @__PURE__ */ new Map();
+  #oswContext;
+  #metadataContext;
+  #ossContext;
+  #maybeDisconnectTimeout;
+  // DO NOT CONSTRUCT DIRECTLY. ONLY EXPOSED AS A TESTING SEAM
+  constructor(client, {
+    objectSetExpiryMs = ONE_DAY_MS,
+    minimumReconnectDelayMs = MINIMUM_RECONNECT_DELAY_MS
+  } = {}) {
+    this.OBJECT_SET_EXPIRY_MS = objectSetExpiryMs;
+    this.MINIMUM_RECONNECT_DELAY_MS = minimumReconnectDelayMs;
+    this.#client = client;
+    this.#logger = client.logger?.child({}, {
+      msgPrefix: "<OSW> "
+    });
+    !(client.baseUrl.startsWith("https://") || client.baseUrl.startsWith("http://")) ? process.env.NODE_ENV !== "production" ? invariant5(false, "Stack must be a URL") : invariant5(false) : void 0;
+    this.#oswContext = {
+      baseUrl: client.baseUrl,
+      servicePath: "/object-set-watcher/api",
+      fetchFn: client.fetch,
+      tokenProvider: async () => await client.tokenProvider()
+    };
+    this.#ossContext = {
+      ...this.#oswContext,
+      servicePath: "/object-set-service/api"
+    };
+    this.#metadataContext = {
+      ...this.#oswContext,
+      servicePath: "/ontology-metadata/api"
+    };
+  }
+  async subscribe(objectSet, listener) {
+    {
+      globalThis.crypto ??= (await import('crypto')).webcrypto;
+    }
+    const sub = {
+      listener: fillOutListener(listener),
+      objectSet,
+      status: "preparing",
+      // Since we don't have a real subscription id yet but we need to keep
+      // track of this reference, we can just use a random uuid.
+      subscriptionId: `TMP-${crypto.randomUUID()}`
+    };
+    this.#subscriptions.set(sub.subscriptionId, sub);
+    this.#initiateSubscribe(sub);
+    return () => {
+      this.#unsubscribe(sub);
+    };
+  }
+  /**
+   * Called at least once for every subscription.
+   *
+   * - Resets pending expiry
+   * - Recreates temporary object set
+   * - Triggers a full subscribe message
+   *
+   * @returns
+   */
+  async #initiateSubscribe(sub) {
+    if (process?.env?.NODE_ENV !== "production") {
+      this.#logger?.trace("#initiateSubscribe()");
+    }
+    if (sub.expiry) {
+      clearTimeout(sub.expiry);
+    }
+    sub.expiry = setTimeout(() => this.#expire(sub), this.OBJECT_SET_EXPIRY_MS);
+    const ontologyRid = await this.#client.ontologyRid;
+    try {
+      const [temporaryObjectSet] = await Promise.all([
+        // create a time-bounded object set representation for watching
+        this.#createTemporaryObjectSet(sub.objectSet),
+        this.#ensureWebsocket(),
+        // look up the object type's rid and ensure that we have enabled object set watcher for that rid
+        // TODO ???
+        getObjectSetBaseType(sub.objectSet).then((baseType) => esm_exports.ObjectTypesV2.getObjectTypeV2(this.#client, ontologyRid, baseType)).then((objectType) => this.#enableObjectSetsWatcher([objectType.rid]))
+      ]);
+      if (subscriptionIsDone(sub)) {
+        return;
+      }
+      sub.temporaryObjectSetId = temporaryObjectSet.objectSetRid;
+      if (this.#ws?.readyState === WebSocket.OPEN) {
+        this.#sendSubscribeMessage();
+      }
+    } catch (error) {
+      this.#logger?.error(error, "Error in #initiateSubscribe");
+      sub.listener.onError(error);
+    }
+  }
+  #sendSubscribeMessage() {
+    if (process?.env?.NODE_ENV !== "production") {
+      this.#logger?.trace("#sendSubscribeMessage()");
+    }
+    const readySubs = [...this.#subscriptions.values()].filter(isReady);
+    if (readySubs.length === 0) {
+      if (process?.env?.NODE_ENV !== "production") {
+        this.#logger?.trace("#sendSubscribeMessage(): aborting due to no ready subscriptions");
+      }
+      return;
+    }
+    const id = crypto.randomUUID();
+    this.#pendingSubscriptions.set(id, readySubs);
+    const subscribe = {
+      id,
+      requests: readySubs.map(({
+        temporaryObjectSetId
+      }) => ({
+        objectSet: temporaryObjectSetId,
+        objectSetContext: {
+          objectSetFilterContext: {
+            parameterOverrides: {}
+          }
+        },
+        watchAllLinks: false
+      }))
+    };
+    if (process?.env?.NODE_ENV !== "production") {
+      this.#logger?.trace({
+        payload: subscribe
+      }, "sending subscribe message");
+    }
+    this.#ws?.send(JSON.stringify(subscribe));
+  }
+  #expire(sub) {
+    if (process?.env?.NODE_ENV !== "production") {
+      this.#logger?.trace({
+        subscription: sub
+      }, "#expire()");
+    }
+    sub.status = "expired";
+    this.#initiateSubscribe(sub);
+  }
+  #unsubscribe(sub, newStatus = "done") {
+    if (subscriptionIsDone(sub)) {
+      return;
+    }
+    sub.status = newStatus;
+    sub.listener = fillOutListener({});
+    if (sub.expiry) {
+      clearTimeout(sub.expiry);
+      sub.expiry = void 0;
+    }
+    this.#subscriptions.delete(sub.subscriptionId);
+    if (this.#maybeDisconnectTimeout) {
+      clearTimeout(this.#maybeDisconnectTimeout);
+    }
+    this.#maybeDisconnectTimeout = setTimeout(
+      () => {
+        this.#maybeDisconnectTimeout = void 0;
+        if (this.#subscriptions.size === 0) {
+          this.#cycleWebsocket();
+        }
+      },
+      15e3
+      /* ms */
+    );
+  }
+  async #ensureWebsocket() {
+    if (this.#ws == null) {
+      const {
+        baseUrl,
+        tokenProvider
+      } = this.#client;
+      const base = new URL(baseUrl);
+      const url = `wss://${base.host}/object-set-watcher/ws/subscriptions`;
+      const token = await tokenProvider();
+      if (this.#ws == null) {
+        const nextConnectTime = (this.#lastWsConnect ?? 0) + this.MINIMUM_RECONNECT_DELAY_MS;
+        if (nextConnectTime > Date.now()) {
+          await new Promise((resolve) => {
+            setTimeout(resolve, nextConnectTime - Date.now());
+          });
+        }
+        this.#lastWsConnect = Date.now();
+        if (this.#ws == null) {
+          if (process?.env?.NODE_ENV !== "production") {
+            this.#logger?.trace("Creating websocket");
+          }
+          this.#ws = new WebSocket(url, [`Bearer-${token}`]);
+          this.#ws.addEventListener("close", this.#onClose);
+          this.#ws.addEventListener("message", this.#onMessage);
+          this.#ws.addEventListener("open", this.#onOpen);
+        }
+      }
+      if (this.#ws.readyState === WebSocket.CONNECTING) {
+        const ws = this.#ws;
+        return new Promise((resolve, reject) => {
+          function cleanup() {
+            ws.removeEventListener("open", open);
+            ws.removeEventListener("error", error);
+            ws.removeEventListener("close", cleanup);
+          }
+          function open() {
+            cleanup();
+            resolve();
+          }
+          function error(evt) {
+            cleanup();
+            reject(evt);
+          }
+          ws.addEventListener("open", open);
+          ws.addEventListener("error", error);
+          ws.addEventListener("close", cleanup);
+        });
+      }
+    }
+  }
+  #onOpen = () => {
+    this.#sendSubscribeMessage();
+  };
+  #onMessage = async (message) => {
+    const data = JSON.parse(message.data.toString());
+    if (process?.env?.NODE_ENV !== "production") {
+      this.#logger?.trace({
+        payload: data
+      }, "received message from ws");
+    }
+    switch (data.type) {
+      case "objectSetChanged":
+        return this.#handleMessage_objectSetChanged(data.objectSetChanged);
+      case "refreshObjectSet":
+        return this.#handleMessage_refreshObjectSet(data.refreshObjectSet);
+      case "subscribeResponses":
+        return this.#handleMessage_subscribeResponses(data.subscribeResponses);
+      case "subscriptionClosed": {
+        const payload = data.subscriptionClosed;
+        return this.#handleMessage_subscriptionClosed(payload);
+      }
+      default:
+        process.env.NODE_ENV !== "production" ? invariant5(false, "Unexpected message type") : invariant5(false) ;
+    }
+  };
+  #handleMessage_objectSetChanged = async (payload) => {
+    const sub = this.#subscriptions.get(payload.id);
+    !sub ? process.env.NODE_ENV !== "production" ? invariant5(false, `Expected subscription id ${payload.id}`) : invariant5(false) : void 0;
+    if ("confidenceValue" in payload) {
+      sub.listener.onOutOfDate();
+      return;
+    }
+    const objects = payload.updates.filter(function(a) {
+      return a.type === "object";
+    }).map((a) => a.object);
+    !(objects.length === payload.updates.length) ? process.env.NODE_ENV !== "production" ? invariant5(false, "currently only support full updates not reference updates") : invariant5(false) : void 0;
+    sub.listener.onChange(await convertFoundryToOsdkObjects(this.#client, this.#metadataContext, objects));
+  };
+  #handleMessage_refreshObjectSet = (payload) => {
+    const sub = this.#subscriptions.get(payload.id);
+    !sub ? process.env.NODE_ENV !== "production" ? invariant5(false, `Expected subscription id ${payload.id}`) : invariant5(false) : void 0;
+    sub.listener.onOutOfDate();
+  };
+  #handleMessage_subscribeResponses = (payload) => {
+    const {
+      id,
+      responses
+    } = payload;
+    const subs = this.#pendingSubscriptions.get(id);
+    !subs ? process.env.NODE_ENV !== "production" ? invariant5(false, `should have a pending subscription for ${id}`) : invariant5(false) : void 0;
+    this.#pendingSubscriptions.delete(id);
+    for (let i = 0; i < responses.length; i++) {
+      const sub = subs[i];
+      const response = responses[i];
+      switch (response.type) {
+        case "error":
+          sub.listener.onError(response.error);
+          this.#unsubscribe(sub, "error");
+          break;
+        case "qos":
+          this.#cycleWebsocket();
+          break;
+        case "success":
+          const shouldFireOutOfDate = sub.status === "expired" || sub.status === "reconnecting";
+          if (process?.env?.NODE_ENV !== "production") {
+            this.#logger?.trace({
+              shouldFireOutOfDate
+            }, "success");
+          }
+          sub.status = "subscribed";
+          if (sub.subscriptionId !== response.success.id) {
+            this.#subscriptions.delete(sub.subscriptionId);
+            sub.subscriptionId = response.success.id;
+            this.#subscriptions.set(sub.subscriptionId, sub);
+          }
+          if (shouldFireOutOfDate) sub.listener.onOutOfDate();
+          break;
+        default:
+          sub.listener.onError(response);
+      }
+    }
+  };
+  #handleMessage_subscriptionClosed(payload) {
+    const sub = this.#subscriptions.get(payload.id);
+    !sub ? process.env.NODE_ENV !== "production" ? invariant5(false, `Expected subscription id ${payload.id}`) : invariant5(false) : void 0;
+    sub.listener.onError(payload.error);
+    this.#unsubscribe(sub, "error");
+  }
+  #onClose = (event) => {
+    if (process?.env?.NODE_ENV !== "production") {
+      this.#logger?.trace({
+        event
+      }, "Received close event from ws", event);
+    }
+    this.#cycleWebsocket();
+  };
+  async #enableObjectSetsWatcher(objectTypeRids) {
+    return batchEnableWatcher(this.#oswContext, {
+      requests: objectTypeRids
+    });
+  }
+  async #createTemporaryObjectSet(objectSet) {
+    const objectSetBaseType = await getObjectSetBaseType(objectSet);
+    const mcc = await metadataCacheClient(this.#client);
+    const objectInfo = await mcc.forObjectByApiName(objectSetBaseType);
+    const propMapping = await objectInfo.getPropertyMapping();
+    const temporaryObjectSet = await createTemporaryObjectSet(this.#ossContext, {
+      objectSet: toConjureObjectSet(objectSet, propMapping),
+      timeToLive: "ONE_DAY",
+      // MUST keep in sync with the value for expiry in `#initiateSubscribe`.
+      objectSetFilterContext: {
+        parameterOverrides: {}
+      }
+    });
+    return {
+      objectSetRid: temporaryObjectSet.objectSetRid
+    };
+  }
+  #cycleWebsocket = () => {
+    if (this.#ws) {
+      this.#ws.removeEventListener("open", this.#onOpen);
+      this.#ws.removeEventListener("message", this.#onMessage);
+      this.#ws.removeEventListener("close", this.#onClose);
+      if (this.#ws.readyState !== WebSocket.CLOSING && this.#ws.readyState !== WebSocket.CLOSED) {
+        this.#ws.close();
+      }
+      this.#ws = void 0;
+    }
+    if (this.#subscriptions.size > 0) {
+      if (process?.env?.NODE_ENV !== "production") {
+        for (const s of this.#subscriptions.values()) {
+          !(s.status !== "done" && s.status !== "error") ? process.env.NODE_ENV !== "production" ? invariant5(false, "should not have done/error subscriptions still") : invariant5(false) : void 0;
+        }
+      }
+      for (const s of this.#subscriptions.values()) {
+        if (s.status === "subscribed") s.status = "reconnecting";
+      }
+      this.#ensureWebsocket();
+    }
+  };
+};
+async function convertFoundryToOsdkObjects(client, ctx, objects) {
+  const osdkObjects = await Promise.all(objects.map(async (object) => {
+    const propertyMapping = await (await (await metadataCacheClient(client)).forObjectByRid(object.type)).getPropertyMapping();
+    const convertedObject = Object.fromEntries([...Object.entries(object.properties).map(([key, value]) => {
+      return [propertyMapping?.propertyIdToApiNameMapping[key], value];
+    }), [propertyMapping?.propertyIdToApiNameMapping[Object.entries(object.key)[0][0]], Object.entries(object.key)[0][1]], ["__apiName", propertyMapping?.apiName], ["$apiName", propertyMapping?.apiName]]);
+    return convertedObject;
+  }));
+  return await convertWireToOsdkObjects(client, osdkObjects, void 0);
+}
+
 // src/objectSet/createObjectSet.ts
 function isObjectTypeDefinition(def) {
   return def.type === "object";
@@ -1420,12 +2116,13 @@ function createObjectSet(objectType, clientCtx, objectSet = {
         objectSets: [objectSet, ...objectSets.map((os) => objectSetDefinitions.get(os))]
       });
     },
-    asyncIter: async function* () {
+    asyncIter: async function* (args) {
       let $nextPageToken = void 0;
       do {
         const result = await fetchPageInternal(augmentRequestContext(clientCtx, (_) => ({
           finalMethodCall: "asyncIter"
         })), objectType, objectSet, {
+          ...args,
           $nextPageToken
         });
         $nextPageToken = result.nextPageToken;
@@ -1443,7 +2140,11 @@ function createObjectSet(objectType, clientCtx, objectSet = {
       return await fetchSingleWithErrors(augmentRequestContext(clientCtx, (_) => ({
         finalMethodCall: "fetchOneWithErrors"
       })), objectType, options, await createWithPk(clientCtx, objectType, objectSet, primaryKey));
-    } : void 0
+    } : void 0,
+    [__EXPERIMENTAL__NOT_SUPPORTED_YET_subscribe]: (listener) => {
+      const pendingSubscribe = ObjectSetListenerWebsocket.getInstance(clientCtx).subscribe(objectSet, listener);
+      return async () => (await pendingSubscribe)();
+    }
   };
   function createSearchAround(link) {
     return () => {
@@ -1607,7 +2308,7 @@ async function convertWireToOsdkObjects(client, objects, interfaceApiName, force
   const ret = [];
   for (const rawObj of objects) {
     const objectDef = await client.ontologyProvider.getObjectDefinition(rawObj.$apiName);
-    !objectDef ? process.env.NODE_ENV !== "production" ? invariant(false, `Missing definition for '${rawObj.$apiName}'`) : invariant(false) : void 0;
+    !objectDef ? process.env.NODE_ENV !== "production" ? invariant5(false, `Missing definition for '${rawObj.$apiName}'`) : invariant5(false) : void 0;
     let objProps;
     let conforming = true;
     if (ifaceDef && ifaceSelected) {
@@ -1799,590 +2500,6 @@ async function fetchObjectPage(client, objectType, args, objectSet) {
   });
 }
 
-// src/util/isOntologyObjectV2.ts
-function isOntologyObjectV2(o) {
-  return o && typeof o === "object" && typeof o.__apiName === "string" && o.__primaryKey != null;
-}
-
-// src/util/isOsdkObject.ts
-function isOsdkBaseObject(o) {
-  return o && typeof o === "object" && typeof o.$apiName === "string" && o.$primaryKey != null;
-}
-
-// src/util/toDataValue.ts
-async function toDataValue(value, client) {
-  if (value == null) {
-    return value;
-  }
-  if (Array.isArray(value) || value instanceof Set) {
-    const promiseArray = Array.from(value, async (innerValue) => await toDataValue(innerValue, client));
-    return Promise.all(promiseArray);
-  }
-  if (isAttachmentUpload(value)) {
-    const attachment = await esm_exports.Attachments.uploadAttachmentV2(client, value, {
-      filename: value.name
-    });
-    return await toDataValue(attachment.rid, client);
-  }
-  if (isOntologyObjectV2(value)) {
-    return await toDataValue(value.__primaryKey, client);
-  }
-  if (isOsdkBaseObject(value)) {
-    return await toDataValue(value.$primaryKey, client);
-  }
-  if (isWireObjectSet(value)) {
-    return value;
-  }
-  if (isObjectSet(value)) {
-    return getWireObjectSet(value);
-  }
-  if (typeof value === "object") {
-    return Object.entries(value).reduce(async (promisedAcc, [key, structValue]) => {
-      const acc = await promisedAcc;
-      acc[key] = await toDataValue(structValue, client);
-      return acc;
-    }, Promise.resolve({}));
-  }
-  return value;
-}
-
-// src/actions/applyAction.ts
-async function applyAction2(client, action, parameters, options = {}) {
-  const clientWithHeaders = addUserAgentAndRequestContextHeaders(augmentRequestContext(client, (_) => ({
-    finalMethodCall: "applyAction"
-  })), action);
-  if (Array.isArray(parameters)) {
-    const response = await esm_exports.Actions.applyActionBatchV2(clientWithHeaders, await client.ontologyRid, action.apiName, {
-      requests: parameters ? await remapBatchActionParams(parameters, client) : [],
-      options: {
-        returnEdits: options?.$returnEdits ? "ALL" : "NONE"
-      }
-    });
-    const edits = response.edits;
-    return options?.$returnEdits ? edits?.type === "edits" ? remapActionResponse(response) : edits : void 0;
-  } else {
-    const response = await esm_exports.Actions.applyActionV2(clientWithHeaders, await client.ontologyRid, action.apiName, {
-      parameters: await remapActionParams(parameters, client),
-      options: {
-        mode: options?.$validateOnly ? "VALIDATE_ONLY" : "VALIDATE_AND_EXECUTE",
-        returnEdits: options?.$returnEdits ? "ALL" : "NONE"
-      }
-    });
-    if (options?.$validateOnly) {
-      return response.validation;
-    }
-    if (response.validation?.result === "INVALID") {
-      throw new ActionValidationError(response.validation);
-    }
-    const edits = response.edits;
-    return options?.$returnEdits ? edits?.type === "edits" ? remapActionResponse(response) : edits : void 0;
-  }
-}
-async function remapActionParams(params, client) {
-  if (params == null) {
-    return {};
-  }
-  const parameterMap = {};
-  for (const [key, value] of Object.entries(params)) {
-    parameterMap[key] = await toDataValue(value, client);
-  }
-  return parameterMap;
-}
-async function remapBatchActionParams(params, client) {
-  const remappedParams = await Promise.all(params.map(async (param) => {
-    return {
-      parameters: await remapActionParams(param, client)
-    };
-  }));
-  return remappedParams;
-}
-function remapActionResponse(response) {
-  const editResponses = response?.edits;
-  if (editResponses?.type === "edits") {
-    const remappedActionResponse = {
-      type: editResponses.type,
-      deletedLinksCount: editResponses.deletedLinksCount,
-      deletedObjectsCount: editResponses.deletedObjectsCount,
-      addedLinks: [],
-      addedObjects: [],
-      modifiedObjects: [],
-      editedObjectTypes: []
-    };
-    const editedObjectTypesSet = /* @__PURE__ */ new Set();
-    for (const edit of editResponses.edits) {
-      if (edit.type === "addLink") {
-        remappedActionResponse.addedLinks.push({
-          linkTypeApiNameAtoB: edit.linkTypeApiNameAtoB,
-          linkTypeApiNameBtoA: edit.linkTypeApiNameBtoA,
-          aSideObject: edit.aSideObject,
-          bSideObject: edit.bSideObject
-        });
-        editedObjectTypesSet.add(edit.aSideObject.objectType);
-        editedObjectTypesSet.add(edit.bSideObject.objectType);
-      } else if (edit.type === "addObject") {
-        remappedActionResponse.addedObjects.push({
-          objectType: edit.objectType,
-          primaryKey: edit.primaryKey
-        });
-        editedObjectTypesSet.add(edit.objectType);
-      } else if (edit.type === "modifyObject") {
-        remappedActionResponse.modifiedObjects.push({
-          objectType: edit.objectType,
-          primaryKey: edit.primaryKey
-        });
-        editedObjectTypesSet.add(edit.objectType);
-      } else {
-        process.env.NODE_ENV !== "production" ? invariant(false, "Unknown edit type") : invariant(false) ;
-      }
-    }
-    remappedActionResponse.editedObjectTypes = [...editedObjectTypesSet];
-    return remappedActionResponse;
-  }
-}
-async function loadFullObjectMetadata(client, objectType) {
-  const full = await esm_exports.ObjectTypesV2.getObjectTypeFullMetadata(client, await client.ontologyRid, objectType, {
-    preview: true
-  });
-  const ret = wireObjectTypeFullMetadataToSdkObjectTypeDefinition(full, true);
-  client.logger?.debug(`END loadFullObjectMetadata(${objectType})`);
-  return {
-    ...ret,
-    rid: full.objectType.rid
-  };
-}
-async function loadInterfaceDefinition(client, objectType) {
-  const r = await esm_exports.OntologyInterfaces.getInterfaceType(client, await client.ontologyRid, objectType, {
-    preview: true
-  });
-  return __UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(r, true);
-}
-async function loadQueryDefinition(client, queryType) {
-  const r = await esm_exports.QueryTypes.getQueryTypeV2(client, await client.ontologyRid, queryType);
-  return wireQueryTypeV2ToSdkQueryDefinition(r);
-}
-
-// src/ontology/StandardOntologyProvider.ts
-var createStandardOntologyProviderFactory = (client) => {
-  return (client2) => {
-    async function loadObject(client3, key) {
-      let objectDef = await loadFullObjectMetadata(client3, key);
-      const interfaceDefs = Object.fromEntries((await Promise.all(objectDef.implements?.map((i) => ret.getInterfaceDefinition(i)) ?? [])).map((i) => [i.apiName, {
-        def: i,
-        handler: void 0
-      }]));
-      const fullObjectDef = {
-        ...objectDef,
-        [InterfaceDefinitions]: interfaceDefs
-      };
-      return fullObjectDef;
-    }
-    async function loadInterface(client3, key) {
-      return loadInterfaceDefinition(client3, key);
-    }
-    async function loadQuery(client3, key) {
-      const r = await loadQueryDefinition(client3, key);
-      return r;
-    }
-    function makeGetter(fn) {
-      const cache = createAsyncClientCache((client3, key) => fn(client3, key, false));
-      return async (apiName) => {
-        return await cache.get(client2, apiName);
-      };
-    }
-    const ret = {
-      getObjectDefinition: makeGetter(loadObject),
-      getInterfaceDefinition: makeGetter(loadInterface),
-      getQueryDefinition: makeGetter(loadQuery)
-    };
-    return ret;
-  };
-};
-
-// src/util/UserAgent.ts
-var USER_AGENT = `osdk-client/${"2.0.0-beta.11"}`;
-
-// src/createMinimalClient.ts
-function createMinimalClient(metadata, baseUrl, tokenProvider, options = {}, fetchFn = global.fetch, objectSetFactory = createObjectSet) {
-  if (process?.env?.NODE_ENV !== "production") {
-    try {
-      new URL(baseUrl);
-    } catch (e) {
-      const hint = !baseUrl.startsWith("http://") || !baseUrl.startsWith("https://") ? ". Did you forget to add 'http://' or 'https://'?" : "";
-      throw new Error(`Invalid stack URL: ${baseUrl}${hint}`);
-    }
-  }
-  const minimalClient = {
-    ...createSharedClientContext(baseUrl, tokenProvider, USER_AGENT, fetchFn),
-    objectSetFactory,
-    ontologyRid: metadata.ontologyRid,
-    logger: options.logger,
-    clientCacheKey: {},
-    requestContext: {}
-  };
-  return Object.assign(minimalClient, {
-    ontologyProvider: createStandardOntologyProviderFactory()(minimalClient)
-  });
-}
-
-// src/fetchMetadata.ts
-var fetchMetadataInternal = async (client, definition) => {
-  if (definition.type === "object") {
-    return fetchObjectMetadata(client, definition);
-  } else if (definition.type === "interface") {
-    return fetchInterfaceMetadata(client, definition);
-  } else if (definition.type === "action") {
-    return fetchActionMetadata(client, definition);
-  } else if (definition.type === "query") {
-    return fetchQueryMetadata(client, definition);
-  } else {
-    throw new Error("Not implemented for given definition");
-  }
-};
-var fetchObjectMetadata = async (client, objectType) => {
-  const response = await esm_exports.ObjectTypesV2.getObjectTypeFullMetadata(addUserAgentAndRequestContextHeaders(client, objectType), await client.ontologyRid, objectType.apiName, {
-    preview: true
-  });
-  const supportedIconTypes = ["blueprint"];
-  return {
-    description: response.objectType.description,
-    displayName: response.objectType.displayName,
-    visibility: response.objectType.visibility,
-    pluralDisplayName: response.objectType.pluralDisplayName,
-    icon: supportedIconTypes.includes(response.objectType.icon.type) ? response.objectType.icon : void 0,
-    rid: response.objectType.rid
-  };
-};
-var fetchInterfaceMetadata = async (client, interfaceType) => {
-  const response = await esm_exports.OntologyInterfaces.getInterfaceType(addUserAgentAndRequestContextHeaders(client, interfaceType), await client.ontologyRid, interfaceType.apiName, {
-    preview: true
-  });
-  return {
-    displayName: response.displayName,
-    description: response.description,
-    rid: response.rid
-  };
-};
-var fetchActionMetadata = async (client, actionType) => {
-  const response = await esm_exports.ActionTypesV2.getActionTypeV2(addUserAgentAndRequestContextHeaders(client, actionType), await client.ontologyRid, actionType.apiName);
-  return {
-    displayName: response.displayName,
-    description: response.description,
-    rid: response.rid
-  };
-};
-var fetchQueryMetadata = async (client, queryType) => {
-  const response = await esm_exports.QueryTypes.getQueryTypeV2(addUserAgentAndRequestContextHeaders(client, queryType), await client.ontologyRid, queryType.apiName);
-  return {
-    displayName: response.displayName,
-    description: response.description,
-    rid: response.rid
-  };
-};
-
-// src/util/isOsdkBaseObject.ts
-function isOsdkBaseObject2(o) {
-  return o && typeof o === "object" && typeof o.$apiName === "string" && o.$primaryKey != null;
-}
-
-// src/util/toDataValueQueries.ts
-async function toDataValueQueries(value, client, desiredType) {
-  if (value == null) {
-    return value;
-  }
-  if (Array.isArray(value) && desiredType.multiplicity) {
-    const promiseArray = Array.from(value, async (innerValue) => await toDataValueQueries(innerValue, client, desiredType));
-    return Promise.all(promiseArray);
-  }
-  switch (desiredType.type) {
-    case "attachment": {
-      if (isAttachmentUpload(value)) {
-        const attachment = await esm_exports.Attachments.uploadAttachmentV2(client, value, {
-          filename: value.name
-        });
-        return attachment.rid;
-      }
-      return value;
-    }
-    case "twoDimensionalAggregation": {
-      return {
-        groups: value
-      };
-    }
-    case "threeDimensionalAggregation": {
-      return {
-        groups: value
-      };
-    }
-    case "set": {
-      if (value instanceof Set) {
-        const promiseArray = Array.from(value, async (innerValue) => await toDataValueQueries(innerValue, client, desiredType["set"]));
-        return Promise.all(promiseArray);
-      }
-      break;
-    }
-    case "object": {
-      if (isOsdkBaseObject2(value)) {
-        return value.$primaryKey;
-      }
-      break;
-    }
-    case "objectSet": {
-      if (isWireObjectSet(value)) {
-        return value;
-      }
-      if (isObjectSet(value)) {
-        return getWireObjectSet(value);
-      }
-      break;
-    }
-    case "struct": {
-      if (typeof value === "object") {
-        const structMap = {};
-        for (const [key, structValue] of Object.entries(value)) {
-          structMap[key] = await toDataValueQueries(structValue, client, desiredType["struct"][key]);
-        }
-        return structMap;
-      }
-    }
-    case "boolean":
-    case "date":
-    case "double":
-    case "float":
-    case "integer":
-    case "long":
-    case "string":
-    case "timestamp":
-      return value;
-  }
-  return value;
-}
-
-// src/queries/applyQuery.ts
-async function applyQuery(client, query, params) {
-  const qd = await client.ontologyProvider.getQueryDefinition(query.apiName);
-  const response = await esm_exports.Queries.executeQueryV2(addUserAgentAndRequestContextHeaders(augmentRequestContext(client, (_) => ({
-    finalMethodCall: "applyQuery"
-  })), query), await client.ontologyRid, query.apiName, {
-    parameters: params ? await remapQueryParams(params, client, qd.parameters) : {}
-  });
-  const objectOutputDefs = await getRequiredDefinitions(qd.output, client);
-  const remappedResponse = await remapQueryResponse(client, qd.output, response.value, objectOutputDefs);
-  return remappedResponse;
-}
-async function remapQueryParams(params, client, paramTypes) {
-  const parameterMap = {};
-  for (const [key, value] of Object.entries(params)) {
-    parameterMap[key] = await toDataValueQueries(value, client, paramTypes[key]);
-  }
-  return parameterMap;
-}
-async function remapQueryResponse(client, responseDataType, responseValue, definitions) {
-  if (responseValue == null) {
-    if (responseDataType.nullable) {
-      return void 0;
-    } else {
-      throw new Error("Got null response when nullable was not allowed");
-    }
-  }
-  if (responseDataType.multiplicity != null && responseDataType.multiplicity !== false) {
-    const withoutMultiplicity = {
-      ...responseDataType,
-      multiplicity: false
-    };
-    for (let i = 0; i < responseValue.length; i++) {
-      responseValue[i] = await remapQueryResponse(responseValue[i], withoutMultiplicity, client, definitions);
-    }
-    return responseValue;
-  }
-  switch (responseDataType.type) {
-    case "union": {
-      throw new Error("Union return types are not yet supported");
-    }
-    case "set": {
-      for (let i = 0; i < responseValue.length; i++) {
-        responseValue[i] = await remapQueryResponse(responseValue[i], responseDataType.set, client, definitions);
-      }
-      return responseValue;
-    }
-    case "attachment": {
-      return createAttachmentFromRid(client, responseValue);
-    }
-    case "object": {
-      const def = definitions.get(responseDataType.object);
-      if (!def) {
-        throw new Error(`Missing definition for ${responseDataType.object}`);
-      }
-      return createQueryObjectResponse(responseValue, def);
-    }
-    case "objectSet": {
-      const def = definitions.get(responseDataType.objectSet);
-      if (!def) {
-        throw new Error(`Missing definition for ${responseDataType.objectSet}`);
-      }
-      if (typeof responseValue === "string") {
-        return createObjectSet(def, client, {
-          type: "intersect",
-          objectSets: [{
-            type: "base",
-            objectType: responseDataType.objectSet
-          }, {
-            type: "reference",
-            reference: responseValue
-          }]
-        });
-      }
-      return createObjectSet(def, client, responseValue);
-    }
-    case "struct": {
-      for (const [key, subtype] of Object.entries(responseDataType.struct)) {
-        if (requiresConversion(subtype)) {
-          responseValue[key] = await remapQueryResponse(responseValue[key], subtype, client, definitions);
-        }
-      }
-      return responseValue;
-    }
-    case "twoDimensionalAggregation": {
-      const result = [];
-      for (const {
-        key,
-        value
-      } of responseValue.groups) {
-        result.push({
-          key,
-          value
-        });
-      }
-      return result;
-    }
-    case "threeDimensionalAggregation": {
-      const result = [];
-      for (const {
-        key,
-        groups
-      } of responseValue.groups) {
-        const subResult = [];
-        for (const {
-          key: subKey,
-          value
-        } of groups) {
-          subResult.push({
-            key: subKey,
-            value
-          });
-        }
-        result.push({
-          key,
-          groups: subResult
-        });
-      }
-      return result;
-    }
-  }
-  return responseValue;
-}
-async function getRequiredDefinitions(dataType, client) {
-  const result = /* @__PURE__ */ new Map();
-  switch (dataType.type) {
-    case "objectSet": {
-      const objectDef = await client.ontologyProvider.getObjectDefinition(dataType.objectSet);
-      result.set(dataType.objectSet, objectDef);
-      break;
-    }
-    case "object": {
-      const objectDef = await client.ontologyProvider.getObjectDefinition(dataType.object);
-      result.set(dataType.object, objectDef);
-      break;
-    }
-    case "set": {
-      return getRequiredDefinitions(dataType.set, client);
-    }
-    case "struct": {
-      for (const value of Object.values(dataType.struct)) {
-        for (const [type, objectDef] of await getRequiredDefinitions(value, client)) {
-          result.set(type, objectDef);
-        }
-      }
-      break;
-    }
-  }
-  return result;
-}
-function requiresConversion(dataType) {
-  switch (dataType.type) {
-    case "boolean":
-    case "date":
-    case "double":
-    case "float":
-    case "integer":
-    case "long":
-    case "object":
-    case "string":
-    case "timestamp":
-      return false;
-    case "union":
-      return true;
-    case "struct":
-      return Object.values(dataType.struct).some(requiresConversion);
-    case "set":
-      return requiresConversion(dataType.set);
-    case "attachment":
-    case "objectSet":
-    case "twoDimensionalAggregation":
-    case "threeDimensionalAggregation":
-      return true;
-    default:
-      return false;
-  }
-}
-function createQueryObjectResponse(primaryKey, objectDef) {
-  return {
-    $apiName: objectDef.apiName,
-    $title: void 0,
-    $objectType: objectDef.apiName,
-    $primaryKey: primaryKey
-  };
-}
-
-// src/createClient.ts
-var ActionInvoker = class {
-  constructor(clientCtx, actionDef) {
-    this.applyAction = applyAction2.bind(void 0, clientCtx, actionDef);
-    this.batchApplyAction = applyAction2.bind(void 0, clientCtx, actionDef);
-  }
-};
-var QueryInvoker = class {
-  constructor(clientCtx, queryDef) {
-    this.executeFunction = applyQuery.bind(void 0, clientCtx, queryDef);
-  }
-};
-function createClientInternal(objectSetFactory, baseUrl, ontologyRid, tokenProvider, options = void 0, fetchFn = fetch) {
-  const clientCtx = createMinimalClient({
-    ontologyRid
-  }, baseUrl, tokenProvider, options, fetchFn, objectSetFactory);
-  function clientFn(o) {
-    if (o.type === "object" || o.type === "interface") {
-      return objectSetFactory(o, clientCtx);
-    } else if (o.type === "action") {
-      return new ActionInvoker(clientCtx, o);
-    } else if (o.type === "query") {
-      return new QueryInvoker(clientCtx, o);
-    } else {
-      throw new Error("not implemented");
-    }
-  }
-  const fetchMetadata = fetchMetadataInternal.bind(void 0, clientCtx);
-  const client = Object.defineProperties(clientFn, {
-    [symbolClientContext]: {
-      value: clientCtx
-    },
-    fetchMetadata: {
-      value: fetchMetadata
-    }
-  });
-  return client;
-}
-var createClient = createClientInternal.bind(void 0, createObjectSet);
-
-export { ActionValidationError, USER_AGENT, augment, convertWireToOsdkObjects, createAttachmentFromRid, createAttachmentUpload, createClient, createClientInternal, createObjectSet, createSimpleAsyncCache, esm_exports };
-//# sourceMappingURL=chunk-WGFCR4UM.js.map
-//# sourceMappingURL=chunk-WGFCR4UM.js.map
+export { InterfaceDefinitions, addUserAgentAndRequestContextHeaders, augment, augmentRequestContext, conjureUnionType, createAsyncClientCache, createAttachmentFromRid, createObjectSet, esm_exports, getWireObjectSet, isObjectSet, isWireObjectSet, makeConjureContext, metadataCacheClient };
+//# sourceMappingURL=chunk-MQTCPUPF.js.map
+//# sourceMappingURL=chunk-MQTCPUPF.js.map