@osdk/client 0.14.0 → 0.15.0

package/build/js/index.mjs

@@ -1,11 +1,1363 @@
-import { createObjectSet, createAsyncCache, isAttachment, isWireObjectSet, isObjectSet, getWireObjectSet, loadAllOntologies, loadOntologyEntities } from './chunk-Y7UBQD5N.mjs';
-export { object_exports as Objects, augment } from './chunk-Y7UBQD5N.mjs';
-import { applyActionV2, getObjectTypeV2, listInterfaceTypes, getInterfaceType, listOutgoingLinkTypesV2 } from '@osdk/gateway/requests';
-import { createClientContext, createOpenApiRequest } from '@osdk/shared.net';
+import { createClientContext, createOpenApiRequest, PalantirApiError } from '@osdk/shared.net';
 export { createClientContext, isOk } from '@osdk/shared.net';
+import { loadObjectSetV2, aggregateObjectSetV2, getObjectTypeV2, searchObjectsForInterface, applyActionV2, listInterfaceTypes, getInterfaceType, listOutgoingLinkTypesV2 } from '@osdk/gateway/requests';
+import invariant2 from 'tiny-invariant';
+import WebSocket from 'isomorphic-ws';
+import { conjureFetch } from 'conjure-lite';
 import { wireObjectTypeFullMetadataToSdkObjectTypeDefinition, __UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition } from '@osdk/generator-converters';
 import deepEqual from 'fast-deep-equal';
