@osdk/faux 0.1.0-beta.1

package/build/cjs/index.cjs

@@ -0,0 +1,2983 @@
+'use strict';
+
+var generatorConverters = require('@osdk/generator-converters');
+var crypto = require('crypto');
+var mnemonist = require('mnemonist');
+var invariant4 = require('tiny-invariant');
+var msw = require('msw');
+var deepEqual = require('fast-deep-equal');
+var dateFns = require('date-fns');
+var semver = require('semver');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
+var invariant4__default = /*#__PURE__*/_interopDefault(invariant4);
+var msw__namespace = /*#__PURE__*/_interopNamespace(msw);
+var deepEqual__default = /*#__PURE__*/_interopDefault(deepEqual);
+var semver__default = /*#__PURE__*/_interopDefault(semver);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/FauxFoundry/typeHelpers/index.ts
+var typeHelpers_exports = {};
+__export(typeHelpers_exports, {
+  actionTypeBuilder: () => actionTypeBuilder,
+  createActionParameterV2: () => createActionParameterV2,
+  createActionRid: () => createActionRid,
+  createActionType: () => createAction
+});
+
+// src/FauxFoundry/typeHelpers/TH_ActionParameterV2.ts
+function createActionParameterV2(type, required) {
+  return {
+    dataType: {
+      type
+    },
+    required
+  };
+}
+
+// src/FauxFoundry/typeHelpers/TH_ActionTypeV2.ts
+function createAction({
+  apiName,
+  parameters,
+  rid = createActionRid(),
+  operations = [],
+  status = "ACTIVE",
+  description
+}) {
+  return {
+    apiName,
+    parameters,
+    rid,
+    operations,
+    status,
+    description: description ?? `Action ${apiName}`
+  };
+}
+
+// src/FauxFoundry/typeHelpers/ActionTypeBuilder.ts
+function actionTypeBuilder(action) {
+  return new ActionTypeBuilder(action);
+}
+function createActionRid() {
+  return `ri.ontology.main.action-type.${crypto__namespace.randomUUID()}`;
+}
+var ActionTypeBuilder = class _ActionTypeBuilder {
+  constructor(action) {
+    if (typeof action === "string") {
+      this.action = createAction({
+        apiName: action,
+        parameters: {}
+      });
+    } else {
+      this.action = action;
+    }
+  }
+  addParameter(paramId, parameter, required = false) {
+    const v = typeof parameter === "string" ? createActionParameterV2(parameter, required) : parameter;
+    return new _ActionTypeBuilder({
+      ...this.action,
+      parameters: {
+        ...this.action.parameters,
+        [paramId]: v
+      }
+    });
+  }
+  build() {
+    const actionTypeV2 = this.action;
+    const actionMetadata = generatorConverters.wireActionTypeV2ToSdkActionMetadata(
+      actionTypeV2
+      // cast below is needed because the compile time type also needs `signatures`
+      // which we don't create in the conversion.
+    );
+    return {
+      actionTypeV2: this.action,
+      actionDefinition: {
+        __DefinitionMetadata: actionMetadata,
+        apiName: actionMetadata.apiName,
+        type: "action"
+      }
+    };
+  }
+};
+
+// src/BaseError.ts
+function isBaseApiError(error) {
+  return error && typeof error === "object" && "errorCode" in error && "errorName" in error && "errorInstanceId" in error;
+}
+
+// src/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  ActionNotFoundError: () => ActionNotFoundError,
+  ApplyActionFailedError: () => ApplyActionFailedError,
+  AttachmentNotFoundError: () => AttachmentNotFoundError,
+  AttachmentSizeExceededLimitError: () => AttachmentSizeExceededLimitError,
+  ExecuteQueryFailedError: () => ExecuteQueryFailedError,
+  InvalidContentTypeError: () => InvalidContentTypeError,
+  InvalidRequest: () => InvalidRequest,
+  LinkTypeNotFound: () => LinkTypeNotFound,
+  ObjectNotFoundError: () => ObjectNotFoundError,
+  ObjectTypeDoesNotExistError: () => ObjectTypeDoesNotExistError,
+  OntologyNotFoundError: () => OntologyNotFoundError,
+  QueryNotFoundError: () => QueryNotFoundError
+});
+var errorInstanceId = "errorInstanceId";
+var objectTypeRid = "ri.foundry.main.objectType.1";
+function ObjectTypeDoesNotExistError(objectType) {
+  return {
+    errorCode: "NOT_FOUND",
+    errorName: "ObjectTypeNotFound",
+    errorInstanceId,
+    parameters: {
+      objectType,
+      objectTypeRid
+    }
+  };
+}
+function LinkTypeNotFound(objectType, linkType) {
+  return {
+    errorCode: "NOT_FOUND",
+    errorName: "LinkTypeNotFound",
+    errorInstanceId,
+    parameters: {
+      objectType,
+      linkType
+    }
+  };
+}
+function OntologyNotFoundError(ontology) {
+  return {
+    errorCode: "NOT_FOUND",
+    errorName: "OntologyNotFound",
+    errorInstanceId,
+    parameters: {
+      ontologyRid: ontology,
+      apiName: ontology
+    }
+  };
+}
+function ObjectNotFoundError(objectType, primaryKey) {
+  return {
+    errorCode: "NOT_FOUND",
+    errorName: "ObjectNotFound",
+    errorInstanceId,
+    parameters: {
+      objectType,
+      primaryKey: {
+        employeeId: primaryKey
+      }
+    }
+  };
+}
+function QueryNotFoundError(queryApiName) {
+  return {
+    errorCode: "NOT_FOUND",
+    errorName: "QueryNotFound",
+    errorInstanceId,
+    parameters: {
+      query: queryApiName
+    }
+  };
+}
+function ActionNotFoundError() {
+  return {
+    errorCode: "NOT_FOUND",
+    errorName: "ActionNotFound",
+    errorInstanceId,
+    parameters: {
+      actionRid: ""
+    }
+  };
+}
+function InvalidRequest(errorName) {
+  return {
+    errorCode: "INVALID_REQUEST",
+    errorName,
+    errorInstanceId,
+    parameters: {}
+  };
+}
+var ApplyActionFailedError = {
+  errorCode: "INVALID_ARGUMENT",
+  errorName: "ApplyActionFailed",
+  errorInstanceId,
+  parameters: {}
+};
+var ExecuteQueryFailedError = {
+  errorCode: "CONFLICT",
+  errorName: "QueryEncounteredUserFacingError",
+  errorInstanceId,
+  parameters: {
+    functionRid: "ri.function-registry.main.function.9b55870a-63c7-4d48-8f06-9627c0805968",
+    functionVersion: "0.11.0",
+    message: "test failed"
+  }
+};
+var InvalidContentTypeError = {
+  errorCode: "INVALID_ARGUMENT",
+  errorName: "InvalidContentType",
+  errorInstanceId,
+  parameters: {}
+};
+var AttachmentSizeExceededLimitError = {
+  errorCode: "INVALID_ARGUMENT",
+  errorName: "AttachmentSizeExceededLimit",
+  errorInstanceId,
+  parameters: {
+    fileSizeBytes: "230000",
+    fileLimitBytes: "200000"
+  }
+};
+var AttachmentNotFoundError = {
+  errorCode: "NOT_FOUND",
+  errorName: "AttachmentNotFound",
+  errorInstanceId,
+  parameters: {
+    attachmentRid: "ri.attachments.main.attachment.86016861-707f-4292-b258-6a7108915a80"
+  }
+};
+
+// src/filterObjects.ts
+function subSelectPropertiesUrl(object, url) {
+  const properties = new Set(url.searchParams.getAll("select"));
+  if (properties.size === 0) {
+    return object;
+  }
+  const result = Object.entries(object).reduce((acc, [key, value]) => {
+    if (properties.has(key)) {
+      acc[key] = value;
+    } else if (key === "__primaryKey") {
+      acc.__primaryKey = value;
+    } else if (key === "__apiName") {
+      acc.__apiName = value;
+    }
+    return acc;
+  }, {});
+  return result;
+}
+function subSelectProperties(objects, urlOrProperties, includeCount, excludeRid) {
+  let properties;
+  if (Array.isArray(urlOrProperties)) {
+    properties = new Set(urlOrProperties);
+  } else {
+    properties = new Set(urlOrProperties.searchParams.getAll("select"));
+  }
+  const result = objects.data.map((object) => {
+    if (object.$propsToReturn) {
+      return {
+        __apiName: object.__apiName,
+        __primaryKey: object.__primaryKey,
+        __title: object.__title,
+        ...object.$propsToReturn,
+        ...excludeRid ? {} : {
+          __rid: object.__rid
+        }
+      };
+    }
+    if (properties.size === 0) {
+      return excludeRid ? removeRid(object) : object;
+    }
+    properties.add("__primaryKey");
+    properties.add("__apiName");
+    properties.add("__title");
+    if (!excludeRid) properties.add("__rid");
+    return Object.entries(object).reduce((acc, [key, value]) => {
+      if (properties.has(key)) {
+        acc[key] = value;
+      }
+      return acc;
+    }, {});
+  });
+  const ret = {
+    nextPageToken: objects.nextPageToken,
+    data: result,
+    totalCount: objects.totalCount
+  };
+  return ret;
+}
+function removeRid(object) {
+  const {
+    __rid,
+    ...rest2
+  } = object;
+  return rest2;
+}
+
+// src/handlers/util/getPaginationParams.ts
+function getPaginationParamsFromUrl(request) {
+  const url = new URL(request.url);
+  return {
+    pageSize: url.searchParams.get("pageSize") == null ? void 0 : Number(url.searchParams.get("pageSize")),
+    pageToken: url.searchParams.get("pageToken") == null ? void 0 : url.searchParams.get("pageToken")
+  };
+}
+function getPaginationParamsFromRequest({
+  pageSize,
+  pageToken
+}) {
+  return {
+    pageSize,
+    pageToken
+  };
+}
+function authHandlerMiddleware(handler) {
+  return async (info) => {
+    const authHeader = info.request.headers.get("authorization");
+    if (!authHeader || authHeader !== `Bearer myAccessToken`) {
+      return msw.HttpResponse.json({
+        message: "Missing Authorization header"
+      }, {
+        status: 401
+      });
+    }
+    try {
+      return await handler(info);
+    } catch (e) {
+      if (e instanceof OpenApiCallError) {
+        return msw.HttpResponse.json(e.json, {
+          status: e.status
+        });
+      }
+      throw e;
+    }
+  };
+}
+
+// src/handlers/util/handleOpenApiCall.ts
+var OpenApiCallError = class extends Error {
+  constructor(status, json) {
+    super(`${json.errorCode} ${json.errorName ?? "Unknown error"} ${JSON.stringify(json.parameters)}`);
+    this.status = status;
+    this.json = json;
+  }
+};
+function handleOpenApiCall(openApiCall, names) {
+  return (baseUrl, restImpl, options) => {
+    let captured = {};
+    const capture = {
+      fetch: (url, req) => {
+        const u = new URL(url);
+        u.search = "";
+        captured = {
+          method: req.method,
+          endPoint: u.toString().replace(/%3A/g, ":")
+        };
+        return {
+          ok: true,
+          json: () => Promise.resolve({}),
+          blob: () => new Blob()
+        };
+      },
+      baseUrl
+    };
+    void openApiCall(
+      capture,
+      ...names.map((n) => `:${n}`),
+      // add a simulated blob in here in case of an upload
+      {
+        type: "",
+        size: 5
+      }
+    );
+    return msw.http[captured.method.toLowerCase()](captured.endPoint, authHandlerMiddleware(async (info) => {
+      try {
+        const result = await restImpl(info);
+        if (result instanceof Response) {
+          return new msw.HttpResponse(result.body);
+        }
+        return msw.HttpResponse.json(result);
+      } catch (e) {
+        if (e instanceof OpenApiCallError) {
+          return msw.HttpResponse.json({
+            ...e.json,
+            stack: e.stack
+          }, {
+            status: e.status,
+            statusText: e.message
+          });
+        }
+        throw e;
+      }
+    }), options);
+  };
+}
+
+// src/handlers/util/pageThroughResponseSearchParams.ts
+function pageThroughResponseSearchParams(iter, {
+  pageSize = 1e3,
+  pageToken
+}, includeCount) {
+  const data = Array.from(iter);
+  const pageCount = Math.ceil(data.length / pageSize);
+  const currentPage = pageToken ? Number(pageToken) : 0;
+  if (currentPage < 0 || currentPage >= pageCount) {
+    return void 0;
+  }
+  const startIndex = currentPage * pageSize;
+  const endIndex = Math.min(startIndex + pageSize, data.length);
+  const nextPageToken = currentPage + 1 < pageCount ? (currentPage + 1).toString() : void 0;
+  const ret = {
+    nextPageToken,
+    data: data.slice(startIndex, endIndex),
+    ...includeCount ? {
+      totalCount: String(data.length)
+    } : {}
+  };
+  return ret;
+}
+
+// src/FauxFoundry/BaseServerObject.ts
+function isBaseServerObject(obj) {
+  return typeof obj === "object" && obj != null && "__primaryKey" in obj && "__apiName" in obj && !("$apiName" in obj) && !("$primaryKey" in obj);
+}
+var FauxDataStoreBatch = class {
+  #fauxDataStore;
+  objectEdits = {
+    addedLinksCount: 0,
+    addedObjectCount: 0,
+    deletedLinksCount: 0,
+    deletedObjectsCount: 0,
+    modifiedObjectsCount: 0,
+    edits: []
+  };
+  constructor(fauxDataStore) {
+    this.#fauxDataStore = fauxDataStore;
+  }
+  getObject = (objectType, primaryKey) => {
+    return this.#fauxDataStore.getObjectOrThrow(objectType, primaryKey);
+  };
+  addObject(objectType, primaryKey, object) {
+    const existingObject = this.#fauxDataStore.getObject(objectType, primaryKey);
+    if (existingObject) {
+      throw new OpenApiCallError(500, {
+        errorCode: "CONFLICT",
+        errorName: "ObjectAlreadyExists",
+        errorInstanceId: "",
+        parameters: {
+          objectType,
+          primaryKey
+        }
+      });
+    }
+    const fullMetadata = this.#fauxDataStore.ontology.getObjectTypeFullMetadataOrThrow(objectType);
+    this.#fauxDataStore.registerObject({
+      ...object,
+      __apiName: objectType,
+      __primaryKey: primaryKey,
+      [fullMetadata.objectType.primaryKey]: primaryKey
+    });
+    this.objectEdits.edits.push({
+      type: "addObject",
+      primaryKey,
+      objectType
+    });
+    this.objectEdits.addedObjectCount += 1;
+  }
+  modifyObject(objectType, primaryKey, update) {
+    const origObj = this.#fauxDataStore.getObjectOrThrow(objectType, primaryKey);
+    const newObj = {
+      ...origObj,
+      ...update
+    };
+    if (!deepEqual__default.default(origObj, newObj)) {
+      this.#fauxDataStore.replaceObjectOrThrow(newObj);
+      this.objectEdits.edits.push({
+        type: "modifyObject",
+        primaryKey,
+        objectType
+      });
+      this.objectEdits.modifiedObjectsCount += 1;
+    }
+  }
+  deleteObject = (objectType, primaryKey) => {
+    this.#fauxDataStore.unregisterObjectOrThrow(objectType, primaryKey);
+    this.objectEdits.edits.push({
+      type: "deleteObject",
+      objectType,
+      primaryKey
+    });
+  };
+  addLink = (leftObjectType, leftPrimaryKey, leftLinkName, rightObjectType, rightPrimaryKey) => {
+    const [leftTypeSideV2, rightTypeSideV2] = this.#fauxDataStore.ontology.getBothLinkTypeSides(leftObjectType, leftLinkName, rightObjectType);
+    this.#fauxDataStore.registerLink({
+      __apiName: leftObjectType,
+      __primaryKey: leftPrimaryKey
+    }, leftTypeSideV2.apiName, {
+      __apiName: rightObjectType,
+      __primaryKey: rightPrimaryKey
+    }, rightTypeSideV2.apiName);
+    this.objectEdits.edits.push({
+      type: "addLink",
+      aSideObject: {
+        objectType: leftObjectType,
+        primaryKey: leftPrimaryKey
+      },
+      bSideObject: {
+        objectType: rightObjectType,
+        primaryKey: rightPrimaryKey
+      },
+      linkTypeApiNameAtoB: leftLinkName,
+      linkTypeApiNameBtoA: rightTypeSideV2.apiName
+    });
+    this.objectEdits.addedLinksCount += 1;
+  };
+  removeLink = (leftObjectType, leftPrimaryKey, leftLinkName, rightObjectType, rightPrimaryKey) => {
+    const [leftTypeSideV2, rightTypeSideV2] = this.#fauxDataStore.ontology.getBothLinkTypeSides(leftObjectType, leftLinkName, rightObjectType);
+    this.#fauxDataStore.unregisterLink({
+      __apiName: leftObjectType,
+      __primaryKey: leftPrimaryKey
+    }, leftTypeSideV2.apiName, {
+      __apiName: rightObjectType,
+      __primaryKey: rightPrimaryKey
+    }, rightTypeSideV2.apiName);
+  };
+};
+var toDuration = {
+  "DAYS": (v) => ({
+    days: v
+  }),
+  "HOURS": (v) => ({
+    hours: v
+  }),
+  "MILLISECONDS": (v) => ({
+    seconds: v / 1e3
+  }),
+  "MINUTES": (v) => ({
+    minutes: v
+  }),
+  "MONTHS": (v) => ({
+    months: v
+  }),
+  "SECONDS": (v) => ({
+    seconds: v
+  }),
+  "WEEKS": (v) => ({
+    weeks: v
+  }),
+  "YEARS": (v) => ({
+    years: v
+  })
+};
+function filterTimeSeriesData(data, {
+  range
+}, now = dateFns.constructNow(Date.now())) {
+  if (!range) {
+    return data;
+  }
+  const start = extractDate(range, "startTime", now);
+  const end = extractDate(range, "endTime", now);
+  const ret = data.filter((point) => {
+    if (range.type === "relative") {
+      return (!end || dateFns.isBefore(point.time, end)) && (!start || dateFns.isAfter(point.time, start));
+    } else {
+      return (!end || dateFns.isBefore(point.time, end)) && (!start || dateFns.isAfter(point.time, start));
+    }
+  });
+  return ret;
+}
+function extractDate(range, key, now) {
+  if (range.type === "absolute") {
+    return range[key];
+  }
+  const x = range[key];
+  if (!x) return void 0;
+  const method = x.when === "BEFORE" ? dateFns.sub : dateFns.add;
+  return method(now, toDuration[x.unit](x.value));
+}
+function filterObjects(objects, where) {
+  switch (where.type) {
+    case "eq": {
+      const {
+        propertyIdentifier,
+        field
+      } = where;
+      if (propertyIdentifier) {
+        console.error("propertyIdentifier not supported", where);
+        throw new Error("propertyIdentifier not supported");
+      }
+      !field ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false) : invariant4__default.default(false) : void 0;
+      const ret = objects.filter((obj) => {
+        return obj[field] === where.value;
+      });
+      return ret;
+    }
+    case "gt": {
+      const {
+        propertyIdentifier,
+        field
+      } = where;
+      if (propertyIdentifier) {
+        console.error("propertyIdentifier not supported", where);
+        throw new Error("propertyIdentifier not supported");
+      }
+      !field ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false) : invariant4__default.default(false) : void 0;
+      return objects.filter((obj) => {
+        return obj[field] > where.value;
+      });
+    }
+    case "lt": {
+      const {
+        propertyIdentifier,
+        field
+      } = where;
+      if (propertyIdentifier) {
+        console.error("propertyIdentifier not supported", where);
+        throw new Error("propertyIdentifier not supported");
+      }
+      !field ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false) : invariant4__default.default(false) : void 0;
+      return objects.filter((obj) => {
+        return obj[field] < where.value;
+      });
+    }
+    case "in": {
+      const {
+        propertyIdentifier,
+        field
+      } = where;
+      if (propertyIdentifier) {
+        console.error("propertyIdentifier not supported", where);
+        throw new Error("propertyIdentifier not supported");
+      }
+      !field ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false) : invariant4__default.default(false) : void 0;
+      return objects.filter((obj) => {
+        return where.value.includes(obj[field]);
+      });
+    }
+    case "and": {
+      const {
+        value
+      } = where;
+      for (const subWhere of value) {
+        objects = filterObjects(objects, subWhere);
+      }
+      return objects;
+    }
+    case "not": {
+      const {
+        value
+      } = where;
+      return objects.filter((obj) => {
+        return !filterObjects([obj], value).length;
+      });
+    }
+    case "isNull": {
+      const {
+        propertyIdentifier,
+        field,
+        value
+      } = where;
+      if (propertyIdentifier) {
+        console.error("propertyIdentifier not supported", where);
+        throw new Error("propertyIdentifier not supported");
+      }
+      !field ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false) : invariant4__default.default(false) : void 0;
+      return objects.filter((obj) => {
+        return value ? obj[field] == null : obj[field] != null;
+      });
+    }
+  }
+  console.error(`-=-=-=-=-=-= Unhandled where type: 
+Unhandled where type: ${where.type} in ${JSON.stringify(where)}`);
+  throw new Error(`Unhandled where type: ${where.type} in ${JSON.stringify(where)}`);
+}
+
+// src/FauxFoundry/getObjectsFromSet.ts
+function getObjectsFromSet(ds, objectSet, methodInput) {
+  switch (objectSet.type) {
+    case "base":
+      const ret = Array.from(ds.getObjectsOfType(objectSet.objectType));
+      return ret;
+    case "filter": {
+      const base = getObjectsFromSet(ds, objectSet.objectSet, methodInput);
+      return filterObjects(base, objectSet.where);
+    }
+    case "union": {
+      const set = /* @__PURE__ */ new Set();
+      for (const objSet of objectSet.objectSets) {
+        const objects = getObjectsFromSet(ds, objSet, methodInput);
+        for (const obj of objects) {
+          set.add(obj);
+        }
+      }
+      return Array.from(set);
+    }
+    case "subtract": {
+      const set = new Set(getObjectsFromSet(ds, objectSet.objectSets[0], methodInput));
+      for (let i = 1; i < objectSet.objectSets.length; i++) {
+        const toSubtract = getObjectsFromSet(ds, objectSet.objectSets[i], methodInput);
+        for (const obj of toSubtract) {
+          set.delete(obj);
+        }
+      }
+      return Array.from(set);
+    }
+    case "intersect": {
+      const set = new Set(getObjectsFromSet(ds, objectSet.objectSets[0], methodInput));
+      for (let i = 1; i < objectSet.objectSets.length; i++) {
+        const toIntersect = getObjectsFromSet(ds, objectSet.objectSets[i], methodInput);
+        for (const obj of set) {
+          const match = toIntersect.find((x) => x.__apiName === obj.__apiName && x.__primaryKey === obj.__primaryKey);
+          if (!match) {
+            set.delete(obj);
+          } else if (obj["$propsToReturn"] || match["$propsToReturn"]) {
+            obj["$propsToReturn"] = {
+              ...obj["$propsToReturn"],
+              ...match["$propsToReturn"]
+            };
+          }
+        }
+      }
+      return Array.from(set);
+    }
+    case "searchAround": {
+      const base = getObjectsFromSet(ds, objectSet.objectSet, methodInput);
+      return base.flatMap((o) => {
+        const ret2 = ds.getLinksOrThrow(o.__apiName, o.__primaryKey, objectSet.link);
+        return ret2;
+      });
+    }
+    case "static": {
+      return objectSet.objects.map((x) => ds.getObjectByRid(x)).filter((x) => x != null);
+    }
+    case "withProperties": {
+      const {
+        derivedProperties
+      } = objectSet;
+      const base = getObjectsFromSet(ds, objectSet.objectSet, methodInput);
+      return base.map((obj) => {
+        const extra = Object.fromEntries(Object.entries(derivedProperties).map(([k, v]) => {
+          return [k, getDerivedPropertyValue(ds, obj, v)];
+        }));
+        return {
+          ...obj,
+          ...extra
+        };
+      });
+    }
+    case "methodInput":
+      !methodInput ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "expected a methodInput") : invariant4__default.default(false) : void 0;
+      return [methodInput];
+    case "asBaseObjectTypes":
+      throw new Error(`Unhandled objectSet type ${JSON.stringify(objectSet)} in shared.test`);
+    case "asType":
+      throw new Error(`Unhandled objectSet type ${JSON.stringify(objectSet)} in shared.test`);
+    case "interfaceBase":
+      const relevantObjectTypes = ds.ontology.getAllObjectTypes().filter((x) => objectSet.interfaceType in x.implementsInterfaces2);
+      return relevantObjectTypes.flatMap((x) => Array.from(ds.getObjectsOfType(x.objectType.apiName))).map((obj) => {
+        const objDef = ds.ontology.getObjectTypeFullMetadataOrThrow(obj.__apiName);
+        const ifaceMap = objDef.implementsInterfaces2[objectSet.interfaceType];
+        const $propsToReturn = objectSet.includeAllBaseObjectProperties ? obj : Object.fromEntries(Object.values(ifaceMap.properties).map((propApiName) => [propApiName, obj[propApiName]]));
+        return {
+          ...objToInterface(ds, obj, objectSet.interfaceType),
+          $propsToReturn
+        };
+      });
+    case "nearestNeighbors":
+      throw new Error(`Unhandled objectSet type ${JSON.stringify(objectSet)} in shared.test`);
+    case "reference":
+      throw new Error(`Unhandled objectSet type ${JSON.stringify(objectSet)} in shared.test`);
+  }
+  throw new Error(`Unhandled objectSet type ${JSON.stringify(objectSet)} in shared.test`);
+}
+function objToInterface(ds, o, iface) {
+  ds.ontology.getInterfaceType(iface);
+  const propMap = ds.ontology.getObjectTypeFullMetadataOrThrow(o.__apiName).implementsInterfaces2[iface].properties;
+  const {
+    __apiName,
+    __primaryKey,
+    __rid,
+    __title
+  } = o;
+  const ret = {
+    __apiName,
+    __primaryKey,
+    __rid,
+    __title
+  };
+  for (const [sptApiName, propApiName] of Object.entries(propMap)) {
+    ret[sptApiName] = o[propApiName];
+  }
+  return ret;
+}
+function getDerivedPropertyValue(ds, obj, def) {
+  switch (def.type) {
+    case "selection": {
+      return getDerivedPropertySelection(ds, obj, def);
+    }
+  }
+  throw new Error(`Unhandled derived property type ${def.type} in ${JSON.stringify(def)}`);
+}
+function getDerivedPropertySelection(ds, obj, {
+  operation,
+  objectSet
+}) {
+  switch (operation.type) {
+    case "get": {
+      const objs = getObjectsFromSet(ds, objectSet, obj);
+      if (objs.length > 1) {
+        throw new Error("Cannot get more than one object from a set");
+      }
+      return objs[0]?.[operation.selectedPropertyApiName];
+    }
+    case "collectList": {
+      const objs = getObjectsFromSet(ds, objectSet, obj);
+      return objs.map((o) => o[operation.selectedPropertyApiName]);
+    }
+    case "collectSet": {
+      const objs = getObjectsFromSet(ds, objectSet, obj);
+      return Array.from(new Set(objs.map((o) => o[operation.selectedPropertyApiName])));
+    }
+    case "count": {
+      const objs = getObjectsFromSet(ds, objectSet, obj);
+      return objs.length.toString();
+    }
+  }
+}
+function createOrderBySortFn(orderBy) {
+  const fns = orderBy.fields.map(({
+    field,
+    direction
+  }) => {
+    return (a, b) => {
+      const aValue = a?.[field];
+      const bValue = b?.[field];
+      if (aValue == null && bValue == null) {
+        return 0;
+      }
+      if (aValue == null) {
+        return 1;
+      }
+      if (bValue == null) {
+        return -1;
+      }
+      const m = direction === "asc" ? -1 : 1;
+      return aValue < bValue ? m : aValue > bValue ? -m : 0;
+    };
+  });
+  return (a, b) => {
+    for (const sortFn of fns) {
+      const ret = sortFn(a, b);
+      if (ret !== 0) {
+        return ret;
+      }
+    }
+    return 0;
+  };
+}
+function objectLocator(obj) {
+  return `${obj.__apiName}:${obj.__primaryKey}`;
+}
+function parseLocator(locator) {
+  const [objectType, primaryKey] = locator?.split(":") ?? [];
+  !(objectType && primaryKey) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, `Invalid locator format:  ${locator}`) : invariant4__default.default(false) : void 0;
+  return {
+    objectType,
+    primaryKey
+  };
+}
+
+// src/FauxFoundry/validateAction.ts
+function validateAction(payload, def, dataStore) {
+  const ret = {
+    parameters: {},
+    submissionCriteria: [],
+    result: "VALID"
+  };
+  for (const [k, v] of Object.entries(def.parameters)) {
+    const value = payload.parameters[k];
+    validateActionParameterType(v.dataType, v, value, ret, k, dataStore);
+  }
+  return ret;
+}
+function validateActionParameterType(dataType, paramDef, value, ret, paramKey, dataStore) {
+  if (paramDef.required && value == null) {
+    ret.result = "INVALID";
+    ret.parameters[paramKey] = {
+      result: "INVALID",
+      evaluatedConstraints: [],
+      required: true
+    };
+    return;
+  }
+  if (!paramDef.required && value == null) {
+    return;
+  }
+  const baseParam = {
+    result: "INVALID",
+    evaluatedConstraints: [],
+    required: paramDef.required
+  };
+  switch (dataType.type) {
+    case "array": {
+      if (!Array.isArray(value)) {
+        ret.result = "INVALID";
+        ret.parameters[paramKey] = {
+          ...baseParam
+        };
+        return;
+      }
+      for (const item of value) {
+        validateActionParameterType(dataType.subType, paramDef, item, ret, paramKey, dataStore);
+      }
+      return;
+    }
+    case "attachment": {
+      if (typeof value !== "string") {
+        ret.result = "INVALID";
+        ret.parameters[paramKey] = {
+          ...baseParam
+        };
+      }
+      return;
+    }
+    case "boolean":
+    case "date":
+    case "long":
+    case "double":
+    case "integer":
+    case "marking":
+    case "objectSet":
+    case "timestamp":
+    case "object":
+    case "string":
+      if (!matchesOntologyDataType(dataType, value)) {
+        ret.result = "INVALID";
+        ret.parameters[paramKey] = {
+          ...baseParam
+        };
+      }
+      return;
+    case "geohash":
+      if (!(typeof value === "string")) {
+        ret.result = "INVALID";
+        ret.parameters[paramKey] = {
+          ...baseParam
+        };
+      }
+      return;
+    case "geoshape":
+      if (!(typeof value === "object" && ("coordinates" in value || "geometries" in value || "features" in value))) {
+        ret.result = "INVALID";
+        ret.parameters[paramKey] = {
+          ...baseParam
+        };
+      }
+      return;
+    case "interfaceObject": {
+      if (!isInterfaceActionParam(value)) {
+        ret.result = "INVALID";
+        ret.parameters[paramKey] = {
+          ...baseParam
+        };
+      } else if (dataStore.getObject(value.objectTypeApiName, value.primaryKeyValue) == null) {
+        ret.result = "INVALID";
+        ret.parameters[paramKey] = {
+          ...baseParam,
+          evaluatedConstraints: [{
+            type: "objectPropertyValue"
+          }]
+        };
+      }
+      return;
+    }
+    case "mediaReference": {
+      if (!isMediaReference(value)) {
+        ret.result = "INVALID";
+        ret.parameters[paramKey] = {
+          ...baseParam
+        };
+      }
+      return;
+    }
+    case "vector": {
+      ret.result = "INVALID";
+      ret.parameters[paramKey] = {
+        ...baseParam
+      };
+      return;
+    }
+    case "struct": {
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        ret.result = "INVALID";
+        ret.parameters[paramKey] = {
+          ...baseParam
+        };
+        return;
+      }
+      for (const {
+        name,
+        fieldType,
+        required
+      } of dataType.fields) {
+        const fieldValue = value[name];
+        if (required && fieldValue == null || !matchesOntologyDataType(fieldType, fieldValue)) {
+          ret.result = "INVALID";
+          ret.parameters[paramKey] = {
+            ...baseParam
+          };
+          return;
+        }
+      }
+      return;
+    }
+    case "objectType": {
+      if (typeof value !== "string" || !dataStore.ontology.getObjectTypeFullMetadata(value)) {
+        ret.result = "INVALID";
+        ret.parameters[paramKey] = {
+          ...baseParam
+        };
+        return;
+      }
+      return;
+    }
+    default: {
+      throw new Error(`validateDataType: unknown type`);
+    }
+  }
+}
+function matchesOntologyDataType(odt, value) {
+  switch (odt.type) {
+    case "any":
+      return true;
+    case "array":
+      return Array.isArray(value) && value.every((v) => matchesOntologyDataType(odt.itemType, v));
+    case "binary":
+      throw new Error(`validateDataType: ${odt.type} not implemented yet.`);
+    case "boolean":
+      return typeof value === "boolean";
+    case "byte":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "cipherText":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "date":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "decimal":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "double":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "float":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "long":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "map":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "marking":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "object":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "objectSet":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "set":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "short":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "string":
+      return typeof value === "string";
+    case "struct":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "timestamp":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    case "unsupported":
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+    default:
+      throw new Error(`matchesOntologyDataType: ${odt.type} not implemented yet.`);
+  }
+}
+function isMediaReference(o) {
+  return typeof o === `object` && typeof o.mimeType === "string" && "reference" in o && typeof o.reference === "object" && o.reference.type === "mediaSetViewItem" && "mediaSetViewItem" in o.reference && typeof o.reference.mediaSetViewItem === "object" && typeof o.reference.mediaSetViewItem.mediaSetRid === "string" && typeof o.reference.mediaSetViewItem.mediaSetViewRid === "string" && typeof o.reference.mediaSetViewItem.mediaItemRid === "string";
+}
+function isInterfaceActionParam(value) {
+  return typeof value === "object" && "objectTypeApiName" in value && typeof value.objectTypeApiName === "string" && "primaryKeyValue" in value && (typeof value.primaryKeyValue === "string" || typeof value.primaryKeyValue === "number" || typeof value.primaryKeyValue === "boolean");
+}
+
+// src/FauxFoundry/FauxDataStore.ts
+var FauxDataStore = class {
+  #objects = new mnemonist.DefaultMap((key) => /* @__PURE__ */ new Map());
+  #singleLinks = new mnemonist.DefaultMap((_objectLocator) => /* @__PURE__ */ new Map());
+  #manyLinks = new mnemonist.DefaultMap((_objectLocator) => new mnemonist.MultiMap(Set));
+  #fauxOntology;
+  #attachments;
+  #timeSeriesData = new mnemonist.DefaultMap((_objectType) => new mnemonist.DefaultMap((_pk) => new mnemonist.DefaultMap((_property) => [])));
+  #media = new mnemonist.DefaultMap((_objectType) => new mnemonist.DefaultMap((_propName) => {
+    return /* @__PURE__ */ new Map();
+  }));
+  constructor(fauxOntology, attachments) {
+    this.#fauxOntology = fauxOntology;
+    this.#attachments = attachments;
+  }
+  /**
+   * Removes all data that is associated with a namespace/ontology.
+   *
+   * Note: does not clear `attachments` nor does it clear the ontology itself.
+   */
+  clear() {
+    this.#media.clear();
+    this.#timeSeriesData.clear();
+    this.#manyLinks.clear();
+    this.#singleLinks.clear();
+    this.#objects.clear();
+  }
+  get ontology() {
+    return this.#fauxOntology;
+  }
+  #assertObjectExists(objectType, primaryKey) {
+    if (!this.getObject(objectType, primaryKey)) {
+      throw new OpenApiCallError(404, ObjectNotFoundError(objectType, String(primaryKey)));
+    }
+  }
+  #assertObjectDoesNotExist(objectType, primaryKey) {
+    if (this.getObject(objectType, primaryKey)) {
+      throw new OpenApiCallError(500, {
+        errorCode: "CONFLICT",
+        errorName: "ObjectAlreadyExists",
+        errorInstanceId: "faux-foundry",
+        parameters: {
+          objectType,
+          primaryKey: String(primaryKey)
+        }
+      });
+    }
+  }
+  /**
+   * Version for use in places like @osdk/client.
+   *
+   * @param obj An `Osdk.Instance` like object for the ObjectType in the generics
+   */
+  /**
+   * Version of register object generally used in shared.test
+   * @param obj A raw server side representation of an object
+   *
+   * Don't use, its too easy to end up with an any.
+   */
+  registerObject(objectType, anyObj) {
+    let bso;
+    if (isBaseServerObject(objectType)) {
+      !(anyObj == null) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Internal overload should only pass one argument") : invariant4__default.default(false) : void 0;
+      !!Object.keys(objectType).some((s) => s.startsWith("$")) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Object should not have any keys starting with $ if it has __apiName") : invariant4__default.default(false) : void 0;
+      bso = objectType;
+    } else if (anyObj == null) {
+      process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "should not be possible due to overloads") : invariant4__default.default(false) ;
+    } else if (isBaseServerObject(anyObj)) {
+      !!Object.keys(anyObj).some((s) => s.startsWith("$")) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Object should not have any keys starting with $ if it has __apiName") : invariant4__default.default(false) : void 0;
+      bso = anyObj;
+    } else {
+      bso = this.#osdkCreatableToBso(objectType, anyObj);
+    }
+    const apiName = bso.__apiName || bso.$apiName;
+    !apiName ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Object should have an __apiName or $apiName") : invariant4__default.default(false) : void 0;
+    this.#assertObjectDoesNotExist(apiName, bso.__primaryKey);
+    if (!("__apiName" in bso && "__primaryKey" in bso)) {
+      !("$apiName" in bso && "$primaryKey" in bso) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Object should have (__apiName and __primaryKey) or ($apiName and $primaryKey)") : invariant4__default.default(false) : void 0;
+      const {
+        $apiName,
+        $primaryKey,
+        ...others
+      } = bso;
+      bso = {
+        __apiName: $apiName,
+        __primaryKey: $primaryKey,
+        ...others
+      };
+    }
+    this.#assertObjectDoesNotExist(bso.__apiName, bso.__primaryKey);
+    this.#objects.get(bso.__apiName).set(String(bso.__primaryKey), Object.freeze({
+      ...bso
+    }));
+  }
+  #osdkCreatableToBso(objectType, anyObj) {
+    objectType = typeof objectType === "string" ? objectType : objectType.apiName;
+    if ("$apiName" in anyObj) {
+      !(anyObj.$apiName === objectType) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false) : invariant4__default.default(false) : void 0;
+    }
+    const {
+      $apiName,
+      $primaryKey,
+      ...others
+    } = anyObj;
+    const meta = this.ontology.getObjectTypeFullMetadataOrThrow(objectType);
+    const realPrimaryKey = anyObj[meta.objectType.primaryKey];
+    const maybeTitle = anyObj[meta.objectType.titleProperty];
+    const rid = anyObj.$rid ?? `ri.phonograph2-objects.main.object.${crypto__namespace.randomUUID()}`;
+    !(realPrimaryKey != null) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, `Object should have a primary key. ${JSON.stringify(anyObj)}`) : invariant4__default.default(false) : void 0;
+    !($primaryKey == null || $primaryKey === realPrimaryKey) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Primary key mismatch") : invariant4__default.default(false) : void 0;
+    return {
+      __apiName: objectType,
+      __primaryKey: realPrimaryKey,
+      __title: maybeTitle ? String(maybeTitle) : void 0,
+      __rid: rid,
+      ...others
+    };
+  }
+  replaceObjectOrThrow(x) {
+    this.#assertObjectExists(x.__apiName, x.__primaryKey);
+    this.#objects.get(x.__apiName).set(String(x.__primaryKey), x);
+  }
+  /** Throws if the object does not already exist */
+  unregisterObjectOrThrow(objectType, primaryKey) {
+    this.#assertObjectExists(objectType, primaryKey);
+    this.#objects.get(objectType).delete(String(primaryKey));
+  }
+  registerLink(src, srcLinkName, dst, destLinkName) {
+    const srcLocator = objectLocator(src);
+    const dstLocator = objectLocator(dst);
+    const [srcSide, dstSide] = this.#fauxOntology.getBothLinkTypeSides(src.__apiName, srcLinkName, dst.__apiName);
+    !(srcSide.linkTypeRid === dstSide.linkTypeRid) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, `Expected both sides of the link to have the same rid, but got ${srcSide.linkTypeRid} and ${dstSide.linkTypeRid}`) : invariant4__default.default(false) : void 0;
+    !(dstSide.apiName === destLinkName) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, `Link name mismatch on dst side. Expected ${destLinkName} but found ${dstSide.apiName}`) : invariant4__default.default(false) : void 0;
+    this.#updateSingleLinkSide(srcSide, srcLocator, dstSide, dstLocator);
+    this.#updateSingleLinkSide(dstSide, dstLocator, srcSide, srcLocator);
+  }
+  unregisterLink(src, srcLinkName, dst, dstLinkName) {
+    const srcLocator = objectLocator(src);
+    const dstLocator = objectLocator(dst);
+    const [srcSide, dstSide] = this.#fauxOntology.getBothLinkTypeSides(src.__apiName, srcLinkName, dst.__apiName);
+    !(dstSide.apiName === dstLinkName) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, `Link name mismatch on dst side. Expected ${dstLinkName} but found ${dstSide.apiName}`) : invariant4__default.default(false) : void 0;
+    this.#removeSingleSideOfLink(srcLocator, srcSide, dstLocator);
+    this.#removeSingleSideOfLink(dstLocator, dstSide, srcLocator);
+  }
+  registerTimeSeriesData(objectType, primaryKey, property, data) {
+    this.getObjectOrThrow(objectType, primaryKey);
+    const def = this.ontology.getObjectTypeFullMetadataOrThrow(objectType);
+    !(def.objectType.properties[property].dataType.type === "timeseries" || def.objectType.properties[property].dataType.type === "geotimeSeriesReference") ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false) : invariant4__default.default(false) : void 0;
+    this.#timeSeriesData.get(objectType).get(String(primaryKey)).set(property, data);
+  }
+  getTimeSeriesData(objectType, primaryKey, property, filter) {
+    this.getObjectOrThrow(objectType, primaryKey);
+    const allData = this.#timeSeriesData.get(objectType).get(String(primaryKey)).get(property);
+    if (!filter) return allData;
+    return filterTimeSeriesData(allData, filter);
+  }
+  #updateSingleLinkSide(srcSide, srcLocator, dstSide, dstLocator) {
+    const srcLinkName = srcSide.apiName;
+    if (srcSide.cardinality === "ONE") {
+      const linkNameToObj = this.#singleLinks.get(srcLocator);
+      const oldLocator = linkNameToObj.get(srcLinkName);
+      if (oldLocator && oldLocator !== dstLocator) {
+        this.#removeSingleSideOfLink(oldLocator, dstSide, srcLocator);
+      }
+      linkNameToObj.set(srcLinkName, dstLocator);
+    } else if (srcSide.cardinality === "MANY") {
+      const linkNameToObj = this.#manyLinks.get(srcLocator);
+      linkNameToObj.set(srcLinkName, dstLocator);
+    } else {
+      throw new Error("unexpected cardinality: " + srcSide.cardinality);
+    }
+  }
+  registerMedia(objectType, property, content, mediaType, path, mediaItemRid = `ri.mio.main.media-item.${crypto.randomUUID()}`) {
+    const mediaRef = Object.freeze({
+      mimeType: mediaType,
+      reference: Object.freeze({
+        type: "mediaSetViewItem",
+        mediaSetViewItem: Object.freeze({
+          mediaItemRid,
+          mediaSetRid: "ri.unimplemented.in.shared.test",
+          mediaSetViewRid: "ri.unimplemented.in.shared.test"
+        })
+      })
+    });
+    this.#media.get(objectType).get(property).set(mediaItemRid, Object.freeze({
+      content,
+      mediaRef,
+      metaData: Object.freeze({
+        mediaType,
+        path,
+        sizeBytes: String(content.byteLength)
+      })
+    }));
+    return mediaRef;
+  }
+  getMediaOrThrow(objectType, primaryKey, property) {
+    const obj = this.getObjectOrThrow(objectType, primaryKey);
+    const propertyDef = this.ontology.getObjectTypeFullMetadataOrThrow(objectType).objectType.properties[property];
+    if (!propertyDef) {
+      throw new OpenApiCallError(400, {
+        errorCode: "NOT_FOUND",
+        errorName: "PropertiesNotFound",
+        errorInstanceId: "faux-foundry",
+        parameters: {
+          objectType,
+          properties: [property]
+        }
+      });
+    }
+    if (propertyDef.dataType.type !== "mediaReference") {
+      throw new OpenApiCallError(400, {
+        errorCode: "INVALID_ARGUMENT",
+        errorName: "InvalidPropertyType",
+        errorInstanceId: "faux-foundry",
+        parameters: {
+          property,
+          propertyBaseType: propertyDef.dataType.type
+        }
+      });
+    }
+    const rid = obj[property].reference.mediaSetViewItem.mediaItemRid;
+    if (!rid || !rid.startsWith("ri.")) {
+      throw new OpenApiCallError(400, {
+        errorCode: "INVALID_ARGUMENT",
+        errorName: "InvalidPropertyValue",
+        errorInstanceId: "faux-foundry",
+        parameters: {
+          property,
+          propertyBaseType: propertyDef.dataType.type,
+          propertyValue: rid
+        }
+      });
+    }
+    const ret = this.#media.get(objectType).get(property).get(rid);
+    if (!ret) {
+      throw new OpenApiCallError(400, InvalidRequest("Invalid parameters"));
+    }
+    return ret;
+  }
+  #removeSingleSideOfLink(locator, linkSide, expectedPriorValue) {
+    const destLinkName = linkSide.apiName;
+    if (linkSide.cardinality === "ONE") {
+      const links = this.#singleLinks.get(locator);
+      !(links.get(destLinkName) === expectedPriorValue) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false) : invariant4__default.default(false) : void 0;
+      links.delete(destLinkName);
+    } else {
+      const links = this.#manyLinks.get(locator);
+      !links.get(destLinkName)?.has(expectedPriorValue) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false) : invariant4__default.default(false) : void 0;
+      links.remove(destLinkName, expectedPriorValue);
+    }
+  }
+  getObject(apiName, primaryKey) {
+    return this.#objects.get(apiName).get(String(primaryKey));
+  }
+  getObjectOrThrow(apiName, primaryKey) {
+    const object = this.getObject(apiName, primaryKey);
+    if (!object) {
+      throw new OpenApiCallError(404, ObjectNotFoundError(apiName, String(primaryKey)));
+    }
+    return object;
+  }
+  getObjectByRid(rid) {
+    for (const [, pkToObjects] of this.#objects) {
+      for (const [, obj] of pkToObjects) {
+        if (obj.__rid === rid) {
+          return obj;
+        }
+      }
+    }
+  }
+  getLinksOrThrow(apiName, primaryKey, linkApiName) {
+    const object = this.getObjectOrThrow(apiName, primaryKey);
+    const linkTypeSide = this.#fauxOntology.getLinkTypeSideV2(apiName, linkApiName);
+    if (linkTypeSide.cardinality === "ONE") {
+      const locator = this.#singleLinks.get(objectLocator(object)).get(linkApiName);
+      if (locator === void 0) {
+        return [];
+      }
+      const {
+        objectType,
+        primaryKey: primaryKey2
+      } = parseLocator(locator);
+      return [this.getObjectOrThrow(objectType, primaryKey2)];
+    } else {
+      const locators = this.#manyLinks.get(objectLocator(object)).get(linkApiName);
+      return Array.from(locators ?? []).map((a) => {
+        const [objectType, primaryKey2] = a.split(":") ?? [];
+        !(objectType && primaryKey2) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Invalid locator format") : invariant4__default.default(false) : void 0;
+        return this.getObjectOrThrow(objectType, primaryKey2);
+      });
+    }
+  }
+  getLinkOrThrow(objectType, primaryKey, linkType, targetPrimaryKey) {
+    const allLinks = this.getLinksOrThrow(objectType, primaryKey, linkType);
+    const object = allLinks.filter((l) => String(l.__primaryKey) === targetPrimaryKey)[0];
+    if (!object) {
+      throw new OpenApiCallError(404, ObjectNotFoundError(`${objectType} -> ${linkType}`, String(targetPrimaryKey)));
+    }
+    return object;
+  }
+  getObjectsOfType(apiName) {
+    return this.#objects.get(apiName).values();
+  }
+  getObjectsFromObjectSet(parsedBody) {
+    const selected = parsedBody.select;
+    let objects = getObjectsFromSet(this, parsedBody.objectSet, void 0);
+    if (!objects) {
+      return {
+        data: [],
+        totalCount: "0",
+        nextPageToken: void 0
+      };
+    }
+    if (parsedBody.orderBy) {
+      objects = objects.sort(createOrderBySortFn(parsedBody.orderBy));
+    }
+    const page = pageThroughResponseSearchParams(objects, getPaginationParamsFromRequest(parsedBody), false);
+    if (!page) {
+      throw new OpenApiCallError(404, InvalidRequest(`No objects found for ${JSON.stringify(parsedBody)}`));
+    }
+    const ret = subSelectProperties(page, [...selected], true, parsedBody.excludeRid);
+    return ret;
+  }
+  getAttachmentMetadata(objectType, primaryKey, propertyName) {
+    const rid = this.getObjectOrThrow(objectType, primaryKey)[propertyName];
+    return this.#attachments.getAttachmentMetadataByRid(rid);
+  }
+  getAttachmentBuffer(objectType, primaryKey, propertyName) {
+    const rid = this.getObjectOrThrow(objectType, primaryKey)[propertyName];
+    return this.#attachments.getAttachmentBuffer(rid);
+  }
+  applyAction(actionTypeApiName, req) {
+    const actionDef = this.#fauxOntology.getActionDef(actionTypeApiName);
+    const actionImpl = this.#fauxOntology.getActionImpl(actionTypeApiName);
+    const validation = validateAction(req, actionDef, this);
+    if (validation.result === "INVALID") {
+      return {
+        validation
+      };
+    }
+    const batch = new FauxDataStoreBatch(this);
+    const r = actionImpl(batch, req, {
+      def: actionDef,
+      attachments: this.#attachments
+    });
+    if (r) return r;
+    return {
+      validation: {
+        parameters: {},
+        result: "VALID",
+        submissionCriteria: []
+      },
+      edits: req.options?.mode === "VALIDATE_AND_EXECUTE" && (req.options.returnEdits === "ALL" || req.options.returnEdits === "ALL_V2_WITH_DELETIONS") ? {
+        type: "edits",
+        ...batch.objectEdits
+      } : void 0
+    };
+  }
+  batchApplyAction(actionTypeApiName, batchReq) {
+    const actionDef = this.#fauxOntology.getActionDef(actionTypeApiName);
+    const actionImpl = this.#fauxOntology.getActionImpl(actionTypeApiName);
+    for (const req of batchReq.requests) {
+      const result = validateAction(req, actionDef, this);
+      if (result.result === "INVALID") {
+        throw new OpenApiCallError(500, {
+          errorCode: "INVALID_ARGUMENT",
+          errorName: "ActionValidationFailed",
+          errorInstanceId: "faux-foundry",
+          parameters: {
+            actionType: actionTypeApiName
+          }
+        });
+      }
+    }
+    const batch = new FauxDataStoreBatch(this);
+    for (const item of batchReq.requests) {
+      actionImpl(batch, {
+        ...item,
+        options: {
+          mode: "VALIDATE_AND_EXECUTE",
+          returnEdits: batchReq.options?.returnEdits
+        }
+      }, {
+        def: actionDef,
+        attachments: this.#attachments
+      });
+    }
+    if (batchReq.options?.returnEdits === "NONE") {
+      return {};
+    }
+    return {
+      edits: {
+        type: "edits",
+        ...batch.objectEdits,
+        edits: batch.objectEdits.edits.filter((x) => x.type !== "deleteObject" && x.type !== "deleteLink")
+      }
+    };
+  }
+};
+
+// src/mock/OntologiesV2/index.ts
+var OntologiesV2_exports2 = {};
+__export(OntologiesV2_exports2, {
+  ActionTypesV2: () => ActionTypesV2_exports,
+  Actions: () => Actions_exports,
+  AttachmentPropertiesV2: () => AttachmentPropertiesV2_exports,
+  Attachments: () => Attachments_exports,
+  LinkedObjectsV2: () => LinkedObjectsV2_exports,
+  MediaReferenceProperties: () => MediaReferenceProperties_exports,
+  ObjectTypesV2: () => ObjectTypesV2_exports,
+  OntologiesV2: () => OntologiesV2_exports,
+  OntologyInterfaces: () => OntologyInterfaces_exports,
+  OntologyObjectSets: () => OntologyObjectSets_exports,
+  OntologyObjectsV2: () => OntologyObjectsV2_exports,
+  Queries: () => Queries_exports,
+  QueryTypes: () => QueryTypes_exports,
+  TimeSeriesPropertiesV2: () => TimeSeriesPropertiesV2_exports,
+  TimeSeriesValueBankProperties: () => TimeSeriesValueBankProperties_exports
+});
+
+// src/mock/OntologiesV2/Actions.ts
+var Actions_exports = {};
+__export(Actions_exports, {
+  apply: () => apply2,
+  applyBatch: () => applyBatch2
+});
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/Action.js
+var Action_exports = {};
+__export(Action_exports, {
+  apply: () => apply,
+  applyAsync: () => applyAsync,
+  applyBatch: () => applyBatch
+});
+
+// ../../node_modules/.pnpm/@osdk+shared.client@1.0.1/node_modules/@osdk/shared.client/index.js
+var symbolClientContext = Symbol("ClientContext");
+
+// ../../node_modules/.pnpm/@osdk+shared.client2@1.0.0/node_modules/@osdk/shared.client2/index.js
+var symbolClientContext2 = "__osdkClientContext";
+
+// ../../node_modules/.pnpm/@osdk+shared.net.errors@2.0.1/node_modules/@osdk/shared.net.errors/build/esm/PalantirApiError.js
+var PalantirApiError = class extends Error {
+  message;
+  errorName;
+  errorCode;
+  statusCode;
+  errorInstanceId;
+  parameters;
+  constructor(message, errorName, errorCode, statusCode, errorInstanceId2, parameters) {
+    super(message);
+    this.message = message;
+    this.errorName = errorName;
+    this.errorCode = errorCode;
+    this.statusCode = statusCode;
+    this.errorInstanceId = errorInstanceId2;
+    this.parameters = parameters;
+  }
+};
+
+// ../../node_modules/.pnpm/@osdk+shared.net.errors@2.0.1/node_modules/@osdk/shared.net.errors/build/esm/UnknownError.js
+var UnknownError = class extends PalantirApiError {
+  originalError;
+  constructor(message, errorType, originalError) {
+    super(message, errorType);
+    this.originalError = originalError;
+  }
+};
+
+// ../../node_modules/.pnpm/@osdk+shared.net.platformapi@1.3.0/node_modules/@osdk/shared.net.platformapi/build/esm/foundryPlatformFetch.js
+async function foundryPlatformFetch(client, [httpMethodNum, origPath, flags, contentType, responseContentType], ...args) {
+  const path = origPath.replace(/\{([^}]+)\}/g, () => encodeURIComponent(args.shift()));
+  const body = flags & 1 ? args.shift() : void 0;
+  const queryArgs = flags & 2 ? args.shift() : void 0;
+  const headerArgs = flags & 4 ? args.shift() : void 0;
+  const method = ["GET", "POST", "PUT", "DELETE", "PATCH"][httpMethodNum];
+  return await apiFetch(client[symbolClientContext2] ?? client[symbolClientContext] ?? client, method, path, body, queryArgs, headerArgs, contentType, responseContentType);
+}
+async function apiFetch(clientCtx, method, endpointPath, data, queryArguments, headers, requestMediaType, responseMediaType) {
+  const url = parseUrl(clientCtx.baseUrl, endpointPath);
+  for (const [key, value] of Object.entries(queryArguments || {})) {
+    if (value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        url.searchParams.append(key, item);
+      }
+    } else {
+      url.searchParams.append(key, value);
+    }
+  }
+  const headersInit = new Headers();
+  headersInit.set("Content-Type", requestMediaType ?? "application/json");
+  headersInit.set("Accept", responseMediaType ?? "application/json");
+  Object.entries(headers || {}).forEach(([key, value]) => {
+    if (value != null) {
+      headersInit.append(key, value.toString());
+    }
+  });
+  const body = data == null || data instanceof globalThis.Blob ? data : JSON.stringify(data);
+  const response = await clientCtx.fetch(url.toString(), {
+    body,
+    method,
+    headers: headersInit
+  });
+  if (!response.ok) {
+    try {
+      const convertedError = await response.json();
+      return new PalantirApiError(convertedError.message, convertedError.errorName, convertedError.errorCode, response.status, convertedError.errorInstanceId, convertedError.parameters);
+    } catch (e) {
+      if (e instanceof Error) {
+        return new UnknownError(e.message, "UNKNOWN");
+      }
+      return new UnknownError("Unable to parse error response", "UNKNOWN");
+    }
+  }
+  if (response.status === 204) {
+    return;
+  }
+  if (responseMediaType == null || responseMediaType === "application/json") {
+    return await response.json();
+  }
+  return response;
+}
+function parseUrl(baseUrl, endpointPath) {
+  baseUrl += baseUrl.endsWith("/") ? "" : "/";
+  return new URL(`api${endpointPath}`, baseUrl);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/Action.js
+var _apply = [1, "/v2/ontologies/{0}/actions/{1}/apply", 3];
+function apply($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _apply, ...args);
+}
+var _applyAsync = [1, "/v2/ontologies/{0}/actions/{1}/applyAsync", 3];
+function applyAsync($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _applyAsync, ...args);
+}
+var _applyBatch = [1, "/v2/ontologies/{0}/actions/{1}/applyBatch", 3];
+function applyBatch($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _applyBatch, ...args);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/ActionTypeV2.js
+var ActionTypeV2_exports = {};
+__export(ActionTypeV2_exports, {
+  get: () => get,
+  getByRid: () => getByRid,
+  list: () => list
+});
+var _list = [0, "/v2/ontologies/{0}/actionTypes", 2];
+function list($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _list, ...args);
+}
+var _get = [0, "/v2/ontologies/{0}/actionTypes/{1}"];
+function get($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _get, ...args);
+}
+var _getByRid = [0, "/v2/ontologies/{0}/actionTypes/byRid/{1}"];
+function getByRid($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getByRid, ...args);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/Attachment.js
+var Attachment_exports = {};
+__export(Attachment_exports, {
+  get: () => get2,
+  read: () => read,
+  upload: () => upload
+});
+var _upload = [1, "/v2/ontologies/attachments/upload", 7, "*/*"];
+function upload($ctx, ...args) {
+  const headerParams = {
+    ...args[2],
+    "Content-Type": args[2]?.["Content-Type"] ?? args[0].type,
+    "Content-Length": args[0].size.toString()
+  };
+  return foundryPlatformFetch($ctx, _upload, args[0], args[1], headerParams);
+}
+var _read = [0, "/v2/ontologies/attachments/{0}/content", , , "*/*"];
+function read($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _read, ...args);
+}
+var _get2 = [0, "/v2/ontologies/attachments/{0}"];
+function get2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _get2, ...args);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/AttachmentPropertyV2.js
+var AttachmentPropertyV2_exports = {};
+__export(AttachmentPropertyV2_exports, {
+  getAttachment: () => getAttachment,
+  getAttachmentByRid: () => getAttachmentByRid,
+  readAttachment: () => readAttachment,
+  readAttachmentByRid: () => readAttachmentByRid
+});
+var _getAttachment = [0, "/v2/ontologies/{0}/objects/{1}/{2}/attachments/{3}", 2];
+function getAttachment($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getAttachment, ...args);
+}
+var _getAttachmentByRid = [0, "/v2/ontologies/{0}/objects/{1}/{2}/attachments/{3}/{4}", 2];
+function getAttachmentByRid($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getAttachmentByRid, ...args);
+}
+var _readAttachment = [0, "/v2/ontologies/{0}/objects/{1}/{2}/attachments/{3}/content", 2, , "*/*"];
+function readAttachment($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _readAttachment, ...args);
+}
+var _readAttachmentByRid = [0, "/v2/ontologies/{0}/objects/{1}/{2}/attachments/{3}/{4}/content", 2, , "*/*"];
+function readAttachmentByRid($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _readAttachmentByRid, ...args);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/LinkedObjectV2.js
+var LinkedObjectV2_exports = {};
+__export(LinkedObjectV2_exports, {
+  getLinkedObject: () => getLinkedObject,
+  listLinkedObjects: () => listLinkedObjects
+});
+var _listLinkedObjects = [0, "/v2/ontologies/{0}/objects/{1}/{2}/links/{3}", 2];
+function listLinkedObjects($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listLinkedObjects, ...args);
+}
+var _getLinkedObject = [0, "/v2/ontologies/{0}/objects/{1}/{2}/links/{3}/{4}", 2];
+function getLinkedObject($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getLinkedObject, ...args);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/MediaReferenceProperty.js
+var MediaReferenceProperty_exports = {};
+__export(MediaReferenceProperty_exports, {
+  getMediaContent: () => getMediaContent,
+  getMediaMetadata: () => getMediaMetadata,
+  upload: () => upload2
+});
+var _getMediaContent = [0, "/v2/ontologies/{0}/objects/{1}/{2}/media/{3}/content", 2, , "*/*"];
+function getMediaContent($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getMediaContent, ...args);
+}
+var _getMediaMetadata = [0, "/v2/ontologies/{0}/objects/{1}/{2}/media/{3}/metadata", 2];
+function getMediaMetadata($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getMediaMetadata, ...args);
+}
+var _upload2 = [1, "/v2/ontologies/{0}/objectTypes/{1}/media/{2}/upload", 3, "*/*"];
+function upload2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _upload2, ...args);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/ObjectTypeV2.js
+var ObjectTypeV2_exports = {};
+__export(ObjectTypeV2_exports, {
+  get: () => get3,
+  getFullMetadata: () => getFullMetadata,
+  getOutgoingLinkType: () => getOutgoingLinkType,
+  list: () => list2,
+  listOutgoingLinkTypes: () => listOutgoingLinkTypes
+});
+var _list2 = [0, "/v2/ontologies/{0}/objectTypes", 2];
+function list2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _list2, ...args);
+}
+var _get3 = [0, "/v2/ontologies/{0}/objectTypes/{1}"];
+function get3($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _get3, ...args);
+}
+var _getFullMetadata = [0, "/v2/ontologies/{0}/objectTypes/{1}/fullMetadata", 2];
+function getFullMetadata($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getFullMetadata, ...args);
+}
+var _listOutgoingLinkTypes = [0, "/v2/ontologies/{0}/objectTypes/{1}/outgoingLinkTypes", 2];
+function listOutgoingLinkTypes($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listOutgoingLinkTypes, ...args);
+}
+var _getOutgoingLinkType = [0, "/v2/ontologies/{0}/objectTypes/{1}/outgoingLinkTypes/{2}"];
+function getOutgoingLinkType($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getOutgoingLinkType, ...args);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/OntologyInterface.js
+var OntologyInterface_exports = {};
+__export(OntologyInterface_exports, {
+  aggregate: () => aggregate,
+  get: () => get4,
+  list: () => list3,
+  search: () => search
+});
+var _list3 = [0, "/v2/ontologies/{0}/interfaceTypes", 2];
+function list3($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _list3, ...args);
+}
+var _get4 = [0, "/v2/ontologies/{0}/interfaceTypes/{1}", 2];
+function get4($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _get4, ...args);
+}
+var _search = [1, "/v2/ontologies/{0}/interfaces/{1}/search", 3];
+function search($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _search, ...args);
+}
+var _aggregate = [1, "/v2/ontologies/{0}/interfaces/{1}/aggregate", 3];
+function aggregate($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _aggregate, ...args);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/OntologyObjectSet.js
+var OntologyObjectSet_exports = {};
+__export(OntologyObjectSet_exports, {
+  aggregate: () => aggregate2,
+  createTemporary: () => createTemporary,
+  get: () => get5,
+  load: () => load,
+  loadMultipleObjectTypes: () => loadMultipleObjectTypes,
+  loadObjectsOrInterfaces: () => loadObjectsOrInterfaces
+});
+var _createTemporary = [1, "/v2/ontologies/{0}/objectSets/createTemporary", 1];
+function createTemporary($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _createTemporary, ...args);
+}
+var _get5 = [0, "/v2/ontologies/{0}/objectSets/{1}"];
+function get5($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _get5, ...args);
+}
+var _load = [1, "/v2/ontologies/{0}/objectSets/loadObjects", 3];
+function load($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _load, ...args);
+}
+var _loadMultipleObjectTypes = [1, "/v2/ontologies/{0}/objectSets/loadObjectsMultipleObjectTypes", 3];
+function loadMultipleObjectTypes($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _loadMultipleObjectTypes, ...args);
+}
+var _loadObjectsOrInterfaces = [1, "/v2/ontologies/{0}/objectSets/loadObjectsOrInterfaces", 3];
+function loadObjectsOrInterfaces($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _loadObjectsOrInterfaces, ...args);
+}
+var _aggregate2 = [1, "/v2/ontologies/{0}/objectSets/aggregate", 3];
+function aggregate2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _aggregate2, ...args);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/OntologyObjectV2.js
+var OntologyObjectV2_exports = {};
+__export(OntologyObjectV2_exports, {
+  aggregate: () => aggregate3,
+  count: () => count,
+  get: () => get6,
+  list: () => list4,
+  search: () => search2
+});
+var _list4 = [0, "/v2/ontologies/{0}/objects/{1}", 2];
+function list4($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _list4, ...args);
+}
+var _get6 = [0, "/v2/ontologies/{0}/objects/{1}/{2}", 2];
+function get6($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _get6, ...args);
+}
+var _count = [1, "/v2/ontologies/{0}/objects/{1}/count", 2];
+function count($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _count, ...args);
+}
+var _search2 = [1, "/v2/ontologies/{0}/objects/{1}/search", 3];
+function search2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _search2, ...args);
+}
+var _aggregate3 = [1, "/v2/ontologies/{0}/objects/{1}/aggregate", 3];
+function aggregate3($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _aggregate3, ...args);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/OntologyV2.js
+var OntologyV2_exports = {};
+__export(OntologyV2_exports, {
+  get: () => get7,
+  getFullMetadata: () => getFullMetadata2,
+  list: () => list5,
+  loadMetadata: () => loadMetadata
+});
+var _list5 = [0, "/v2/ontologies"];
+function list5($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _list5, ...args);
+}
+var _get7 = [0, "/v2/ontologies/{0}"];
+function get7($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _get7, ...args);
+}
+var _getFullMetadata2 = [0, "/v2/ontologies/{0}/fullMetadata"];
+function getFullMetadata2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getFullMetadata2, ...args);
+}
+var _loadMetadata = [1, "/v2/ontologies/{0}/metadata", 3];
+function loadMetadata($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _loadMetadata, ...args);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/Query.js
+var Query_exports = {};
+__export(Query_exports, {
+  execute: () => execute
+});
+var _execute = [1, "/v2/ontologies/{0}/queries/{1}/execute", 3];
+function execute($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _execute, ...args);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/QueryType.js
+var QueryType_exports = {};
+__export(QueryType_exports, {
+  get: () => get8,
+  list: () => list6
+});
+var _list6 = [0, "/v2/ontologies/{0}/queryTypes", 2];
+function list6($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _list6, ...args);
+}
+var _get8 = [0, "/v2/ontologies/{0}/queryTypes/{1}", 2];
+function get8($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _get8, ...args);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/TimeSeriesPropertyV2.js
+var TimeSeriesPropertyV2_exports = {};
+__export(TimeSeriesPropertyV2_exports, {
+  getFirstPoint: () => getFirstPoint,
+  getLastPoint: () => getLastPoint,
+  streamPoints: () => streamPoints
+});
+var _getFirstPoint = [0, "/v2/ontologies/{0}/objects/{1}/{2}/timeseries/{3}/firstPoint", 2];
+function getFirstPoint($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getFirstPoint, ...args);
+}
+var _getLastPoint = [0, "/v2/ontologies/{0}/objects/{1}/{2}/timeseries/{3}/lastPoint", 2];
+function getLastPoint($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getLastPoint, ...args);
+}
+var _streamPoints = [1, "/v2/ontologies/{0}/objects/{1}/{2}/timeseries/{3}/streamPoints", 3, , "*/*"];
+function streamPoints($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _streamPoints, ...args);
+}
+
+// ../../node_modules/.pnpm/@osdk+foundry.ontologies@2.20.0/node_modules/@osdk/foundry.ontologies/build/esm/public/TimeSeriesValueBankProperty.js
+var TimeSeriesValueBankProperty_exports = {};
+__export(TimeSeriesValueBankProperty_exports, {
+  getLatestValue: () => getLatestValue,
+  streamValues: () => streamValues
+});
+var _getLatestValue = [0, "/v2/ontologies/{0}/objects/{1}/{2}/timeseries/{3}/latestValue", 2];
+function getLatestValue($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getLatestValue, ...args);
+}
+var _streamValues = [1, "/v2/ontologies/{0}/objects/{1}/{2}/timeseries/{3}/streamValues", 3, , "*/*"];
+function streamValues($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _streamValues, ...args);
+}
+
+// src/mock/OntologiesV2/Actions.ts
+var applyBatch2 = handleOpenApiCall(Action_exports.applyBatch, ["ontologyApiName", "actionType"]);
+var apply2 = handleOpenApiCall(Action_exports.apply, ["ontologyApiName", "actionType"]);
+
+// src/mock/OntologiesV2/ActionTypesV2.ts
+var ActionTypesV2_exports = {};
+__export(ActionTypesV2_exports, {
+  get: () => get9,
+  list: () => list7
+});
+var list7 = handleOpenApiCall(ActionTypeV2_exports.list, ["ontologyApiName"]);
+var get9 = handleOpenApiCall(ActionTypeV2_exports.get, ["ontologyApiName", "actionTypeApiName"]);
+
+// src/mock/OntologiesV2/AttachmentPropertiesV2.ts
+var AttachmentPropertiesV2_exports = {};
+__export(AttachmentPropertiesV2_exports, {
+  getAttachment: () => getAttachment2,
+  readAttachment: () => readAttachment2
+});
+var getAttachment2 = handleOpenApiCall(AttachmentPropertyV2_exports.getAttachment, ["ontologyApiName", "objectType", "primaryKey", "propertyName"]);
+var readAttachment2 = handleOpenApiCall(AttachmentPropertyV2_exports.readAttachment, ["ontologyApiName", "objectType", "primaryKey", "propertyName"]);
+
+// src/mock/OntologiesV2/Attachments.ts
+var Attachments_exports = {};
+__export(Attachments_exports, {
+  get: () => get10,
+  read: () => read2,
+  upload: () => upload3
+});
+var upload3 = handleOpenApiCall(Attachment_exports.upload, []);
+var get10 = handleOpenApiCall(Attachment_exports.get, ["attachmentRid"]);
+var read2 = handleOpenApiCall(Attachment_exports.read, ["attachmentRid"]);
+
+// src/mock/OntologiesV2/LinkedObjectsV2.ts
+var LinkedObjectsV2_exports = {};
+__export(LinkedObjectsV2_exports, {
+  getLinkedObject: () => getLinkedObject2,
+  listLinkedObjects: () => listLinkedObjects2
+});
+var listLinkedObjects2 = handleOpenApiCall(LinkedObjectV2_exports.listLinkedObjects, ["ontologyApiName", "objectType", "primaryKey", "linkType"]);
+var getLinkedObject2 = handleOpenApiCall(LinkedObjectV2_exports.getLinkedObject, ["ontologyApiName", "objectType", "primaryKey", "linkType", "targetPrimaryKey"]);
+
+// src/mock/OntologiesV2/MediaReferenceProperties.ts
+var MediaReferenceProperties_exports = {};
+__export(MediaReferenceProperties_exports, {
+  getMediaContent: () => getMediaContent2,
+  getMediaMetadata: () => getMediaMetadata2,
+  upload: () => upload4
+});
+var getMediaMetadata2 = handleOpenApiCall(MediaReferenceProperty_exports.getMediaMetadata, ["ontologyApiName", "objectType", "primaryKey", "propertyName"]);
+var getMediaContent2 = handleOpenApiCall(MediaReferenceProperty_exports.getMediaContent, ["ontologyApiName", "objectType", "primaryKey", "propertyName"]);
+var upload4 = handleOpenApiCall(MediaReferenceProperty_exports.upload, ["ontologyApiName", "objectType", "propertyName"]);
+
+// src/mock/OntologiesV2/ObjectTypesV2.ts
+var ObjectTypesV2_exports = {};
+__export(ObjectTypesV2_exports, {
+  get: () => get11,
+  getFullMetadata: () => getFullMetadata3,
+  getOutgoingLinkType: () => getOutgoingLinkType2,
+  list: () => list8,
+  listOutgoingLinkTypes: () => listOutgoingLinkTypes2
+});
+var get11 = handleOpenApiCall(ObjectTypeV2_exports.get, ["ontologyApiName", "objectTypeApiName"]);
+var getFullMetadata3 = handleOpenApiCall(ObjectTypeV2_exports.getFullMetadata, ["ontologyApiName", "objectTypeApiName"]);
+var getOutgoingLinkType2 = handleOpenApiCall(ObjectTypeV2_exports.getOutgoingLinkType, ["ontology", "objectType", "linkType"]);
+var listOutgoingLinkTypes2 = handleOpenApiCall(ObjectTypeV2_exports.listOutgoingLinkTypes, ["ontology", "objectType"]);
+var list8 = handleOpenApiCall(ObjectTypeV2_exports.list, ["ontologyApiName"]);
+
+// src/mock/OntologiesV2/OntologiesV2.ts
+var OntologiesV2_exports = {};
+__export(OntologiesV2_exports, {
+  get: () => get12,
+  getFullMetadata: () => getFullMetadata4,
+  list: () => list9,
+  loadMetadata: () => loadMetadata2
+});
+var getFullMetadata4 = handleOpenApiCall(OntologyV2_exports.getFullMetadata, ["ontologyApiName"]);
+var loadMetadata2 = handleOpenApiCall(OntologyV2_exports.loadMetadata, ["ontologyApiName"]);
+var list9 = handleOpenApiCall(OntologyV2_exports.list, []);
+var get12 = handleOpenApiCall(OntologyV2_exports.get, ["ontologyRid"]);
+
+// src/mock/OntologiesV2/OntologyInterfaces.ts
+var OntologyInterfaces_exports = {};
+__export(OntologyInterfaces_exports, {
+  get: () => get13,
+  list: () => list10
+});
+var list10 = handleOpenApiCall(OntologyInterface_exports.list, ["ontologyApiName"]);
+var get13 = handleOpenApiCall(OntologyInterface_exports.get, ["ontologyApiName", "interfaceType"]);
+
+// src/mock/OntologiesV2/OntologyObjectSets.ts
+var OntologyObjectSets_exports = {};
+__export(OntologyObjectSets_exports, {
+  aggregate: () => aggregate4,
+  load: () => load2,
+  loadMultipleObjectTypes: () => loadMultipleObjectTypes2
+});
+var load2 = handleOpenApiCall(OntologyObjectSet_exports.load, ["ontologyApiName"]);
+var aggregate4 = handleOpenApiCall(OntologyObjectSet_exports.aggregate, ["ontologyApiName"]);
+var loadMultipleObjectTypes2 = handleOpenApiCall(OntologyObjectSet_exports.loadMultipleObjectTypes, ["ontologyApiName"]);
+
+// src/mock/OntologiesV2/OntologyObjectsV2.ts
+var OntologyObjectsV2_exports = {};
+__export(OntologyObjectsV2_exports, {
+  get: () => get14,
+  list: () => list11
+});
+var get14 = handleOpenApiCall(OntologyObjectV2_exports.get, ["ontologyApiName", "objectType", "primaryKey"]);
+var list11 = handleOpenApiCall(OntologyObjectV2_exports.list, ["ontologyApiName", "objectType"]);
+
+// src/mock/OntologiesV2/Queries.ts
+var Queries_exports = {};
+__export(Queries_exports, {
+  execute: () => execute2
+});
+var execute2 = handleOpenApiCall(Query_exports.execute, ["ontologyApiName", "queryApiName"]);
+
+// src/mock/OntologiesV2/QueryTypes.ts
+var QueryTypes_exports = {};
+__export(QueryTypes_exports, {
+  get: () => get15,
+  list: () => list12
+});
+var get15 = handleOpenApiCall(QueryType_exports.get, ["ontologyApiName", "queryTypeApiName"]);
+var list12 = handleOpenApiCall(QueryType_exports.list, ["ontologyApiName"]);
+
+// src/mock/OntologiesV2/TimeSeriesPropertiesV2.ts
+var TimeSeriesPropertiesV2_exports = {};
+__export(TimeSeriesPropertiesV2_exports, {
+  getFirstPoint: () => getFirstPoint2,
+  getLastPoint: () => getLastPoint2,
+  streamPoints: () => streamPoints2
+});
+var getFirstPoint2 = handleOpenApiCall(TimeSeriesPropertyV2_exports.getFirstPoint, ["ontologyApiName", "objectType", "primaryKey", "propertyName"]);
+var getLastPoint2 = handleOpenApiCall(TimeSeriesPropertyV2_exports.getLastPoint, ["ontologyApiName", "objectType", "primaryKey", "propertyName"]);
+var streamPoints2 = handleOpenApiCall(TimeSeriesPropertyV2_exports.streamPoints, ["ontologyApiName", "objectType", "primaryKey", "propertyName"]);
+
+// src/mock/OntologiesV2/TimeSeriesValueBankProperties.ts
+var TimeSeriesValueBankProperties_exports = {};
+__export(TimeSeriesValueBankProperties_exports, {
+  getLatestValue: () => getLatestValue2,
+  streamValues: () => streamValues2
+});
+var getLatestValue2 = handleOpenApiCall(TimeSeriesValueBankProperty_exports.getLatestValue, ["ontologyApiName", "objectType", "primaryKey", "propertyName"]);
+var streamValues2 = handleOpenApiCall(TimeSeriesValueBankProperty_exports.streamValues, ["ontologyApiName", "objectType", "primaryKey", "propertyName"]);
+
+// src/handlers/createActionHandlers.ts
+var createActionHandlers = (baseUrl, fauxFoundry) => [
+  /**
+   * Apply an Action
+   */
+  OntologiesV2_exports2.Actions.apply(baseUrl, async ({
+    params: {
+      ontologyApiName,
+      actionType
+    },
+    request
+  }) => {
+    const response = fauxFoundry.getDataStore(ontologyApiName).applyAction(actionType, await request.json());
+    if (!response) {
+      throw new OpenApiCallError(400, ApplyActionFailedError);
+    }
+    return response;
+  }),
+  OntologiesV2_exports2.Actions.applyBatch(baseUrl, async ({
+    params: {
+      ontologyApiName,
+      actionType
+    },
+    request
+  }) => {
+    return fauxFoundry.getDataStore(ontologyApiName).batchApplyAction(actionType, await request.json());
+  })
+];
+
+// src/handlers/util/requireSearchParams.ts
+function requireSearchParams(names, req) {
+  const url = new URL(req.url);
+  return Object.fromEntries(names.map((name) => {
+    const value = url.searchParams.get(name);
+    if (value == null) {
+      throw new OpenApiCallError(400, InvalidRequest("Invalid parameters"));
+    }
+    return [name, value];
+  }));
+}
+
+// src/handlers/createAttachmentHandlers.ts
+var createAttachmentHandlers = (baseUrl, fauxFoundry) => [
+  /**
+   * Upload attachment
+   */
+  OntologiesV2_exports2.Attachments.upload(baseUrl, async ({
+    request
+  }) => {
+    const {
+      filename
+    } = requireSearchParams(["filename"], request);
+    return fauxFoundry.attachments.registerAttachment({
+      buffer: await request.arrayBuffer(),
+      filename,
+      mediaType: request.headers.get("Content-Type") ?? "application/octet-stream",
+      rid: `ri.attachments.main.attachment.${crypto.randomUUID()}`
+    });
+  }),
+  /**
+   * Get attachment metadata V1
+   */
+  OntologiesV2_exports2.Attachments.get(baseUrl, async ({
+    params
+  }) => {
+    return fauxFoundry.attachments.getAttachmentMetadataByRid(params.attachmentRid);
+  }),
+  /**
+   * Get attachment metadata V2
+   */
+  OntologiesV2_exports2.AttachmentPropertiesV2.getAttachment(baseUrl, async ({
+    params: {
+      ontologyApiName,
+      primaryKey,
+      objectType,
+      propertyName
+    }
+  }) => {
+    return {
+      ...fauxFoundry.getDataStore(ontologyApiName).getAttachmentMetadata(objectType, primaryKey, propertyName),
+      type: "single"
+    };
+  }),
+  /**
+   * Read attachment content V1
+   */
+  OntologiesV2_exports2.Attachments.read(baseUrl, async ({
+    params
+  }) => {
+    return new Response(fauxFoundry.attachments.getAttachmentBuffer(params.attachmentRid));
+  }),
+  /**
+   * Read attachment content V2
+   */
+  OntologiesV2_exports2.AttachmentPropertiesV2.readAttachment(baseUrl, async ({
+    params: {
+      ontologyApiName,
+      primaryKey,
+      objectType,
+      propertyName
+    }
+  }) => {
+    return new Response(fauxFoundry.getDataStore(ontologyApiName).getAttachmentBuffer(objectType, primaryKey, propertyName));
+  })
+];
+
+// src/handlers/createLoadObjectsHandlers.ts
+var createLoadObjectsHandlers = (baseUrl, fauxFoundry) => [
+  /**
+   * Load object
+   */
+  OntologiesV2_exports2.OntologyObjectsV2.get(baseUrl, async ({
+    request,
+    params: {
+      ontologyApiName,
+      objectType,
+      primaryKey
+    }
+  }) => {
+    return subSelectPropertiesUrl(fauxFoundry.getDataStore(ontologyApiName).getObjectOrThrow(objectType, primaryKey), new URL(request.url));
+  }),
+  /**
+   * Load all objects
+   */
+  OntologiesV2_exports2.OntologyObjectsV2.list(baseUrl, async ({
+    request,
+    params: {
+      ontologyApiName,
+      objectType
+    }
+  }) => {
+    const loadObjects = pageThroughResponseSearchParams(fauxFoundry.getDataStore(ontologyApiName).getObjectsOfType(objectType), getPaginationParamsFromUrl(request), true);
+    if (loadObjects) {
+      return subSelectProperties(loadObjects, new URL(request.url));
+    }
+    throw new OpenApiCallError(400, InvalidRequest("Invalid Request"));
+  }),
+  /**
+   * List Linked Objects
+   */
+  OntologiesV2_exports2.LinkedObjectsV2.listLinkedObjects(baseUrl, async ({
+    request,
+    params: {
+      primaryKey,
+      linkType,
+      objectType,
+      ontologyApiName
+    }
+  }) => {
+    const linkResults = fauxFoundry.getDataStore(ontologyApiName).getLinksOrThrow(objectType, primaryKey, linkType);
+    const objects = pageThroughResponseSearchParams(linkResults, getPaginationParamsFromUrl(request), true);
+    if (objects) {
+      return subSelectProperties(objects, new URL(request.url));
+    }
+    throw new OpenApiCallError(400, InvalidRequest("Invalid Request"));
+  }),
+  /**
+   * Get specific Linked Object
+   */
+  OntologiesV2_exports2.LinkedObjectsV2.getLinkedObject(baseUrl, async ({
+    request,
+    params: {
+      ontologyApiName,
+      objectType,
+      primaryKey,
+      linkType,
+      targetPrimaryKey
+    }
+  }) => {
+    const object = fauxFoundry.getDataStore(ontologyApiName).getLinkOrThrow(objectType, primaryKey, linkType, targetPrimaryKey);
+    return subSelectPropertiesUrl(object, new URL(request.url));
+  })
+];
+
+// src/handlers/createMediaRefHandlers.ts
+var createMediaRefHandlers = (baseUrl, fauxFoundry) => [
+  /**
+   * Load media metadata
+   */
+  OntologiesV2_exports2.MediaReferenceProperties.getMediaMetadata(baseUrl, async ({
+    params: {
+      ontologyApiName,
+      objectType,
+      primaryKey,
+      propertyName
+    }
+  }) => {
+    return fauxFoundry.getDataStore(ontologyApiName).getMediaOrThrow(objectType, primaryKey, propertyName).metaData;
+  }),
+  /**
+   * Read media content
+   */
+  OntologiesV2_exports2.MediaReferenceProperties.getMediaContent(baseUrl, async ({
+    params: {
+      ontologyApiName,
+      objectType,
+      primaryKey,
+      propertyName
+    }
+  }) => {
+    const {
+      content,
+      metaData: {
+        mediaType
+      }
+    } = fauxFoundry.getDataStore(ontologyApiName).getMediaOrThrow(objectType, primaryKey, propertyName);
+    return new Response(content, {
+      headers: {
+        "Content-Type": mediaType
+      }
+    });
+  }),
+  OntologiesV2_exports2.MediaReferenceProperties.upload(baseUrl, async ({
+    params: {
+      ontologyApiName,
+      objectType,
+      propertyName
+    },
+    request
+  }) => {
+    const {
+      mediaItemPath
+    } = requireSearchParams(["mediaItemPath"], request);
+    return fauxFoundry.getDataStore(ontologyApiName).registerMedia(objectType, propertyName, await request.arrayBuffer(), request.headers.get("Content-Type") ?? "application/octet-stream", mediaItemPath);
+  })
+];
+var createMultipassServerHandlers = (baseUrl, fauxFoundry) => [msw.http.post(`${baseUrl}/multipass/api/oauth2/token`, async (req) => {
+  const body = await req.request.text();
+  const parsedBody = new URLSearchParams(body);
+  const parsedBodyArray = Array.from(parsedBody.entries());
+  if (parsedBody.get("grant_type") === "client_credentials" && parsedBody.get("client_id") === "myClientId" && parsedBody.get("client_secret") === "myClientSecret" && parsedBody.get("scopes")?.includes("offline_access") && parsedBodyArray.length === 4) {
+    return msw.HttpResponse.json({
+      access_token: "myAccessToken",
+      token_type: "bearer",
+      refresh_token: "myRefreshToken",
+      expires_in: 3600
+    });
+  }
+  if (parsedBody.get("client_id") === "myClientId" && parsedBody.get("grant_type") === "authorization_code" && parsedBody.get("code") === "callBackCode" && parsedBody.get("redirect_uri") === "localhost" && parsedBody.get("code_verifier") === "01020304" && parsedBodyArray.length === 5) {
+    return msw.HttpResponse.json({
+      access_token: "myAccessToken",
+      token_type: "bearer",
+      refresh_token: "myRefreshToken",
+      expires_in: 3600
+    });
+  }
+  if (parsedBody.get("client_id") === "myClientId" && parsedBody.get("grant_type") === "refresh_token" && parsedBody.get("refresh_token") === "myRefreshToken" && parsedBodyArray.length === 3) {
+    return msw.HttpResponse.json({
+      access_token: "refreshedAccessToken",
+      token_type: "bearer",
+      refresh_token: "refreshedRefreshToken",
+      expires_in: 3600
+    });
+  }
+  return msw.HttpResponse.json({
+    message: "Invalid request body"
+  }, {
+    status: 400
+  });
+}), msw.http.post("https://stack.palantir.com/multipass/api/oauth2/revoke_token", async (req) => {
+  const body = await req.request.text();
+  const parsedBody = new URLSearchParams(body);
+  const parsedBodyArray = Array.from(parsedBody.entries());
+  if (parsedBodyArray.length === 3 && parsedBody.get("client_id") === "myClientId" && parsedBody.get("client_secret") === "myClientSecret" && parsedBody.get("token") === "myAccessToken") {
+    return msw.HttpResponse.json({});
+  }
+  if (parsedBodyArray.length === 2 && parsedBody.get("client_id") === "myClientId" && parsedBody.get("token") === "myAccessToken") {
+    return msw.HttpResponse.json({});
+  }
+  return msw.HttpResponse.json({
+    message: "Invalid request body"
+  }, {
+    status: 400
+  });
+})];
+
+// src/handlers/createObjectSetHandlers.ts
+var createObjectSetHandlers = (baseUrl, fauxFoundry) => [
+  /**
+   * Load ObjectSet Objects
+   */
+  OntologiesV2_exports2.OntologyObjectSets.load(baseUrl, async ({
+    request,
+    params
+  }) => {
+    return fauxFoundry.getDataStore(params.ontologyApiName).getObjectsFromObjectSet(await request.json());
+  }),
+  /**
+   * Aggregate Objects in ObjectSet
+   */
+  OntologiesV2_exports2.OntologyObjectSets.aggregate(baseUrl, async ({
+    request
+  }) => {
+    throw new Error("Not implemented");
+  }),
+  /**
+   * Load interface objectset Objects
+   */
+  OntologiesV2_exports2.OntologyObjectSets.loadMultipleObjectTypes(baseUrl, async ({
+    params,
+    request
+  }) => {
+    const pagedResponse = fauxFoundry.getDataStore(params.ontologyApiName).getObjectsFromObjectSet(await request.json());
+    const objectApiNames = new Set(pagedResponse.data.map((o) => o.__apiName));
+    return {
+      interfaceToObjectTypeMappings: fauxFoundry.getOntology(params.ontologyApiName).getInterfaceToObjectTypeMappings(objectApiNames),
+      ...pagedResponse
+    };
+  })
+];
+
+// src/defaultOntologyMetadata.ts
+var defaultOntologyMetadata = {
+  apiName: "default-ontology",
+  displayName: "Ontology",
+  description: "The default ontology",
+  rid: "ri.ontology.main.ontology.698267cc-6b48-4d98-beff-29beb24e9361"
+};
+
+// src/defaultOntologyForConjure.ts
+var defaultOntologyForConjure = {
+  apiName: defaultOntologyMetadata.apiName,
+  displayName: defaultOntologyMetadata.displayName,
+  description: defaultOntologyMetadata.description,
+  currentOntologyVersion: "0000000c-aaaa-bbbb-cccc-ddddeeeeffff",
+  defaultBranchRid: "ri.ontology.main.branch.99999999-8888-7777-6666-555555555555"
+};
+
+// src/handlers/createOntologyHandlers.ts
+var createOntologyHandlers = (baseUrl, fauxFoundry) => [
+  /**
+   * Load full Ontology metadata
+   */
+  OntologiesV2_exports2.OntologiesV2.getFullMetadata(baseUrl, async (req) => {
+    return fauxFoundry.getOntology(req.params.ontologyApiName).getOntologyFullMetadata();
+  }),
+  /**
+   * Load ontology metadata for the requested object, link, action, query, and interface types.
+   */
+  OntologiesV2_exports2.OntologiesV2.loadMetadata(baseUrl, async ({
+    params,
+    request
+  }) => {
+    return fauxFoundry.getOntology(params.ontologyApiName).getFilteredOntologyMetadata(await request.json());
+  }),
+  OntologiesV2_exports2.ObjectTypesV2.get(baseUrl, async (req) => {
+    return fauxFoundry.getOntology(req.params.ontologyApiName).getObjectTypeFullMetadataOrThrow(req.params.objectTypeApiName).objectType;
+  }),
+  OntologiesV2_exports2.ObjectTypesV2.getFullMetadata(baseUrl, async (req) => {
+    return fauxFoundry.getOntology(req.params.ontologyApiName).getObjectTypeFullMetadataOrThrow(req.params.objectTypeApiName);
+  }),
+  /**
+   * List ActionTypes
+   */
+  OntologiesV2_exports2.ActionTypesV2.list(baseUrl, async ({
+    params
+  }) => {
+    return {
+      data: fauxFoundry.getOntology(params.ontologyApiName).getAllActionTypes()
+    };
+  }),
+  OntologiesV2_exports2.ActionTypesV2.get(baseUrl, async (req) => {
+    return fauxFoundry.getOntology(req.params.ontologyApiName).getActionDef(req.params.actionTypeApiName);
+  }),
+  OntologiesV2_exports2.QueryTypes.get(baseUrl, async (req) => {
+    const queryParams = Object.fromEntries(new URL(req.request.url).searchParams.entries());
+    const version = queryParams["version"];
+    return fauxFoundry.getOntology(req.params.ontologyApiName).getQueryDef(version ? `${req.params.queryTypeApiName}:${version}` : req.params.queryTypeApiName);
+  }),
+  OntologiesV2_exports2.ObjectTypesV2.getOutgoingLinkType(baseUrl, async ({
+    params
+  }) => {
+    return fauxFoundry.getOntology(params.ontology).getLinkTypeSideV2(params.objectType, params.linkType);
+  }),
+  OntologiesV2_exports2.ObjectTypesV2.listOutgoingLinkTypes(baseUrl, async ({
+    params
+  }) => {
+    return {
+      data: fauxFoundry.getOntology(params.ontology).getObjectTypeFullMetadataOrThrow(params.objectType).linkTypes
+    };
+  }),
+  OntologiesV2_exports2.OntologyInterfaces.list(baseUrl, async (req) => {
+    return {
+      data: fauxFoundry.getOntology(req.params.ontologyApiName).getAllInterfaceTypes()
+    };
+  }),
+  OntologiesV2_exports2.OntologyInterfaces.get(baseUrl, ({
+    params
+  }) => {
+    return fauxFoundry.getOntology(params.ontologyApiName).getInterfaceType(params.interfaceType);
+  }),
+  /**
+   * List ontologies
+   */
+  OntologiesV2_exports2.OntologiesV2.list(baseUrl, async () => {
+    return {
+      data: fauxFoundry.getEveryOntology().map((x) => x.getOntologyFullMetadata().ontology)
+    };
+  }),
+  /**
+   * Get specified Ontology
+   */
+  OntologiesV2_exports2.OntologiesV2.get(baseUrl, async (req) => {
+    return fauxFoundry.getOntology(req.params.ontologyRid).getOntologyFullMetadata().ontology;
+  }),
+  /**
+   * List objectTypes V2
+   */
+  OntologiesV2_exports2.ObjectTypesV2.list(baseUrl, async (req) => {
+    return {
+      data: fauxFoundry.getOntology(req.params.ontologyApiName).getAllObjectTypes().map((x) => x.objectType)
+    };
+  }),
+  /**
+   * List Queries
+   */
+  OntologiesV2_exports2.QueryTypes.list(baseUrl, async (req) => {
+    return {
+      data: fauxFoundry.getOntology(req.params.ontologyApiName).getAllQueryTypes()
+    };
+  })
+];
+[msw.http.post(`https://stack.palantir.com/ontology-metadata/api/ontology/ontology/ontologies/load/all`, authHandlerMiddleware(async () => {
+  return msw.HttpResponse.json({
+    ontologies: {
+      "ri.ontology.main.ontology.f34bca54-eb0f-41ad-84f0-d562d9f2763a": {
+        apiName: "ontology-migration-source",
+        displayName: "Ontology Migration Test Source",
+        description: "",
+        currentOntologyVersion: "0000000c-040d-f49d-b7e8-79fa53caacf5",
+        defaultBranchRid: "ri.ontology.main.branch.122438ac-a6b7-46e9-825f-6c911ffff857"
+      },
+      [defaultOntologyMetadata.rid]: defaultOntologyForConjure
+    }
+  });
+}))];
+var createQueryHandlers = (baseUrl, fauxFoundry) => [
+  /**
+   * Execute Queries
+   */
+  OntologiesV2_exports2.Queries.execute(baseUrl, async ({
+    request,
+    params: {
+      ontologyApiName,
+      queryApiName
+    }
+  }) => {
+    const queryParams = Object.fromEntries(new URL(request.url).searchParams.entries());
+    const version = queryParams["version"];
+    if (!semver.valid(version)) {
+      throw new Error(`Invalid version "${version}" for query "${queryApiName}" in ontology "${ontologyApiName}: not semver compatible".`);
+    }
+    const queryImpl = fauxFoundry.getOntology(ontologyApiName).getQueryImpl(queryApiName, version);
+    return queryImpl(await request.json(), fauxFoundry.getDataStore(ontologyApiName));
+  })
+];
+
+// src/handlers/createTimeseriesAndGeotimeHandlers.ts
+var createTimeseriesAndGeotimeHandlers = (baseUrl, fauxFoundry) => [
+  /**
+   * Load firstPoint
+   */
+  OntologiesV2_exports2.TimeSeriesPropertiesV2.getFirstPoint(baseUrl, async ({
+    params: {
+      objectType,
+      ontologyApiName,
+      primaryKey,
+      propertyName
+    }
+  }) => {
+    return fauxFoundry.getDataStore(ontologyApiName).getTimeSeriesData(objectType, primaryKey, propertyName).at(0);
+  }),
+  /**
+   * Load lastPoint
+   */
+  OntologiesV2_exports2.TimeSeriesPropertiesV2.getLastPoint(baseUrl, async ({
+    params: {
+      objectType,
+      ontologyApiName,
+      primaryKey,
+      propertyName
+    }
+  }) => {
+    return fauxFoundry.getDataStore(ontologyApiName).getTimeSeriesData(objectType, primaryKey, propertyName).at(-1);
+  }),
+  /**
+   * stream points
+   */
+  OntologiesV2_exports2.TimeSeriesPropertiesV2.streamPoints(baseUrl, async ({
+    request,
+    params: {
+      objectType,
+      ontologyApiName,
+      primaryKey,
+      propertyName
+    }
+  }) => {
+    return Response.json(fauxFoundry.getDataStore(ontologyApiName).getTimeSeriesData(objectType, primaryKey, propertyName, await request.json()));
+  }),
+  /**
+   * Load latestValue
+   */
+  OntologiesV2_exports2.TimeSeriesValueBankProperties.getLatestValue(baseUrl, async ({
+    params: {
+      objectType,
+      ontologyApiName,
+      primaryKey,
+      propertyName
+    }
+  }) => {
+    const ret = fauxFoundry.getDataStore(ontologyApiName).getTimeSeriesData(objectType, primaryKey, propertyName).at(-1);
+    if (!ret) {
+      throw new OpenApiCallError(400, InvalidRequest("Invalid request"));
+    }
+    return ret;
+  }),
+  /**
+   * stream values
+   */
+  OntologiesV2_exports2.TimeSeriesValueBankProperties.streamValues(baseUrl, async ({
+    request,
+    params: {
+      objectType,
+      ontologyApiName,
+      primaryKey,
+      propertyName
+    }
+  }) => {
+    return Response.json(fauxFoundry.getDataStore(ontologyApiName).getTimeSeriesData(objectType, primaryKey, propertyName, await request.json()));
+  })
+];
+
+// src/handlers/createFauxFoundryHandlers.ts
+function createFauxFoundryHandlers(baseUrl, fauxFoundry) {
+  return [createMultipassServerHandlers, createActionHandlers, createObjectSetHandlers, createOntologyHandlers, createQueryHandlers, createLoadObjectsHandlers, createTimeseriesAndGeotimeHandlers, createAttachmentHandlers, createMediaRefHandlers].flatMap((x) => x(baseUrl, fauxFoundry));
+}
+
+// src/FauxFoundry/FauxAttachmentStore.ts
+var FauxAttachmentStore = class {
+  #attachments = /* @__PURE__ */ new Map();
+  registerAttachment(attachment) {
+    this.#attachments.set(attachment.rid, attachment);
+    return this.getAttachmentMetadataByRid(attachment.rid);
+  }
+  getAttachmentMetadataByRid(attachmentRid) {
+    const attachment = this.#attachments.get(attachmentRid);
+    if (!attachment) {
+      throw new OpenApiCallError(404, {
+        errorCode: "NOT_FOUND",
+        errorName: "AttachmentNotFound",
+        errorInstanceId: "internal",
+        parameters: {
+          attachmentRid
+        }
+      });
+    }
+    const {
+      buffer,
+      ...metadata
+    } = attachment;
+    return {
+      ...metadata,
+      sizeBytes: String(buffer.byteLength)
+    };
+  }
+  getAttachmentBuffer(attachmentRid) {
+    const attachment = this.#attachments.get(attachmentRid);
+    if (!attachment) {
+      throw new OpenApiCallError(404, {
+        errorCode: "NOT_FOUND",
+        errorName: "AttachmentNotFound",
+        errorInstanceId: "internal",
+        parameters: {
+          attachmentRid
+        }
+      });
+    }
+    return attachment.buffer;
+  }
+};
+var FauxOntology = class {
+  #ontology;
+  #actionImpl = /* @__PURE__ */ new Map();
+  #queryImpl = /* @__PURE__ */ new Map();
+  constructor(ontology) {
+    this.#ontology = {
+      actionTypes: {},
+      interfaceTypes: {},
+      objectTypes: {},
+      ontology,
+      queryTypes: {},
+      sharedPropertyTypes: {}
+    };
+  }
+  get apiName() {
+    return this.#ontology.ontology.apiName;
+  }
+  getOntologyFullMetadata() {
+    return this.#ontology;
+  }
+  getFilteredOntologyMetadata(request) {
+    return {
+      ontology: this.#ontology.ontology,
+      objectTypes: Object.fromEntries(Object.entries(this.#ontology.objectTypes).filter(([objectType]) => request.objectTypes.includes(objectType)).map(([objectTypeApiName, objectTypeDefinition]) => [objectTypeApiName, {
+        ...objectTypeDefinition,
+        linkTypes: objectTypeDefinition.linkTypes.filter((linkType) => request.linkTypes.includes(linkType.apiName))
+      }])),
+      actionTypes: filterRecord(this.#ontology.actionTypes, request.actionTypes),
+      queryTypes: this.#getFilteredQueryTypes(request),
+      interfaceTypes: filterRecord(this.#ontology.interfaceTypes, request.interfaceTypes),
+      sharedPropertyTypes: {}
+    };
+  }
+  getAllInterfaceTypes() {
+    return Object.values(this.#ontology.interfaceTypes);
+  }
+  getAllObjectTypes() {
+    return Object.values(this.#ontology.objectTypes);
+  }
+  getAllActionTypes() {
+    return Object.values(this.#ontology.actionTypes);
+  }
+  getAllQueryTypes() {
+    return Object.values(this.#ontology.queryTypes);
+  }
+  getInterfaceType(interfaceType) {
+    const ret = this.#ontology.interfaceTypes[interfaceType];
+    if (ret === void 0) {
+      throw new OpenApiCallError(404, ObjectNotFoundError(interfaceType, ""));
+    }
+    return this.#ontology.interfaceTypes[interfaceType];
+  }
+  getObjectTypeFullMetadata(objectTypeApiName) {
+    return this.#ontology.objectTypes[objectTypeApiName];
+  }
+  getObjectTypeFullMetadataOrThrow(objectTypeApiName) {
+    const objectType = this.#ontology.objectTypes[objectTypeApiName];
+    if (objectType === void 0) {
+      throw new OpenApiCallError(404, ObjectTypeDoesNotExistError(objectTypeApiName));
+    }
+    return objectType;
+  }
+  getActionDef(actionTypeApiName) {
+    const actionType = this.#ontology.actionTypes[actionTypeApiName];
+    if (actionType === void 0) {
+      throw new OpenApiCallError(404, ActionNotFoundError());
+    }
+    return actionType;
+  }
+  getActionImpl(actionTypeApiName) {
+    const impl = this.#actionImpl.get(actionTypeApiName);
+    !impl ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Action implementation not found for " + actionTypeApiName) : invariant4__default.default(false) : void 0;
+    return impl;
+  }
+  getQueryDef(queryTypeApiNameAndVersion) {
+    const queryType = this.#ontology.queryTypes[this.#convertToVersionedApiName(queryTypeApiNameAndVersion)];
+    if (queryType === void 0) {
+      throw new OpenApiCallError(404, QueryNotFoundError(queryTypeApiNameAndVersion));
+    }
+    return queryType;
+  }
+  getQueryImpl(queryTypeApiName, version) {
+    const versionMap = this.#queryImpl.get(queryTypeApiName);
+    const impl = version !== void 0 ? versionMap?.get(version) : versionMap?.get(semver__default.default.rsort(Array.from(versionMap.keys() ?? []))[0]);
+    if (!impl) {
+      throw new OpenApiCallError(404, QueryNotFoundError(queryTypeApiName));
+    }
+    !impl ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Query implementation not found for " + queryTypeApiName) : invariant4__default.default(false) : void 0;
+    return impl;
+  }
+  getInterfaceToObjectTypeMappings(objectApiNames) {
+    const objectDefs = Array.from(objectApiNames).map((apiName) => this.getObjectTypeFullMetadataOrThrow(apiName));
+    const ifaceToObjMap = {};
+    for (const objDef of objectDefs) {
+      for (const [ifaceApiName, {
+        properties
+      }] of Object.entries(objDef.implementsInterfaces2)) {
+        if (ifaceToObjMap[ifaceApiName] === void 0) {
+          ifaceToObjMap[ifaceApiName] = {};
+        }
+        ifaceToObjMap[ifaceApiName][objDef.objectType.apiName] = properties;
+      }
+    }
+    return ifaceToObjMap;
+  }
+  getLinkTypeSideV2(objectTypeApiName, linkTypeName) {
+    const objectType = this.getObjectTypeFullMetadataOrThrow(objectTypeApiName);
+    const linkType = objectType.linkTypes.find((a) => a.apiName === linkTypeName);
+    if (linkType === void 0) {
+      throw new OpenApiCallError(404, LinkTypeNotFound(objectTypeApiName, linkTypeName));
+    }
+    return linkType;
+  }
+  getOtherLinkTypeSideV2OrThrow(objectTypeApiName, linkTypeName) {
+    const thisSideLink = this.getLinkTypeSideV2(objectTypeApiName, linkTypeName);
+    const otherObj = this.getObjectTypeFullMetadataOrThrow(thisSideLink.objectTypeApiName);
+    const candidates = otherObj.linkTypes.filter((l) => l.linkTypeRid === thisSideLink.linkTypeRid);
+    if (otherObj.objectType.apiName !== objectTypeApiName) {
+      !(candidates.length === 1) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Expected only one candidate link type") : invariant4__default.default(false) : void 0;
+      return candidates[0];
+    }
+    if (candidates.length === 1) {
+      return candidates[0];
+    }
+    !(candidates.length === 2) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Expected only two candidate link types") : invariant4__default.default(false) : void 0;
+    const candidate = candidates.find((l) => l.apiName !== thisSideLink.apiName);
+    !candidate ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Expected to find a candidate link type that is not the same as the one passed in") : invariant4__default.default(false) : void 0;
+    return candidate;
+  }
+  getBothLinkTypeSides(leftObjectType, leftLinkName, rightObjectType) {
+    const leftTypeSideV2 = this.getLinkTypeSideV2(leftObjectType, leftLinkName);
+    !(rightObjectType === leftTypeSideV2.objectTypeApiName) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false) : invariant4__default.default(false) : void 0;
+    const rightTypeSideV2 = this.getOtherLinkTypeSideV2OrThrow(leftObjectType, leftLinkName);
+    return [leftTypeSideV2, rightTypeSideV2];
+  }
+  registerObjectType(def) {
+    if (def.objectType.apiName in this.#ontology.objectTypes) {
+      throw new Error(`ObjectType ${def.objectType.apiName} already registered`);
+    }
+    this.#ontology.objectTypes[def.objectType.apiName] = def;
+  }
+  registerActionType(def, implementation) {
+    if (def.apiName in this.#ontology.actionTypes) {
+      throw new Error(`ActionType ${def.apiName} already registered`);
+    }
+    this.#ontology.actionTypes[def.apiName] = def;
+    if (implementation) {
+      this.#actionImpl.set(def.apiName, implementation);
+    }
+  }
+  registerQueryType(def, implementation) {
+    if (`${def.apiName}:${def.version}` in this.#ontology.queryTypes) {
+      throw new Error(`QueryType ${def.apiName} already registered`);
+    }
+    this.#ontology.queryTypes[`${def.apiName}:${def.version}`] = def;
+    if (implementation) {
+      if (!this.#queryImpl.has(def.apiName)) {
+        this.#queryImpl.set(def.apiName, /* @__PURE__ */ new Map());
+      }
+      if (!semver.valid(def.version)) {
+        throw new Error(`QueryType ${def.apiName} version ${def.version} is not semver valid`);
+      }
+      this.#queryImpl.get(def.apiName)?.set(def.version, implementation);
+    }
+  }
+  registerInterfaceType(def) {
+    if (def.apiName in this.#ontology.interfaceTypes) {
+      throw new Error(`InterfaceType ${def.apiName} already registered`);
+    }
+    this.#ontology.interfaceTypes[def.apiName] = def;
+  }
+  registerSharedPropertyType(def) {
+    if (def.apiName in this.#ontology.sharedPropertyTypes) {
+      throw new Error(`SharedPropertyType ${def.apiName} already registered`);
+    }
+    this.#ontology.sharedPropertyTypes[def.apiName] = def;
+  }
+  #getFilteredQueryTypes(request) {
+    const remappedQueryTypes = request.queryTypes.map((x) => this.#convertToVersionedApiName(x));
+    return Object.fromEntries(Object.entries(this.#ontology.queryTypes).filter(([queryTypeApiName]) => remappedQueryTypes.includes(queryTypeApiName)).map(([queryTypeApiName, queryTypeDefinition]) => [request.queryTypes[remappedQueryTypes.indexOf(queryTypeApiName)], queryTypeDefinition]));
+  }
+  #convertToVersionedApiName(apiName) {
+    if (extractVersion(apiName) !== void 0) {
+      return apiName;
+    }
+    const version = semver__default.default.rsort(Object.keys(this.#ontology.queryTypes).filter((queryTypeApiName) => queryTypeApiName.startsWith(apiName)).map((x) => extractVersion(x)))[0];
+    return `${apiName}:${version}`;
+  }
+};
+function filterRecord(record, keys) {
+  return Object.fromEntries(Object.entries(record).filter(([key]) => keys.includes(key)));
+}
+function extractVersion(apiName) {
+  return apiName.split(":")[1];
+}
+
+// src/FauxFoundry/FauxFoundry.ts
+var FauxFoundry = class {
+  #ontologiesByRid = /* @__PURE__ */ new Map();
+  #ontologiesByApiName = /* @__PURE__ */ new Map();
+  #dataStoresByOntologyApiName = /* @__PURE__ */ new Map();
+  #handlers;
+  attachments = new FauxAttachmentStore();
+  constructor(baseUrl, defaultOntology = {
+    apiName: "default-ontology",
+    displayName: "Ontology",
+    description: "The default ontology",
+    rid: `ri.ontology.main.ontology.${crypto__namespace.randomUUID()}`
+  }, {
+    logger
+  } = {}) {
+    this.baseUrl = baseUrl;
+    this.#handlers = createFauxFoundryHandlers(baseUrl, this);
+    this.createOntology(defaultOntology);
+    this.defaultOntologyRid = defaultOntology.rid;
+    this.logger = logger;
+  }
+  get handlers() {
+    return this.#handlers;
+  }
+  getDefaultOntology() {
+    return this.getOntology(this.defaultOntologyRid);
+  }
+  getDefaultDataStore() {
+    return this.getDataStore(this.defaultOntologyRid);
+  }
+  createOntology(metadata) {
+    const ret = new FauxOntology(metadata);
+    this.registerOntology(ret);
+    return ret;
+  }
+  registerOntology(ontology) {
+    this.#ontologiesByApiName.set(ontology.getOntologyFullMetadata().ontology.apiName, ontology);
+    this.#ontologiesByRid.set(ontology.getOntologyFullMetadata().ontology.rid, ontology);
+  }
+  getOntology(ontologyApiNameOrRid) {
+    const ontology = this.#ontologiesByApiName.get(ontologyApiNameOrRid) ?? this.#ontologiesByRid.get(ontologyApiNameOrRid);
+    if (!ontology) {
+      throw new OpenApiCallError(404, OntologyNotFoundError(ontologyApiNameOrRid));
+    }
+    return ontology;
+  }
+  setDataStore(ontologyApiNameOrRid, fauxDataStore) {
+    const ontology = this.getOntology(ontologyApiNameOrRid);
+    this.#dataStoresByOntologyApiName.set(ontology.apiName, fauxDataStore);
+  }
+  getDataStore(ontologyApiNameOrRid) {
+    const ontology = this.getOntology(ontologyApiNameOrRid);
+    const dataStore = this.#dataStoresByOntologyApiName.get(ontology.apiName);
+    if (!dataStore) {
+      const ret = new FauxDataStore(ontology, this.attachments);
+      this.setDataStore(ontologyApiNameOrRid, ret);
+      return ret;
+    }
+    return dataStore;
+  }
+  getEveryOntology() {
+    return Object.values(this.#ontologiesByApiName);
+  }
+};
+
+// src/withoutRid.ts
+function withoutRid(o) {
+  const {
+    __rid,
+    ...r
+  } = o;
+  return r;
+}
+
+exports.msw = msw__namespace;
+exports.Errors = errors_exports;
+exports.FauxDataStore = FauxDataStore;
+exports.FauxDataStoreBatch = FauxDataStoreBatch;
+exports.FauxFoundry = FauxFoundry;
+exports.FauxOntology = FauxOntology;
+exports.MockOntologiesV2 = OntologiesV2_exports2;
+exports.OpenApiCallError = OpenApiCallError;
+exports.TypeHelpers = typeHelpers_exports;
+exports.authHandlerMiddleware = authHandlerMiddleware;
+exports.isBaseApiError = isBaseApiError;
+exports.withoutRid = withoutRid;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map