-import invariant from 'tiny-invariant';
+
+// src/index.ts
+
+// src/actions/ActionValidationError.ts
+var ActionValidationError = class extends Error {
+  constructor(validation) {
+    super("Validation Error");
+    this.validation = validation;
+  }
+};
+
+// src/object/Attachment.ts
+var Attachment = class {
+  constructor(rid) {
+    this.rid = rid;
+  }
+};
+function isAttachment(o) {
+  return o instanceof Attachment;
+}
+function legacyToModernSingleAggregationResult(entry) {
+  return entry.metrics.reduce((accumulator, curValue) => {
+    const parts = curValue.name.split(".");
+    if (parts[0] === "count") {
+      return accumulator;
+    }
+    !(parts.length === 2) ? process.env.NODE_ENV !== "production" ? invariant2(false, "assumed we were getting a `${key}.${type}`") : invariant2(false) : void 0;
+    if (!(parts[0] in accumulator)) {
+      accumulator[parts[0]] = {};
+    }
+    accumulator[parts[0]][parts[1]] = curValue.value;
+    return accumulator;
+  }, {});
+}
+
+// src/internal/conversions/modernToLegacyAggregationClause.ts
+function modernToLegacyAggregationClause(select) {
+  return Object.entries(select).flatMap(([k, v]) => {
+    if (k === "$count") {
+      if (v)
+        return {
+          type: "count",
+          name: "count"
+        };
+      return [];
+    } else if (Array.isArray(v)) {
+      return v.map((v2) => {
+        return {
+          type: v2,
+          name: `${k}.${v2}`,
+          field: k
+        };
+      });
+    } else {
+      return [{
+        type: v,
+        // FIXME v has additional possible values
+        name: `${k}.${v}`,
+        field: k
+      }];
+    }
+  });
+}
+
+// src/query/aggregations/GroupByClause.ts
+var DurationMapping = {
+  "sec": "SECONDS",
+  "seconds": "SECONDS",
+  "min": "MINUTES",
+  "minute": "MINUTES",
+  "minutes": "MINUTES",
+  "hr": "HOURS",
+  "hrs": "HOURS",
+  "hour": "HOURS",
+  "hours": "HOURS",
+  "day": "DAYS",
+  "days": "DAYS",
+  "wk": "WEEKS",
+  "week": "WEEKS",
+  "weeks": "WEEKS",
+  "mos": "MONTHS",
+  "month": "MONTHS",
+  "months": "MONTHS",
+  "yr": "YEARS",
+  "year": "YEARS",
+  "years": "YEARS",
+  "quarter": "QUARTERS",
+  "quarters": "QUARTERS"
+};
+
+// src/internal/conversions/modernToLegacyGroupByClause.ts
+function modernToLegacyGroupByClause(groupByClause) {
+  if (!groupByClause)
+    return [];
+  return Object.entries(groupByClause).flatMap(([field, type]) => {
+    if (type === "exact") {
+      return [{
+        type,
+        field
+      }];
+    } else if ("exactWithLimit" in type) {
+      {
+        return [{
+          type: "exact",
+          field,
+          maxGroupCount: type.exactWithLimit
+        }];
+      }
+    } else if ("fixedWidth" in type) {
+      return [{
+        type: "fixedWidth",
+        field,
+        fixedWidth: type.fixedWidth
+      }];
+    } else if ("ranges" in type) {
+      return [{
+        type: "ranges",
+        field,
+        ranges: type.ranges.map((range) => convertRange(range))
+      }];
+    } else if ("duration" in type) {
+      return [{
+        type: "duration",
+        field,
+        value: type.duration[0],
+        unit: DurationMapping[type.duration[1]]
+      }];
+    } else
+      return [];
+  });
+}
+function convertRange(range) {
+  return {
+    startValue: range[0],
+    endValue: range[1]
+  };
+}
+
+// src/query/WhereClause.ts
+var DistanceUnitMapping = {
+  "centimeter": "CENTIMETERS",
+  "centimeters": "CENTIMETERS",
+  "cm": "CENTIMETERS",
+  "meter": "METERS",
+  "meters": "METERS",
+  "m": "METERS",
+  "kilometer": "KILOMETERS",
+  "kilometers": "KILOMETERS",
+  "km": "KILOMETERS",
+  "inch": "INCHES",
+  "inches": "INCHES",
+  "foot": "FEET",
+  "feet": "FEET",
+  "yard": "YARDS",
+  "yards": "YARDS",
+  "mile": "MILES",
+  "miles": "MILES",
+  "nautical_mile": "NAUTICAL_MILES",
+  "nauticalMile": "NAUTICAL_MILES",
+  "nautical miles": "NAUTICAL_MILES"
+};
+
+// src/internal/conversions/modernToLegacyWhereClause.ts
+function modernToLegacyWhereClause(whereClause) {
+  if ("$and" in whereClause) {
+    return {
+      type: "and",
+      value: whereClause.$and.map(modernToLegacyWhereClause)
+    };
+  } else if ("$or" in whereClause) {
+    return {
+      type: "or",
+      value: whereClause.$or.map(modernToLegacyWhereClause)
+    };
+  } else if ("$not" in whereClause) {
+    return {
+      type: "not",
+      value: modernToLegacyWhereClause(whereClause.$not)
+    };
+  }
+  const parts = Object.entries(whereClause);
+  if (parts.length === 1) {
+    return handleWherePair(parts[0]);
+  }
+  return {
+    type: "and",
+    value: parts.map(handleWherePair)
+  };
+}
+function makeGeoFilterBbox(field, bbox, filterType) {
+  return {
+    type: filterType === "$within" ? "withinBoundingBox" : "intersectsBoundingBox",
+    field,
+    value: {
+      topLeft: {
+        type: "Point",
+        coordinates: [bbox[0], bbox[3]]
+      },
+      bottomRight: {
+        type: "Point",
+        coordinates: [bbox[2], bbox[1]]
+      }
+    }
+  };
+}
+function makeGeoFilterPolygon(field, coordinates, filterType) {
+  return {
+    type: filterType,
+    field,
+    value: {
+      type: "Polygon",
+      coordinates
+    }
+  };
+}
+function handleWherePair([field, filter]) {
+  !(filter != null) ? process.env.NODE_ENV !== "production" ? invariant2(false, "Defined key values are only allowed when they are not undefined.") : invariant2(false) : void 0;
+  if (typeof filter === "string" || typeof filter === "number" || typeof filter === "boolean") {
+    return {
+      type: "eq",
+      field,
+      value: filter
+    };
+  }
+  const keysOfFilter = Object.keys(filter);
+  const hasDollarSign = keysOfFilter.some((key) => key.startsWith("$"));
+  !(!hasDollarSign || keysOfFilter.length === 1) ? process.env.NODE_ENV !== "production" ? invariant2(false, "WhereClause Filter with multiple clauses isn't allowed") : invariant2(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" ? invariant2(false) : invariant2(false) : void 0;
+  if (firstKey === "$ne") {
+    return {
+      type: "not",
+      value: {
+        type: "eq",
+        field,
+        value: filter[firstKey]
+      }
+    };
+  }
+  if (firstKey === "$within") {
+    const withinBody = filter[firstKey];
+    if (Array.isArray(withinBody)) {
+      return makeGeoFilterBbox(field, withinBody, firstKey);
+    } else if ("bbox" in withinBody && !("type" in withinBody)) {
+      return makeGeoFilterBbox(field, withinBody.bbox, firstKey);
+    } else if ("distance" in withinBody && "of" in withinBody) {
+      return {
+        type: "withinDistanceOf",
+        field,
+        value: {
+          center: Array.isArray(withinBody.of) ? {
+            type: "Point",
+            coordinates: withinBody.of
+          } : withinBody.of,
+          distance: {
+            value: withinBody.distance[0],
+            unit: DistanceUnitMapping[withinBody.distance[1]]
+          }
+        }
+      };
+    } else {
+      const coordinates = "polygon" in withinBody ? withinBody.polygon : withinBody.coordinates;
+      return makeGeoFilterPolygon(field, coordinates, "withinPolygon");
+    }
+  }
+  if (firstKey === "$intersects") {
+    const intersectsBody = filter[firstKey];
+    if (Array.isArray(intersectsBody)) {
+      return makeGeoFilterBbox(field, intersectsBody, firstKey);
+    } else if ("bbox" in intersectsBody && !("type" in intersectsBody)) {
+      return makeGeoFilterBbox(field, intersectsBody.bbox, firstKey);
+    } else {
+      const coordinates = "polygon" in intersectsBody ? intersectsBody.polygon : intersectsBody.coordinates;
+      return makeGeoFilterPolygon(field, coordinates, "intersectsPolygon");
+    }
+  }
+  return {
+    type: firstKey.substring(1),
+    field,
+    value: filter[firstKey]
+  };
+}
+
+// src/object/Cache.ts
+function createCache(fn) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  function get(client, key) {
+    if (cache.get(client) == null) {
+      cache.set(client, /* @__PURE__ */ new Map());
+    }
+    let r = cache.get(client).get(key);
+    if (r === void 0 && fn !== void 0) {
+      return set(client, key, fn(client, key));
+    } else {
+      return r;
+    }
+  }
+  function set(client, key, value) {
+    if (cache.get(client) == null) {
+      cache.set(client, /* @__PURE__ */ new Map());
+    }
+    cache.get(client).set(key, value);
+    return value;
+  }
+  function remove(client, key) {
+    if (cache.get(client) == null)
+      return false;
+    return cache.get(client).delete(key);
+  }
+  return {
+    get,
+    set,
+    remove
+  };
+}
+function createAsyncCache(fn, createCacheLocal = createCache) {
+  const cache = createCacheLocal();
+  const inProgress = createCacheLocal();
+  const ret = {
+    getOrUndefined: function getOrUndefined(client, key) {
+      return cache.get(client, key);
+    },
+    get: async function get(client, key) {
+      return cache.get(client, key) ?? inProgress.get(client, key) ?? ret.set(client, key, fn(client, key));
+    },
+    set: async function set(client, k, v) {
+      try {
+        const r = await inProgress.set(client, k, v);
+        cache.set(client, k, r);
+        inProgress.remove(client, k);
+        return r;
+      } catch (e) {
+        inProgress.remove(client, k);
+        throw e;
+      }
+    }
+  };
+  return ret;
+}
+function augment(type, ...properties) {
+  return {
+    [type.apiName]: properties
+  };
+}
+function objectSetToSearchJsonV2(objectSet, expectedApiName, existingWhere = void 0) {
+  if (objectSet.type === "base") {
+    if (objectSet.objectType !== expectedApiName) {
+      throw new Error(`Expected objectSet.objectType to be ${expectedApiName}, but got ${objectSet.objectType}`);
+    }
+    return existingWhere;
+  }
+  if (objectSet.type === "filter") {
+    return objectSetToSearchJsonV2(objectSet.objectSet, expectedApiName, existingWhere == null ? objectSet.where : {
+      type: "and",
+      value: [existingWhere, objectSet.where]
+    });
+  }
+  throw new Error(`Unsupported objectSet type: ${objectSet.type}`);
+}
+async function fetchInterfacePage(client, interfaceType, args, objectSet) {
+  const result = await searchObjectsForInterface(createOpenApiRequest(client.stack, client.fetch), client.ontology.metadata.ontologyApiName, interfaceType.apiName, applyFetchArgs(args, {
+    augmentedProperties: args.augment ?? {},
+    augmentedSharedPropertyTypes: {},
+    otherInterfaceTypes: [],
+    selectedObjectTypes: [],
+    selectedSharedPropertyTypes: args.select ?? [],
+    where: objectSetToSearchJsonV2(objectSet, interfaceType.apiName)
+  }), {
+    preview: true
+  });
+  result.data = await convertWireToOsdkObjects(
+    client,
+    result.data,
+    // drop readonly
+    interfaceType.apiName,
+    !args.includeRid
+  );
+  return result;
+}
+async function fetchPageInternal(client, objectType, objectSet, args = {}) {
+  if (objectType.type === "interface") {
+    return await fetchInterfacePage(client, objectType, args, objectSet);
+  } else {
+    return await fetchObjectPage(client, objectType, args, objectSet);
+  }
+}
+async function fetchPageWithErrorsInternal(client, objectType, objectSet, args = {}) {
+  try {
+    const result = await fetchPageInternal(client, objectType, objectSet, args);
+    return {
+      value: result
+    };
+  } catch (e) {
+    if (e instanceof Error) {
+      return {
+        error: e
+      };
+    }
+    return {
+      error: e
+    };
+  }
+}
+async function fetchPage(client, objectType, args, objectSet = {
+  type: "base",
+  objectType: objectType["apiName"]
+}) {
+  return fetchPageInternal(client, objectType, objectSet, args);
+}
+function applyFetchArgs(args, body) {
+  if (args?.nextPageToken) {
+    body.pageToken = args.nextPageToken;
+  }
+  if (args?.pageSize != null) {
+    body.pageSize = args.pageSize;
+  }
+  if (args?.orderBy != null) {
+    body.orderBy = {
+      fields: Object.entries(args.orderBy).map(([field, direction]) => ({
+        field,
+        direction
+      }))
+    };
+  }
+  return body;
+}
+async function fetchObjectPage(client, objectType, args, objectSet) {
+  const r = await loadObjectSetV2(createOpenApiRequest(client.stack, client.fetch), client.ontology.metadata.ontologyApiName, applyFetchArgs(args, {
+    objectSet,
+    // We have to do the following case because LoadObjectSetRequestV2 isnt readonly
+    select: args?.select ?? [],
+    // FIXME?
+    excludeRid: !args?.includeRid
+  }));
+  return Promise.resolve({
+    data: await convertWireToOsdkObjects(client, r.data, void 0),
+    nextPageToken: r.nextPageToken
+  });
+}
+
+// src/object/fetchSingle.ts
+async function fetchSingle(client, objectType, args, objectSet) {
+  const result = await fetchPage(client, objectType, {
+    ...args,
+    pageSize: 1
+  }, objectSet);
+  if (result.data.length !== 1 || result.nextPageToken != null) {
+    throw new PalantirApiError(`Expected a single result but got ${result.data.length} instead${result.nextPageToken != null ? " with nextPageToken set" : ""}`);
+  }
+  return result.data[0];
+}
+
+// src/object/convertWireToOsdkObjects.ts
+var OriginClient = Symbol();
+var UnderlyingObject = Symbol();
+var InterfaceDefinitions = Symbol();
+var LinkFetcherProxyHandler = class {
+  constructor(objDef, primaryKey, client) {
+    this.objDef = objDef;
+    this.primaryKey = primaryKey;
+    this.client = client;
+  }
+  get(_target, p) {
+    const linkDef = this.objDef.links[p];
+    if (linkDef == null) {
+      return;
+    }
+    const objectSet = createObjectSet(this.objDef, this.client).where({
+      [this.objDef.primaryKeyApiName]: this.primaryKey
+    }).pivotTo(p);
+    if (!linkDef.multiplicity) {
+      return {
+        get: (options) => fetchSingle(this.client, this.objDef, options ?? {}, getWireObjectSet(objectSet))
+      };
+    } else {
+      return objectSet;
+    }
+  }
+  ownKeys() {
+    return Object.keys(this.objDef.links);
+  }
+  getOwnPropertyDescriptor(target, p) {
+    return {
+      enumerable: true,
+      configurable: true,
+      get: () => {
+        return this.get(target, p);
+      }
+    };
+  }
+};
+function createPrototype(objDef, client) {
+  if (process.env.NODE_ENV !== "production") {
+    !(objDef.type === "object") ? process.env.NODE_ENV !== "production" ? invariant2(false, "Expected object definition") : invariant2(false) : void 0;
+  }
+  const sharedPropertyDefs = {
+    $as: {
+      value: $as
+    }
+  };
+  const interfaceProto = Object.defineProperties({}, sharedPropertyDefs);
+  const objectProto = Object.defineProperties({}, {
+    $link: {
+      get: function() {
+        return new Proxy({}, new LinkFetcherProxyHandler(objDef, this["$primaryKey"], client));
+      }
+    },
+    ...sharedPropertyDefs
+  });
+  function $as(newDef) {
+    if (typeof newDef === "string") {
+      if (newDef === objDef.apiName) {
+        return this[UnderlyingObject];
+      }
+      const def = objDef[InterfaceDefinitions][newDef];
+      if (!def) {
+        throw new Error(`Object does not implement interface '${newDef}'.`);
+      }
+      newDef = def;
+    } else if (newDef.apiName === objDef.apiName) {
+      return this[UnderlyingObject];
+    }
+    if (newDef.type !== "interface" && newDef.apiName !== this.$apiName) {
+      throw new Error(`'${newDef.apiName}' is not an interface of '${this.$objectType}'.`);
+    }
+    const underlying = this[UnderlyingObject];
+    const common = {
+      enumerable: true,
+      configurable: true
+    };
+    return Object.create(interfaceProto, {
+      $apiName: {
+        value: newDef.apiName,
+        ...common
+      },
+      $objectType: {
+        value: objDef.apiName,
+        ...common
+      },
+      $primaryKey: {
+        value: this["$primaryKey"],
+        ...common
+      },
+      ...Object.fromEntries(Object.keys(newDef.properties).map((p) => {
+        const value = underlying[objDef.spts[p]];
+        return [p, {
+          value,
+          enumerable: value !== void 0
+        }];
+      })),
+      [UnderlyingObject]: {
+        value: underlying
+      }
+    });
+  }
+  return objectProto;
+}
+function createConverter(objDef) {
+  const steps = [];
+  for (const [key, value] of Object.entries(objDef.properties)) {
+    if (value.type === "attachment") {
+      steps.push((o) => {
+        if (o[key] != null) {
+          if (Array.isArray(o[key])) {
+            o[key] = o[key].map((a) => new Attachment(a.rid));
+          } else {
+            o[key] = new Attachment(o[key].rid);
+          }
+        }
+      });
+    }
+  }
+  return steps.length > 0 ? (o) => {
+    for (const step of steps) {
+      step(o);
+    }
+  } : void 0;
+}
+var protoConverterCache = createCache((client, objectDef) => {
+  const proto = createPrototype(objectDef, client);
+  const converter = createConverter(objectDef);
+  return [proto, converter];
+});
+async function convertWireToOsdkObjects(client, objects, interfaceApiName, forceRemoveRid = false) {
+  if (forceRemoveRid) {
+    for (const obj of objects) {
+      delete obj.__rid;
+    }
+  }
+  fixObjectPropertiesInline(objects);
+  const localObjectCache = createLocalObjectCacheAndInitiatePreseed(objects, client);
+  for (const obj of objects) {
+    const objectDef = await localObjectCache.get(client, obj.$apiName);
+    if (objectDef == null) {
+      throw new Error(`Failed to find ontology definition for '${obj.$apiName}'`);
+    }
+    if (interfaceApiName !== void 0) {
+      for (const [sptProp, regularProp] of Object.entries(objectDef.spts)) {
+        if (sptProp in obj) {
+          const value = obj[sptProp];
+          delete obj[sptProp];
+          if (value !== void 0) {
+            obj[regularProp] = value;
+          }
+        }
+      }
+    }
+    internalConvertObjectInPlace(objectDef, client, obj);
+  }
+  if (interfaceApiName) {
+    return objects.map((o) => o.$as(interfaceApiName));
+  } else {
+    return objects;
+  }
+}
+function createLocalObjectCacheAndInitiatePreseed(objects, client) {
+  const localInterfaceCache = createAsyncCache((client2, apiName) => client2.ontology.provider.getInterfaceDefinition(apiName));
+  const localObjectCache = createAsyncCache(async (client2, apiName) => {
+    const objectDef = await client2.ontology.provider.getObjectDefinition(apiName);
+    const interfaceDefs = Object.fromEntries((await Promise.all(objectDef.implements?.map((i) => localInterfaceCache.get(client2, i)) ?? [])).map((i) => [i.apiName, i]));
+    if (objectDef[InterfaceDefinitions] == null) {
+      Object.defineProperty(objectDef, InterfaceDefinitions, {
+        value: interfaceDefs,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    }
+    return objectDef;
+  });
+  const uniqueApiNames = /* @__PURE__ */ new Set();
+  for (const {
+    $apiName
+  } of objects) {
+    if (uniqueApiNames.has($apiName))
+      continue;
+    uniqueApiNames.add($apiName);
+    localObjectCache.get(client, $apiName);
+  }
+  return localObjectCache;
+}
+function fixObjectPropertiesInline(objs) {
+  for (const obj of objs) {
+    if (obj.__rid) {
+      obj.$rid = obj.__rid;
+      delete obj.__rid;
+    }
+    obj.$apiName = obj.__apiName;
+    obj.$objectType = obj.__apiName;
+    obj.$primaryKey = obj.__primaryKey;
+    {
+      Object.defineProperties(obj, {
+        "__apiName": {
+          enumerable: false
+        },
+        "__primaryKey": {
+          enumerable: false
+        }
+      });
+    }
+  }
+}
+function internalConvertObjectInPlace(objectDef, client, obj) {
+  const [proto, converter] = protoConverterCache.get(client, objectDef);
+  Object.setPrototypeOf(obj, proto);
+  Object.defineProperties(obj, {
+    [OriginClient]: {
+      value: client
+    },
+    [UnderlyingObject]: {
+      value: obj
+    }
+  });
+  if (converter) {
+    converter(obj);
+  }
+}
+async function aggregate(clientCtx, objectType, objectSet = {
+  type: "base",
+  objectType: objectType["apiName"]
+}, req) {
+  const body = {
+    aggregation: modernToLegacyAggregationClause(req.select),
+    groupBy: [],
+    where: void 0
+  };
+  if (req.groupBy) {
+    body.groupBy = modernToLegacyGroupByClause(req.groupBy);
+  }
+  if (req.where) {
+    body.where = modernToLegacyWhereClause(req.where);
+  }
+  const result = await aggregateObjectSetV2(createOpenApiRequest(clientCtx.stack, clientCtx.fetch), clientCtx.ontology.metadata.ontologyApiName, {
+    objectSet,
+    groupBy: body.groupBy,
+    aggregation: body.aggregation
+  });
+  if (!req.groupBy) {
+    !(result.data.length === 1) ? process.env.NODE_ENV !== "production" ? invariant2(false, "no group by clause should mean only one data result") : invariant2(false) : void 0;
+    return {
+      ...aggregationToCountResult(result.data[0]),
+      ...legacyToModernSingleAggregationResult(result.data[0])
+    };
+  }
+  const ret = result.data.map((entry) => {
+    return {
+      $group: entry.group,
+      ...aggregationToCountResult(entry),
+      ...legacyToModernSingleAggregationResult(entry)
+    };
+  });
+  return ret;
+}
+function aggregationToCountResult(entry) {
+  for (const aggregateResult of entry.metrics) {
+    if (aggregateResult.name === "count") {
+      return {
+        $count: aggregateResult.value
+      };
+    }
+  }
+}
+
+// src/util/WireObjectSet.ts
+var WIRE_OBJECT_SET_TYPES = /* @__PURE__ */ new Set(["base", "filter", "intersect", "reference", "searchAround", "static", "subtract", "union"]);
+function isWireObjectSet(o) {
+  return o != null && typeof o === "object" && WIRE_OBJECT_SET_TYPES.has(o.type);
+}
+async function createTemporaryObjectSet(ctx, request) {
+  return conjureFetch(ctx, `/objectSets/temporary`, "POST", request);
+}
+async function batchEnableWatcher(ctx, request) {
+  return conjureFetch(ctx, `/object-set-watcher/batchEnableWatcher`, "POST", request);
+}
+async function loadAllOntologies(ctx, request) {
+  return conjureFetch(ctx, `/ontology/ontology/ontologies/load/all`, "POST", request);
+}
+async function loadOntologyEntities(ctx, request) {
+  return conjureFetch(ctx, `/ontology/ontology/loadEntities`, "POST", request);
+}
+
+// src/objectSet/toConjureObjectSet.ts
+function toConjureObjectSet(objectSet, objectPropertyMapping) {
+  switch (objectSet.type) {
+    case "base":
+      return {
+        type: "base",
+        base: {
+          objectTypeId: objectPropertyMapping.id
+        }
+      };
+    case "static":
+      return {
+        type: "static",
+        static: {
+          objectRids: objectSet.objects,
+          provenance: void 0
+        }
+      };
+    case "reference":
+      return {
+        type: "referenced",
+        referenced: {
+          objectSetRid: objectSet.reference
+        }
+      };
+    case "filter":
+      return {
+        type: "filtered",
+        filtered: {
+          objectSet: toConjureObjectSet(objectSet.objectSet, objectPropertyMapping),
+          runtimeDerivedProperties: void 0,
+          filter: mapWhereClauseToObjectSetFilter(objectSet.where, objectPropertyMapping)
+        }
+      };
+    case "union":
+      return {
+        type: "unioned",
+        unioned: {
+          objectSets: objectSet.objectSets.map((os) => toConjureObjectSet(os, objectPropertyMapping))
+        }
+      };
+    case "intersect":
+      return {
+        type: "intersected",
+        intersected: {
+          objectSets: objectSet.objectSets.map((os) => toConjureObjectSet(os, objectPropertyMapping))
+        }
+      };
+    case "subtract":
+      return {
+        type: "subtracted",
+        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 {
+        type: "range",
+        range: {
+          propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
+          lt: objectSetFilter.value,
+          lte: void 0,
+          gt: void 0,
+          gte: void 0
+        }
+      };
+    case "gt":
+      return {
+        type: "range",
+        range: {
+          propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
+          gt: objectSetFilter.value,
+          lte: void 0,
+          lt: void 0,
+          gte: void 0
+        }
+      };
+    case "lte":
+      return {
+        type: "range",
+        range: {
+          propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
+          lte: objectSetFilter.value,
+          lt: void 0,
+          gt: void 0,
+          gte: void 0
+        }
+      };
+    case "gte":
+      return {
+        type: "range",
+        range: {
+          propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
+          gte: objectSetFilter.value,
+          lt: void 0,
+          lte: void 0,
+          gt: void 0
+        }
+      };
+    case "eq":
+      return {
+        type: "exactMatch",
+        exactMatch: {
+          propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
+          terms: []
+        }
+      };
+    case "and":
+      return {
+        type: "and",
+        and: {
+          filters: objectSetFilter.value.map((filter) => mapWhereClauseToObjectSetFilter(filter, propertyMapping))
+        }
+      };
+    case "or":
+      return {
+        type: "or",
+        or: {
+          filters: objectSetFilter.value.map((filter) => mapWhereClauseToObjectSetFilter(filter, propertyMapping))
+        }
+      };
+    case "isNull":
+      return {
+        type: "not",
+        not: {
+          filter: {
+            type: "hasProperty",
+            hasProperty: {
+              propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field]
+            }
+          }
+        }
+      };
+    case "not":
+      return {
+        type: "not",
+        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":
+      throw new Error("not implemented");
+  }
+}
+
+// src/objectSet/ObjectSetListenerWebsocket.ts
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var MINIMUM_RECONNECT_DELAY_MS = 5 * 1e3;
+var ObjectSetListenerWebsocket = class _ObjectSetListenerWebsocket {
+  static #instances = /* @__PURE__ */ new WeakMap();
+  // FIXME
+  static getInstance(client) {
+    let instance = _ObjectSetListenerWebsocket.#instances.get(client);
+    if (instance == null) {
+      instance = new _ObjectSetListenerWebsocket(client);
+      _ObjectSetListenerWebsocket.#instances.set(client, instance);
+    }
+    return instance;
+  }
+  #ws;
+  #lastWsConnect = 0;
+  #client;
+  /** map of listenerId to listener */
+  #listeners = /* @__PURE__ */ new Map();
+  /** map of subscriptionId to listenerId */
+  #subscriptionToRequestId = /* @__PURE__ */ new Map();
+  #conjureContext;
+  #metadataContext;
+  #ossContext;
+  constructor(client) {
+    this.#client = client;
+    const stackUrl = new URL(client.stack);
+    this.#conjureContext = {
+      baseUrl: stackUrl.origin,
+      servicePath: "/object-set-watcher/api",
+      fetchFn: client.fetch,
+      tokenProvider: async () => await client.tokenProvider()
+    };
+    this.#ossContext = {
+      baseUrl: stackUrl.origin,
+      servicePath: "/object-set-service/api",
+      fetchFn: client.fetch,
+      tokenProvider: async () => await client.tokenProvider()
+    };
+    this.#metadataContext = {
+      baseUrl: stackUrl.origin,
+      servicePath: "/ontology-metadata/api",
+      fetchFn: client.fetch,
+      tokenProvider: async () => await client.tokenProvider()
+    };
+  }
+  subscribe(objectSet, listener) {
+    const requestId = crypto.randomUUID();
+    const expiry = setTimeout(() => {
+      this.#expire(requestId);
+    }, ONE_DAY_MS);
+    this.#listeners.set(requestId, {
+      listener,
+      objectSet,
+      expiry
+    });
+    this.#subscribe(requestId, objectSet);
+    return () => {
+      this.#unsubscribe(requestId);
+    };
+  }
+  async #subscribe(requestId, objectSet) {
+    try {
+      const [temporaryObjectSet] = await Promise.all([
+        // create a time-bounded object set representation for watching
+        this.#createTemporaryObjectSet(objectSet),
+        this.#ensureWebsocket(),
+        // look up the object type's rid and ensure that we have enabled object set watcher for that rid
+        // TODO ???
+        getObjectSetBaseType(objectSet).then((baseType) => getObjectTypeV2(createOpenApiRequest(this.#client.stack, this.#client.fetch), this.#client.ontology.metadata.ontologyApiName, baseType)).then((objectType) => this.#enableObjectSetsWatcher([objectType.rid]))
+      ]);
+      if (!this.#listeners.has(requestId)) {
+        return;
+      }
+      const subscribe = {
+        id: requestId,
+        requests: [{
+          objectSet: temporaryObjectSet.objectSetRid,
+          objectSetContext: {
+            objectSetFilterContext: {
+              parameterOverrides: {}
+            }
+          },
+          watchAllLinks: false
+        }]
+      };
+      this.#ws?.send(JSON.stringify(subscribe));
+    } catch (error) {
+      this.#getCallbackByRequestId(requestId, "onError")?.(error);
+    }
+  }
+  #expire(requestId) {
+    const state = this.#listeners.get(requestId);
+    if (state) {
+      const {
+        subscriptionId,
+        objectSet
+      } = state;
+      if (subscriptionId) {
+        state.subscriptionId = void 0;
+        this.#subscriptionToRequestId.delete(subscriptionId);
+      }
+      this.#subscribe(requestId, objectSet);
+    }
+  }
+  #unsubscribe(requestId) {
+    const data = this.#listeners.get(requestId);
+    if (data == null) {
+      return;
+    }
+    this.#listeners.delete(requestId);
+    clearTimeout(data.expiry);
+    const {
+      subscriptionId
+    } = data;
+    if (subscriptionId != null) {
+      this.#subscriptionToRequestId.delete(subscriptionId);
+    }
+    if (this.#listeners.size === 0) {
+      this.#destroyWebsocket();
+    }
+  }
+  async #ensureWebsocket() {
+    if (this.#ws == null) {
+      const {
+        stack,
+        tokenProvider
+      } = this.#client;
+      const base = new URL(stack);
+      const url = `wss://${base.host}/object-set-watcher/ws/subscriptions`;
+      const token = await tokenProvider();
+      if (this.#ws == null) {
+        const nextConnectTime = (this.#lastWsConnect ?? 0) + 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) {
+          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) {
+        return new Promise((resolve, reject) => {
+          this.#ws.addEventListener("open", () => {
+            resolve();
+          });
+          this.#ws.addEventListener("error", (event) => {
+            reject(new Error(event.toString()));
+          });
+        });
+      }
+    }
+  }
+  #onOpen = () => {
+    for (const [requestId, state] of this.#listeners) {
+      this.#subscribe(requestId, state.objectSet);
+    }
+  };
+  #onMessage = async (message) => {
+    const data = JSON.parse(message.data.toString());
+    switch (data.type) {
+      case "objectSetChanged": {
+        if (data.objectSetChanged.confidenceValue) {
+          this.#getCallback(data.objectSetChanged.id, "onOutOfDate")?.();
+          break;
+        }
+        const {
+          id: subscriptionId,
+          objects
+        } = data.objectSetChanged;
+        const callback = this.#getCallback(subscriptionId, "onChange");
+        if (callback) {
+          callback(await convertFoundryToOsdkObjects(this.#client, this.#metadataContext, objects));
+        }
+        break;
+      }
+      case "refreshObjectSet": {
+        const {
+          id: subscriptionId
+        } = data.refreshObjectSet;
+        this.#getCallback(subscriptionId, "onOutOfDate")?.();
+        break;
+      }
+      case "subscribeResponses": {
+        const {
+          id: requestId,
+          responses
+        } = data.subscribeResponses;
+        const listenerData = this.#listeners.get(requestId);
+        if (listenerData == null) {
+          return;
+        }
+        if (responses.length !== 1) {
+          throw new Error("Got more than one response but we only expect a single one");
+        }
+        const response = responses[0];
+        switch (response.type) {
+          case "error":
+            this.#getCallbackByRequestId(requestId, "onError")?.(response.error);
+            this.#unsubscribe(requestId);
+            return;
+          case "qos":
+            this.#destroyWebsocket();
+            this.#ensureWebsocket();
+            return;
+          case "success":
+            const {
+              id: subscriptionId
+            } = response.success;
+            listenerData.subscriptionId = subscriptionId;
+            this.#subscriptionToRequestId.set(subscriptionId, requestId);
+            this.#getCallbackByRequestId(requestId, "onOutOfDate")?.();
+            break;
+          default:
+            this.#getCallbackByRequestId(requestId, "onError")?.(response);
+        }
+        break;
+      }
+    }
+  };
+  #onClose = () => {
+    this.#destroyWebsocket();
+  };
+  async #enableObjectSetsWatcher(objectTypeRids) {
+    return batchEnableWatcher(this.#conjureContext, {
+      requests: objectTypeRids
+    });
+  }
+  async #createTemporaryObjectSet(objectSet) {
+    const objectSetBaseType = await getObjectSetBaseType(objectSet);
+    const mapping = await getOntologyPropertyMappingForApiName(this.#client, this.#metadataContext, objectSetBaseType);
+    const temporaryObjectSet = await createTemporaryObjectSet(this.#ossContext, {
+      objectSet: toConjureObjectSet(objectSet, mapping),
+      timeToLive: "ONE_DAY",
+      objectSetFilterContext: {
+        parameterOverrides: {}
+      }
+    });
+    return {
+      objectSetRid: temporaryObjectSet.objectSetRid
+    };
+  }
+  #destroyWebsocket = () => {
+    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;
+    }
+    this.#subscriptionToRequestId.clear();
+    for (const state of this.#listeners.values()) {
+      state.subscriptionId = void 0;
+    }
+    if (this.#listeners.size > 0) {
+      this.#ensureWebsocket();
+    }
+  };
+  #getCallbackByRequestId(requestId, type) {
+    const maybeListener = this.#listeners.get(requestId);
+    return maybeListener?.listener?.[type];
+  }
+  #getCallback(subscriptionId, type) {
+    const requestId = this.#subscriptionToRequestId.get(subscriptionId);
+    if (requestId) {
+      return this.#getCallbackByRequestId(requestId, type);
+    }
+    return;
+  }
+};
+async function convertFoundryToOsdkObjects(client, ctx, objects) {
+  const osdkObjects = await Promise.all(objects.map(async (object) => {
+    const propertyMapping = await getOntologyPropertyMappingForRid(ctx, client.ontology.metadata.ontologyRid, object.type);
+    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);
+}
+var objectTypeMapping = /* @__PURE__ */ new WeakMap();
+var objectApiNameToRid = /* @__PURE__ */ new Map();
+async function getOntologyPropertyMappingForApiName(client, ctx, objectApiName) {
+  if (objectApiNameToRid.has(objectApiName)) {
+    return objectTypeMapping.get(ctx)?.get(objectApiNameToRid.get(objectApiName));
+  }
+  const wireObjectType = await getObjectTypeV2(createOpenApiRequest(client.stack, client.fetch), client.ontology.metadata.ontologyApiName, objectApiName);
+  return getOntologyPropertyMappingForRid(ctx, client.ontology.metadata.ontologyRid, wireObjectType.rid);
+}
+var cachedAllOntologies;
+async function getOntologyVersionForRid(ctx, ontologyRid) {
+  cachedAllOntologies ??= await loadAllOntologies(ctx, {});
+  !cachedAllOntologies.ontologies[ontologyRid] ? process.env.NODE_ENV !== "production" ? invariant2(false, "ontology should be loaded") : invariant2(false) : void 0;
+  return cachedAllOntologies.ontologies[ontologyRid].currentOntologyVersion;
+}
+async function getOntologyPropertyMappingForRid(ctx, ontologyRid, objectRid) {
+  if (!objectTypeMapping.has(ctx)) {
+    objectTypeMapping.set(ctx, /* @__PURE__ */ new Map());
+  }
+  if (!objectTypeMapping.get(ctx).has(objectRid)) {
+    const ontologyVersion = await getOntologyVersionForRid(ctx, ontologyRid);
+    const body = {
+      objectTypeVersions: {
+        // TODO: Undefined drops this in the body
+        [objectRid]: ontologyVersion
+      },
+      linkTypeVersions: {},
+      loadRedacted: false,
+      includeObjectTypesWithoutSearchableDatasources: true
+    };
+    const entities = await loadOntologyEntities(ctx, body);
+    !entities.objectTypes[objectRid] ? process.env.NODE_ENV !== "production" ? invariant2(false, "object type should be loaded") : invariant2(false) : void 0;
+    const propertyIdToApiNameMapping = Object.fromEntries(Object.values(entities.objectTypes[objectRid].propertyTypes).map((property) => {
+      return [property.id, property.apiName];
+    }));
+    const propertyApiNameToIdMapping = Object.fromEntries(Object.values(entities.objectTypes[objectRid].propertyTypes).map((property) => {
+      return [property.id, property.apiName];
+    }));
+    objectTypeMapping.get(ctx)?.set(objectRid, {
+      apiName: entities.objectTypes[objectRid].apiName,
+      id: entities.objectTypes[objectRid].id,
+      propertyIdToApiNameMapping,
+      propertyApiNameToIdMapping
+    });
+    objectApiNameToRid.set(entities.objectTypes[objectRid].apiName, objectRid);
+  }
+  return objectTypeMapping.get(ctx)?.get(objectRid);
+}
+
+// src/objectSet/createObjectSet.ts
+function isObjectTypeDefinition(def) {
+  return def.type === "object";
+}
+function isObjectSet(o) {
+  return o != null && typeof o === "object" && isWireObjectSet(objectSetDefinitions.get(o));
+}
+function getWireObjectSet(objectSet) {
+  return objectSetDefinitions.get(objectSet);
+}
+var objectSetDefinitions = /* @__PURE__ */ new WeakMap();
+function createObjectSet(objectType, clientCtx, objectSet = {
+  type: "base",
+  objectType: objectType["apiName"]
+}) {
+  const base = {
+    aggregate: aggregate.bind(globalThis, clientCtx, objectType, objectSet),
+    aggregateOrThrow: aggregate.bind(globalThis, clientCtx, objectType, objectSet),
+    fetchPage: fetchPageInternal.bind(globalThis, clientCtx, objectType, objectSet),
+    fetchPageWithErrors: fetchPageWithErrorsInternal.bind(globalThis, clientCtx, objectType, objectSet),
+    fetchPageOrThrow: fetchPageInternal.bind(globalThis, clientCtx, objectType, objectSet),
+    where: (clause) => {
+      return createObjectSet(objectType, clientCtx, {
+        type: "filter",
+        objectSet,
+        where: modernToLegacyWhereClause(clause)
+      });
+    },
+    pivotTo: function(type) {
+      return createSearchAround(type)();
+    },
+    union: (...objectSets) => {
+      return createObjectSet(objectType, clientCtx, {
+        type: "union",
+        objectSets: [objectSet, ...objectSets.map((os) => objectSetDefinitions.get(os))]
+      });
+    },
+    intersect: (...objectSets) => {
+      return createObjectSet(objectType, clientCtx, {
+        type: "intersect",
+        objectSets: [objectSet, ...objectSets.map((os) => objectSetDefinitions.get(os))]
+      });
+    },
+    subtract: (...objectSets) => {
+      return createObjectSet(objectType, clientCtx, {
+        type: "subtract",
+        objectSets: [objectSet, ...objectSets.map((os) => objectSetDefinitions.get(os))]
+      });
+    },
+    subscribe(listener) {
+      const instance = ObjectSetListenerWebsocket.getInstance(clientCtx);
+      return instance.subscribe(objectSet, listener);
+    },
+    asyncIter: async function* () {
+      let nextPageToken = void 0;
+      do {
+        const result = await base.fetchPage({
+          nextPageToken
+        });
+        for (const obj of await convertWireToOsdkObjects(clientCtx, result.data, void 0)) {
+          yield obj;
+        }
+      } while (nextPageToken != null);
+    },
+    get: isObjectTypeDefinition(objectType) ? async (primaryKey, options) => {
+      const withPk = {
+        type: "filter",
+        objectSet,
+        where: {
+          type: "eq",
+          field: objectType.primaryKeyApiName,
+          value: primaryKey
+        }
+      };
+      return await fetchSingle(clientCtx, objectType, options, withPk);
+    } : void 0
+  };
+  function createSearchAround(link) {
+    return () => {
+      return createObjectSet(objectType, clientCtx, {
+        type: "searchAround",
+        objectSet,
+        link
+      });
+    };
+  }
+  objectSetDefinitions.set(base, objectSet);
+  return base;
+}
 
 // src/util/isOntologyObjectV2.ts
 function isOntologyObjectV2(o) {
@@ -41,14 +1393,6 @@ function toDataValue(value) {
   return value;
 }
 
-// src/actions/ActionValidationError.ts
-var ActionValidationError = class extends Error {
-  constructor(validation) {
-    super("Validation Error");
-    this.validation = validation;
-  }
-};
-
 // src/actions/applyAction.ts
 async function applyAction(client, action, parameters, options = {}) {
   const response = await applyActionV2(createOpenApiRequest(client.stack, client.fetch), client.ontology.metadata.ontologyApiName, action.apiName, {
@@ -120,9 +1464,8 @@ async function loadAllOutgoingLinkTypes(client, objtype) {
   return linkTypes;
 }
 function makeConjureContext(client, servicePath) {
-  const baseUrl = client.stack.startsWith("https://") ? client.stack : `https://${client.stack}`;
   return {
-    baseUrl,
+    baseUrl: client.stack,
     servicePath,
     fetchFn: client.fetch,
     tokenProvider: async () => await client.tokenProvider()
@@ -158,7 +1501,7 @@ async function loadSptMap(ctx, ontologyMetadata, ontologyRid, objectRid) {
   };
   const entities = await loadOntologyEntities(ctx, body);
   const objectType = entities.objectTypes[objectRid];
-  !objectType ? process.env.NODE_ENV !== "production" ? invariant(false, "object type should be loaded") : invariant(false) : void 0;
+  !objectType ? process.env.NODE_ENV !== "production" ? invariant2(false, "object type should be loaded") : invariant2(false) : void 0;
   const sptMap = {};
   for (const property of Object.values(objectType.propertyTypes)) {
     if (property.sharedPropertyTypeApiName && property.apiName) {
@@ -217,7 +1560,7 @@ var createStandardOntologyProviderFactory = (client) => {
 };
 
 // src/util/UserAgent.ts
-var USER_AGENT = `osdk-client/${"0.14.0"}`;
+var USER_AGENT = `osdk-client/${"0.15.0"}`;
 
 // src/createMinimalClient.ts
 function createMinimalClient(metadata, stack, tokenProvider, ontologyCachingOptions = {}, fetchFn = global.fetch) {
@@ -269,7 +1612,16 @@ function createFutureClientPlus(metadata, stack, tokenProvider, ontologyCachingO
   }
   return [clientCtx, clientFn];
 }
+function createFutureClient(metadata, stack, tokenProvider, ontologyCachingOptions = {}, fetchFn = fetch) {
+  return createFutureClientPlus(metadata, stack, tokenProvider, ontologyCachingOptions, fetchFn)[1];
+}
+function isOntologyMetadata(ontology) {
+  return "ontologyRid" in ontology || "ontologyApiName" in ontology;
+}
 function createClient(ontology, stack, tokenProvider, ontologyCachingOptions = {}, fetchFn = fetch) {
+  if (isOntologyMetadata(ontology)) {
+    return createFutureClient(ontology, stack, tokenProvider, ontologyCachingOptions, fetchFn);
+  }
   const [clientCtx, clientFn] = createFutureClientPlus(ontology.metadata, stack, tokenProvider, ontologyCachingOptions, fetchFn);
   const objectSetFactory = (type) => createObjectSet(ontology["objects"][type] ?? ontology["interfaces"]?.[type], clientCtx);
   const oldActionInvoker = createOldActionInvoker(clientCtx, ontology);
@@ -301,6 +1653,6 @@ function createClient(ontology, stack, tokenProvider, ontologyCachingOptions = {
   return client;
 }
 
-export { ActionValidationError, createClient, createMinimalClient };
+export { ActionValidationError, augment, createClient, createMinimalClient };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.mjs.map