@osdk/client 0.19.0 → 0.19.1-main-20240520153817

package/build/browser/chunk-DSK3YH2L.js

@@ -0,0 +1,1644 @@
+import { foundryPlatformFetch, createFetchHeaderMutator, PalantirApiError, createSharedClientContext, symbolClientContext } from '@osdk/shared.net';
+import invariant2 from 'tiny-invariant';
+import { wireObjectTypeFullMetadataToSdkObjectTypeDefinition, __UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition } from '@osdk/generator-converters';
+import deepEqual from 'fast-deep-equal';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../internal.foundry.datasets/build/esm/chunk-CSAU5B4Q.js
+var __defProp2 = Object.defineProperty;
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, {
+      get: all[name],
+      enumerable: true
+    });
+};
+var Branch_exports = {};
+__export2(Branch_exports, {
+  createBranch: () => createBranch,
+  deleteBranch: () => deleteBranch,
+  getBranch: () => getBranch,
+  listBranches: () => listBranches
+});
+var _listBranches = [0, "/v1/datasets/{0}/branches", 2];
+function listBranches($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listBranches, ...args);
+}
+var _createBranch = [1, "/v1/datasets/{0}/branches", 1];
+function createBranch($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _createBranch, ...args);
+}
+var _getBranch = [0, "/v1/datasets/{0}/branches/{1}"];
+function getBranch($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getBranch, ...args);
+}
+var _deleteBranch = [3, "/v1/datasets/{0}/branches/{1}"];
+function deleteBranch($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _deleteBranch, ...args);
+}
+var Dataset_exports = {};
+__export2(Dataset_exports, {
+  createDataset: () => createDataset,
+  deleteSchema: () => deleteSchema,
+  getDataset: () => getDataset,
+  getSchema: () => getSchema,
+  putSchema: () => putSchema,
+  readTable: () => readTable
+});
+var _createDataset = [1, "/v1/datasets", 1];
+function createDataset($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _createDataset, ...args);
+}
+var _getDataset = [0, "/v1/datasets/{0}"];
+function getDataset($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getDataset, ...args);
+}
+var _readTable = [0, "/v1/datasets/{0}/readTable", 2, , "*/*"];
+function readTable($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _readTable, ...args);
+}
+var _getSchema = [0, "/v1/datasets/{0}/schema", 2];
+function getSchema($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getSchema, ...args);
+}
+var _putSchema = [2, "/v1/datasets/{0}/schema", 3];
+function putSchema($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _putSchema, ...args);
+}
+var _deleteSchema = [3, "/v1/datasets/{0}/schema", 2];
+function deleteSchema($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _deleteSchema, ...args);
+}
+var File_exports = {};
+__export2(File_exports, {
+  deleteFile: () => deleteFile,
+  getFileContent: () => getFileContent,
+  getFileMetadata: () => getFileMetadata,
+  listFiles: () => listFiles,
+  uploadFile: () => uploadFile
+});
+var _listFiles = [0, "/v1/datasets/{0}/files", 2];
+function listFiles($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listFiles, ...args);
+}
+var _uploadFile = [1, "/v1/datasets/{0}/files:upload", 2, "*/*"];
+function uploadFile($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _uploadFile, ...args);
+}
+var _getFileMetadata = [0, "/v1/datasets/{0}/files/{1}", 2];
+function getFileMetadata($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getFileMetadata, ...args);
+}
+var _deleteFile = [3, "/v1/datasets/{0}/files/{1}", 2];
+function deleteFile($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _deleteFile, ...args);
+}
+var _getFileContent = [0, "/v1/datasets/{0}/files/{1}/content", 2, , "*/*"];
+function getFileContent($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getFileContent, ...args);
+}
+var Transaction_exports = {};
+__export2(Transaction_exports, {
+  abortTransaction: () => abortTransaction,
+  commitTransaction: () => commitTransaction,
+  createTransaction: () => createTransaction,
+  getTransaction: () => getTransaction
+});
+var _createTransaction = [1, "/v1/datasets/{0}/transactions", 3];
+function createTransaction($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _createTransaction, ...args);
+}
+var _getTransaction = [0, "/v1/datasets/{0}/transactions/{1}"];
+function getTransaction($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getTransaction, ...args);
+}
+var _commitTransaction = [1, "/v1/datasets/{0}/transactions/{1}/commit"];
+function commitTransaction($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _commitTransaction, ...args);
+}
+var _abortTransaction = [1, "/v1/datasets/{0}/transactions/{1}/abort"];
+function abortTransaction($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _abortTransaction, ...args);
+}
+var __defProp3 = Object.defineProperty;
+var __export3 = (target, all) => {
+  for (var name in all)
+    __defProp3(target, name, {
+      get: all[name],
+      enumerable: true
+    });
+};
+var LanguageModel_exports = {};
+__export3(LanguageModel_exports, {
+  createChatCompletion: () => createChatCompletion,
+  listLanguageModels: () => listLanguageModels,
+  streamChatCompletion: () => streamChatCompletion
+});
+var _createChatCompletion = [1, "/v1/models/languageModels/{0}/chatCompletions", 1];
+function createChatCompletion($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _createChatCompletion, ...args);
+}
+var _streamChatCompletion = [1, "/v1/models/languageModels/{0}/chatCompletions/stream", 1, , "*/*"];
+function streamChatCompletion($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _streamChatCompletion, ...args);
+}
+var _listLanguageModels = [0, "/v1/models/languageModels", 2];
+function listLanguageModels($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listLanguageModels, ...args);
+}
+
+// ../internal.foundry.ontologies/build/esm/chunk-CSAU5B4Q.js
+var __defProp4 = Object.defineProperty;
+var __export4 = (target, all) => {
+  for (var name in all)
+    __defProp4(target, name, {
+      get: all[name],
+      enumerable: true
+    });
+};
+var ActionType_exports = {};
+__export4(ActionType_exports, {
+  applyAction: () => applyAction,
+  applyActionAsync: () => applyActionAsync,
+  applyActionBatch: () => applyActionBatch,
+  getActionType: () => getActionType,
+  getAsyncActionStatus: () => getAsyncActionStatus,
+  listActionTypes: () => listActionTypes,
+  validateAction: () => validateAction
+});
+var _listActionTypes = [0, "/v1/ontologies/{0}/actionTypes", 2];
+function listActionTypes($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listActionTypes, ...args);
+}
+var _getActionType = [0, "/v1/ontologies/{0}/actionTypes/{1}"];
+function getActionType($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getActionType, ...args);
+}
+var _applyAction = [1, "/v1/ontologies/{0}/actions/{1}/apply", 1];
+function applyAction($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _applyAction, ...args);
+}
+var _applyActionBatch = [1, "/v1/ontologies/{0}/actions/{1}/applyBatch", 1];
+function applyActionBatch($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _applyActionBatch, ...args);
+}
+var _applyActionAsync = [1, "/v1/ontologies/{0}/actions/{1}/applyAsync", 3];
+function applyActionAsync($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _applyActionAsync, ...args);
+}
+var _getAsyncActionStatus = [0, "/v1/ontologies/{0}/actions/{1}/applyAsync/{2}", 2];
+function getAsyncActionStatus($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getAsyncActionStatus, ...args);
+}
+var _validateAction = [1, "/v1/ontologies/{0}/actions/{1}/validate", 1];
+function validateAction($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _validateAction, ...args);
+}
+var Attachment_exports = {};
+__export4(Attachment_exports, {
+  getAttachment: () => getAttachment,
+  getAttachmentContent: () => getAttachmentContent,
+  uploadAttachment: () => uploadAttachment
+});
+var _uploadAttachment = [1, "/v1/attachments/upload", 6, "*/*"];
+function uploadAttachment($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _uploadAttachment, ...args);
+}
+var _getAttachmentContent = [0, "/v1/attachments/{0}/content", , , "*/*"];
+function getAttachmentContent($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getAttachmentContent, ...args);
+}
+var _getAttachment = [0, "/v1/attachments/{0}"];
+function getAttachment($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getAttachment, ...args);
+}
+var ObjectType_exports = {};
+__export4(ObjectType_exports, {
+  getObjectType: () => getObjectType,
+  getOutgoingLinkType: () => getOutgoingLinkType,
+  listObjectTypes: () => listObjectTypes,
+  listOutgoingLinkTypes: () => listOutgoingLinkTypes
+});
+var _listObjectTypes = [0, "/v1/ontologies/{0}/objectTypes", 2];
+function listObjectTypes($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listObjectTypes, ...args);
+}
+var _getObjectType = [0, "/v1/ontologies/{0}/objectTypes/{1}"];
+function getObjectType($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getObjectType, ...args);
+}
+var _listOutgoingLinkTypes = [0, "/v1/ontologies/{0}/objectTypes/{1}/outgoingLinkTypes", 2];
+function listOutgoingLinkTypes($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listOutgoingLinkTypes, ...args);
+}
+var _getOutgoingLinkType = [0, "/v1/ontologies/{0}/objectTypes/{1}/outgoingLinkTypes/{2}"];
+function getOutgoingLinkType($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getOutgoingLinkType, ...args);
+}
+var Ontology_exports = {};
+__export4(Ontology_exports, {
+  getOntology: () => getOntology,
+  listOntologies: () => listOntologies
+});
+var _listOntologies = [0, "/v1/ontologies"];
+function listOntologies($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listOntologies, ...args);
+}
+var _getOntology = [0, "/v1/ontologies/{0}"];
+function getOntology($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getOntology, ...args);
+}
+var OntologyObject_exports = {};
+__export4(OntologyObject_exports, {
+  aggregateObjects: () => aggregateObjects,
+  getLinkedObject: () => getLinkedObject,
+  getObject: () => getObject,
+  listLinkedObjects: () => listLinkedObjects,
+  listObjects: () => listObjects,
+  searchObjects: () => searchObjects
+});
+var _listObjects = [0, "/v1/ontologies/{0}/objects/{1}", 2];
+function listObjects($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listObjects, ...args);
+}
+var _getObject = [0, "/v1/ontologies/{0}/objects/{1}/{2}", 2];
+function getObject($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getObject, ...args);
+}
+var _listLinkedObjects = [0, "/v1/ontologies/{0}/objects/{1}/{2}/links/{3}", 2];
+function listLinkedObjects($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listLinkedObjects, ...args);
+}
+var _getLinkedObject = [0, "/v1/ontologies/{0}/objects/{1}/{2}/links/{3}/{4}", 2];
+function getLinkedObject($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getLinkedObject, ...args);
+}
+var _searchObjects = [1, "/v1/ontologies/{0}/objects/{1}/search", 1];
+function searchObjects($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _searchObjects, ...args);
+}
+var _aggregateObjects = [1, "/v1/ontologies/{0}/objects/{1}/aggregate", 1];
+function aggregateObjects($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _aggregateObjects, ...args);
+}
+var QueryType_exports = {};
+__export4(QueryType_exports, {
+  executeQuery: () => executeQuery,
+  getQueryType: () => getQueryType,
+  listQueryTypes: () => listQueryTypes
+});
+var _listQueryTypes = [0, "/v1/ontologies/{0}/queryTypes", 2];
+function listQueryTypes($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listQueryTypes, ...args);
+}
+var _getQueryType = [0, "/v1/ontologies/{0}/queryTypes/{1}", 2];
+function getQueryType($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getQueryType, ...args);
+}
+var _executeQuery = [1, "/v1/ontologies/{0}/queries/{1}/execute", 3];
+function executeQuery($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _executeQuery, ...args);
+}
+
+// ../internal.foundry.ontologiesv2/build/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  Action: () => Action_exports,
+  ActionTypeV2: () => ActionTypeV2_exports,
+  ObjectTypeV2: () => ObjectTypeV2_exports,
+  OntologyObjectSet: () => OntologyObjectSet_exports,
+  OntologyObjectV2: () => OntologyObjectV2_exports,
+  OntologyV2: () => OntologyV2_exports,
+  QueryType: () => QueryType_exports2
+});
+
+// ../internal.foundry.ontologiesv2/build/esm/chunk-CSAU5B4Q.js
+var __defProp5 = Object.defineProperty;
+var __export5 = (target, all) => {
+  for (var name in all)
+    __defProp5(target, name, {
+      get: all[name],
+      enumerable: true
+    });
+};
+var Action_exports = {};
+__export5(Action_exports, {
+  applyActionAsyncV2: () => applyActionAsyncV2,
+  applyActionBatchV2: () => applyActionBatchV2,
+  applyActionV2: () => applyActionV2
+});
+var _applyActionV2 = [1, "/v2/ontologies/{0}/actions/{1}/apply", 3];
+function applyActionV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _applyActionV2, ...args);
+}
+var _applyActionBatchV2 = [1, "/v2/ontologies/{0}/actions/{1}/applyBatch", 3];
+function applyActionBatchV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _applyActionBatchV2, ...args);
+}
+var _applyActionAsyncV2 = [1, "/v2/ontologies/{0}/actions/{1}/applyAsync", 3];
+function applyActionAsyncV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _applyActionAsyncV2, ...args);
+}
+var ActionTypeV2_exports = {};
+__export5(ActionTypeV2_exports, {
+  getActionTypeV2: () => getActionTypeV2,
+  listActionTypesV2: () => listActionTypesV2
+});
+var _listActionTypesV2 = [0, "/v2/ontologies/{0}/actionTypes", 2];
+function listActionTypesV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listActionTypesV2, ...args);
+}
+var _getActionTypeV2 = [0, "/v2/ontologies/{0}/actionTypes/{1}"];
+function getActionTypeV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getActionTypeV2, ...args);
+}
+var ObjectTypeV2_exports = {};
+__export5(ObjectTypeV2_exports, {
+  getObjectTypeV2: () => getObjectTypeV2,
+  getOutgoingLinkTypeV2: () => getOutgoingLinkTypeV2,
+  listObjectTypesV2: () => listObjectTypesV2,
+  listOutgoingLinkTypesV2: () => listOutgoingLinkTypesV2
+});
+var _listObjectTypesV2 = [0, "/v2/ontologies/{0}/objectTypes", 2];
+function listObjectTypesV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listObjectTypesV2, ...args);
+}
+var _getObjectTypeV2 = [0, "/v2/ontologies/{0}/objectTypes/{1}"];
+function getObjectTypeV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getObjectTypeV2, ...args);
+}
+var _listOutgoingLinkTypesV2 = [0, "/v2/ontologies/{0}/objectTypes/{1}/outgoingLinkTypes", 2];
+function listOutgoingLinkTypesV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listOutgoingLinkTypesV2, ...args);
+}
+var _getOutgoingLinkTypeV2 = [0, "/v2/ontologies/{0}/objectTypes/{1}/outgoingLinkTypes/{2}"];
+function getOutgoingLinkTypeV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getOutgoingLinkTypeV2, ...args);
+}
+var OntologyObjectSet_exports = {};
+__export5(OntologyObjectSet_exports, {
+  aggregateObjectSetV2: () => aggregateObjectSetV2,
+  createTemporaryObjectSetV2: () => createTemporaryObjectSetV2,
+  getObjectSetV2: () => getObjectSetV2,
+  loadObjectSetV2: () => loadObjectSetV2
+});
+var _createTemporaryObjectSetV2 = [1, "/v2/ontologies/{0}/objectSets/createTemporary", 1];
+function createTemporaryObjectSetV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _createTemporaryObjectSetV2, ...args);
+}
+var _getObjectSetV2 = [0, "/v2/ontologies/{0}/objectSets/{1}"];
+function getObjectSetV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getObjectSetV2, ...args);
+}
+var _loadObjectSetV2 = [1, "/v2/ontologies/{0}/objectSets/loadObjects", 3];
+function loadObjectSetV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _loadObjectSetV2, ...args);
+}
+var _aggregateObjectSetV2 = [1, "/v2/ontologies/{0}/objectSets/aggregate", 3];
+function aggregateObjectSetV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _aggregateObjectSetV2, ...args);
+}
+var OntologyObjectV2_exports = {};
+__export5(OntologyObjectV2_exports, {
+  aggregateObjectsForInterface: () => aggregateObjectsForInterface,
+  aggregateObjectsV2: () => aggregateObjectsV2,
+  countObjects: () => countObjects,
+  getAttachmentByRidV2: () => getAttachmentByRidV2,
+  getAttachmentContentByRidV2: () => getAttachmentContentByRidV2,
+  getAttachmentContentV2: () => getAttachmentContentV2,
+  getAttachmentsV2: () => getAttachmentsV2,
+  getFirstPoint: () => getFirstPoint,
+  getInterfaceType: () => getInterfaceType,
+  getLastPoint: () => getLastPoint,
+  getLinkedObjectV2: () => getLinkedObjectV2,
+  getObjectTypeFullMetadata: () => getObjectTypeFullMetadata,
+  getObjectV2: () => getObjectV2,
+  listInterfaceTypes: () => listInterfaceTypes,
+  listLinkedObjectsV2: () => listLinkedObjectsV2,
+  listObjectsV2: () => listObjectsV2,
+  searchObjectsForInterface: () => searchObjectsForInterface,
+  searchObjectsV2: () => searchObjectsV2,
+  streamPoints: () => streamPoints
+});
+var _listObjectsV2 = [0, "/v2/ontologies/{0}/objects/{1}", 2];
+function listObjectsV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listObjectsV2, ...args);
+}
+var _getObjectV2 = [0, "/v2/ontologies/{0}/objects/{1}/{2}", 2];
+function getObjectV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getObjectV2, ...args);
+}
+var _countObjects = [1, "/v2/ontologies/{0}/objects/{1}/count", 2];
+function countObjects($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _countObjects, ...args);
+}
+var _searchObjectsV2 = [1, "/v2/ontologies/{0}/objects/{1}/search", 3];
+function searchObjectsV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _searchObjectsV2, ...args);
+}
+var _aggregateObjectsV2 = [1, "/v2/ontologies/{0}/objects/{1}/aggregate", 3];
+function aggregateObjectsV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _aggregateObjectsV2, ...args);
+}
+var _listInterfaceTypes = [0, "/v2/ontologies/{0}/interfaceTypes", 2];
+function listInterfaceTypes($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listInterfaceTypes, ...args);
+}
+var _getInterfaceType = [0, "/v2/ontologies/{0}/interfaceTypes/{1}", 2];
+function getInterfaceType($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getInterfaceType, ...args);
+}
+var _searchObjectsForInterface = [1, "/v2/ontologies/{0}/interfaces/{1}/search", 3];
+function searchObjectsForInterface($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _searchObjectsForInterface, ...args);
+}
+var _aggregateObjectsForInterface = [1, "/v2/ontologies/{0}/interfaces/{1}/aggregate", 3];
+function aggregateObjectsForInterface($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _aggregateObjectsForInterface, ...args);
+}
+var _listLinkedObjectsV2 = [0, "/v2/ontologies/{0}/objects/{1}/{2}/links/{3}", 2];
+function listLinkedObjectsV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listLinkedObjectsV2, ...args);
+}
+var _getLinkedObjectV2 = [0, "/v2/ontologies/{0}/objects/{1}/{2}/links/{3}/{4}", 2];
+function getLinkedObjectV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getLinkedObjectV2, ...args);
+}
+var _getAttachmentsV2 = [0, "/v2/ontologies/{0}/objects/{1}/{2}/attachments/{3}", 2];
+function getAttachmentsV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getAttachmentsV2, ...args);
+}
+var _getAttachmentByRidV2 = [0, "/v2/ontologies/{0}/objects/{1}/{2}/attachments/{3}/{4}", 2];
+function getAttachmentByRidV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getAttachmentByRidV2, ...args);
+}
+var _getAttachmentContentV2 = [0, "/v2/ontologies/{0}/objects/{1}/{2}/attachments/{3}/content", 2, , "*/*"];
+function getAttachmentContentV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getAttachmentContentV2, ...args);
+}
+var _getAttachmentContentByRidV2 = [0, "/v2/ontologies/{0}/objects/{1}/{2}/attachments/{3}/{4}/content", 2, , "*/*"];
+function getAttachmentContentByRidV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getAttachmentContentByRidV2, ...args);
+}
+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);
+}
+var _getObjectTypeFullMetadata = [0, "/v2/ontologies/{0}/objectTypes/{1}/fullMetadata", 2];
+function getObjectTypeFullMetadata($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getObjectTypeFullMetadata, ...args);
+}
+var OntologyV2_exports = {};
+__export5(OntologyV2_exports, {
+  getOntologyFullMetadata: () => getOntologyFullMetadata,
+  getOntologyV2: () => getOntologyV2,
+  listOntologiesV2: () => listOntologiesV2
+});
+var _listOntologiesV2 = [0, "/v2/ontologies"];
+function listOntologiesV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listOntologiesV2, ...args);
+}
+var _getOntologyV2 = [0, "/v2/ontologies/{0}"];
+function getOntologyV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getOntologyV2, ...args);
+}
+var _getOntologyFullMetadata = [0, "/v2/ontologies/{0}/fullMetadata"];
+function getOntologyFullMetadata($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getOntologyFullMetadata, ...args);
+}
+var QueryType_exports2 = {};
+__export5(QueryType_exports2, {
+  executeQueryV2: () => executeQueryV2,
+  getQueryTypeV2: () => getQueryTypeV2,
+  listQueryTypesV2: () => listQueryTypesV2
+});
+var _listQueryTypesV2 = [0, "/v2/ontologies/{0}/queryTypes", 2];
+function listQueryTypesV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _listQueryTypesV2, ...args);
+}
+var _getQueryTypeV2 = [0, "/v2/ontologies/{0}/queryTypes/{1}"];
+function getQueryTypeV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _getQueryTypeV2, ...args);
+}
+var _executeQueryV2 = [1, "/v2/ontologies/{0}/queries/{1}/execute", 3];
+function executeQueryV2($ctx, ...args) {
+  return foundryPlatformFetch($ctx, _executeQueryV2, ...args);
+}
+function addUserAgent(client, withMetadata) {
+  if (withMetadata.osdkMetadata) {
+    return {
+      ...client,
+      fetch: createFetchHeaderMutator(client.fetch, (headers) => {
+        headers.set("Fetch-User-Agent", withMetadata.osdkMetadata.extraUserAgent);
+        return headers;
+      })
+    };
+  }
+  return client;
+}
+function legacyToModernSingleAggregationResult(entry) {
+  return entry.metrics.reduce((accumulator, curValue) => {
+    const parts = curValue.name.split(".");
+    if (parts[0] === "count") {
+      return accumulator;
+    }
+    !(parts.length === 2) ? process.env.NODE_ENV !== "production" ? invariant2(false, "assumed we were getting a `${key}.${type}`") : invariant2(false) : void 0;
+    if (!(parts[0] in accumulator)) {
+      accumulator[parts[0]] = {};
+    }
+    accumulator[parts[0]][parts[1]] = curValue.value;
+    return accumulator;
+  }, {});
+}
+
+// src/internal/conversions/modernToLegacyAggregationClause.ts
+function modernToLegacyAggregationClause(select) {
+  return Object.entries(select).flatMap(([k, v]) => {
+    if (k === "$count") {
+      if (v)
+        return {
+          type: "count",
+          name: "count"
+        };
+      return [];
+    } else if (Array.isArray(v)) {
+      return v.map((v2) => {
+        return {
+          type: v2,
+          name: `${k}.${v2}`,
+          field: k
+        };
+      });
+    } else {
+      return [{
+        type: v,
+        // FIXME v has additional possible values
+        name: `${k}.${v}`,
+        field: k
+      }];
+    }
+  });
+}
+
+// src/query/aggregations/GroupByClause.ts
+var DurationMapping = {
+  "sec": "SECONDS",
+  "seconds": "SECONDS",
+  "min": "MINUTES",
+  "minute": "MINUTES",
+  "minutes": "MINUTES",
+  "hr": "HOURS",
+  "hrs": "HOURS",
+  "hour": "HOURS",
+  "hours": "HOURS",
+  "day": "DAYS",
+  "days": "DAYS",
+  "wk": "WEEKS",
+  "week": "WEEKS",
+  "weeks": "WEEKS",
+  "mos": "MONTHS",
+  "month": "MONTHS",
+  "months": "MONTHS",
+  "yr": "YEARS",
+  "year": "YEARS",
+  "years": "YEARS",
+  "quarter": "QUARTERS",
+  "quarters": "QUARTERS"
+};
+
+// src/internal/conversions/modernToLegacyGroupByClause.ts
+function modernToLegacyGroupByClause(groupByClause) {
+  if (!groupByClause)
+    return [];
+  return Object.entries(groupByClause).flatMap(([field, type]) => {
+    if (type === "exact") {
+      return [{
+        type,
+        field
+      }];
+    } else if ("exactWithLimit" in type) {
+      {
+        return [{
+          type: "exact",
+          field,
+          maxGroupCount: type.exactWithLimit
+        }];
+      }
+    } else if ("fixedWidth" in type) {
+      return [{
+        type: "fixedWidth",
+        field,
+        fixedWidth: type.fixedWidth
+      }];
+    } else if ("ranges" in type) {
+      return [{
+        type: "ranges",
+        field,
+        ranges: type.ranges.map((range) => convertRange(range))
+      }];
+    } else if ("duration" in type) {
+      return [{
+        type: "duration",
+        field,
+        value: type.duration[0],
+        unit: DurationMapping[type.duration[1]]
+      }];
+    } else
+      return [];
+  });
+}
+function convertRange(range) {
+  return {
+    startValue: range[0],
+    endValue: range[1]
+  };
+}
+
+// src/query/WhereClause.ts
+var DistanceUnitMapping = {
+  "centimeter": "CENTIMETERS",
+  "centimeters": "CENTIMETERS",
+  "cm": "CENTIMETERS",
+  "meter": "METERS",
+  "meters": "METERS",
+  "m": "METERS",
+  "kilometer": "KILOMETERS",
+  "kilometers": "KILOMETERS",
+  "km": "KILOMETERS",
+  "inch": "INCHES",
+  "inches": "INCHES",
+  "foot": "FEET",
+  "feet": "FEET",
+  "yard": "YARDS",
+  "yards": "YARDS",
+  "mile": "MILES",
+  "miles": "MILES",
+  "nautical_mile": "NAUTICAL_MILES",
+  "nauticalMile": "NAUTICAL_MILES",
+  "nautical miles": "NAUTICAL_MILES"
+};
+
+// src/internal/conversions/modernToLegacyWhereClause.ts
+function modernToLegacyWhereClause(whereClause) {
+  if ("$and" in whereClause) {
+    return {
+      type: "and",
+      value: whereClause.$and.map(modernToLegacyWhereClause)
+    };
+  } else if ("$or" in whereClause) {
+    return {
+      type: "or",
+      value: whereClause.$or.map(modernToLegacyWhereClause)
+    };
+  } else if ("$not" in whereClause) {
+    return {
+      type: "not",
+      value: modernToLegacyWhereClause(whereClause.$not)
+    };
+  }
+  const parts = Object.entries(whereClause);
+  if (parts.length === 1) {
+    return handleWherePair(parts[0]);
+  }
+  return {
+    type: "and",
+    value: parts.map(handleWherePair)
+  };
+}
+function makeGeoFilterBbox(field, bbox, filterType) {
+  return {
+    type: filterType === "$within" ? "withinBoundingBox" : "intersectsBoundingBox",
+    field,
+    value: {
+      topLeft: {
+        type: "Point",
+        coordinates: [bbox[0], bbox[3]]
+      },
+      bottomRight: {
+        type: "Point",
+        coordinates: [bbox[2], bbox[1]]
+      }
+    }
+  };
+}
+function makeGeoFilterPolygon(field, coordinates, filterType) {
+  return {
+    type: filterType,
+    field,
+    value: {
+      type: "Polygon",
+      coordinates
+    }
+  };
+}
+function handleWherePair([field, filter]) {
+  !(filter != null) ? process.env.NODE_ENV !== "production" ? invariant2(false, "Defined key values are only allowed when they are not undefined.") : invariant2(false) : void 0;
+  if (typeof filter === "string" || typeof filter === "number" || typeof filter === "boolean") {
+    return {
+      type: "eq",
+      field,
+      value: filter
+    };
+  }
+  const keysOfFilter = Object.keys(filter);
+  const hasDollarSign = keysOfFilter.some((key) => key.startsWith("$"));
+  !(!hasDollarSign || keysOfFilter.length === 1) ? process.env.NODE_ENV !== "production" ? invariant2(false, "WhereClause Filter with multiple clauses isn't allowed") : invariant2(false) : void 0;
+  if (!hasDollarSign) {
+    throw new Error(`Unsupported filter. Did you forget to use a $-prefixed filter? (${JSON.stringify(filter)})`);
+  }
+  const firstKey = keysOfFilter[0];
+  !(filter[firstKey] != null) ? process.env.NODE_ENV !== "production" ? invariant2(false) : invariant2(false) : void 0;
+  if (firstKey === "$ne") {
+    return {
+      type: "not",
+      value: {
+        type: "eq",
+        field,
+        value: filter[firstKey]
+      }
+    };
+  }
+  if (firstKey === "$within") {
+    const withinBody = filter[firstKey];
+    if (Array.isArray(withinBody)) {
+      return makeGeoFilterBbox(field, withinBody, firstKey);
+    } else if ("bbox" in withinBody && !("type" in withinBody)) {
+      return makeGeoFilterBbox(field, withinBody.bbox, firstKey);
+    } else if ("distance" in withinBody && "of" in withinBody) {
+      return {
+        type: "withinDistanceOf",
+        field,
+        value: {
+          center: Array.isArray(withinBody.of) ? {
+            type: "Point",
+            coordinates: withinBody.of
+          } : withinBody.of,
+          distance: {
+            value: withinBody.distance[0],
+            unit: DistanceUnitMapping[withinBody.distance[1]]
+          }
+        }
+      };
+    } else {
+      const coordinates = "polygon" in withinBody ? withinBody.polygon : withinBody.coordinates;
+      return makeGeoFilterPolygon(field, coordinates, "withinPolygon");
+    }
+  }
+  if (firstKey === "$intersects") {
+    const intersectsBody = filter[firstKey];
+    if (Array.isArray(intersectsBody)) {
+      return makeGeoFilterBbox(field, intersectsBody, firstKey);
+    } else if ("bbox" in intersectsBody && !("type" in intersectsBody)) {
+      return makeGeoFilterBbox(field, intersectsBody.bbox, firstKey);
+    } else {
+      const coordinates = "polygon" in intersectsBody ? intersectsBody.polygon : intersectsBody.coordinates;
+      return makeGeoFilterPolygon(field, coordinates, "intersectsPolygon");
+    }
+  }
+  return {
+    type: firstKey.substring(1),
+    field,
+    value: filter[firstKey]
+  };
+}
+async function fetchSingle(client, objectType, args, objectSet) {
+  const result = await fetchPage(client, objectType, {
+    ...args,
+    pageSize: 1
+  }, objectSet);
+  if (result.data.length !== 1 || result.nextPageToken != null) {
+    throw new PalantirApiError(`Expected a single result but got ${result.data.length} instead${result.nextPageToken != null ? " with nextPageToken set" : ""}`);
+  }
+  return result.data[0];
+}
+async function fetchSingleWithErrors(client, objectType, args, objectSet) {
+  try {
+    const result = await fetchSingle(client, objectType, args, objectSet);
+    return {
+      value: result
+    };
+  } catch (e) {
+    if (e instanceof Error) {
+      return {
+        error: e
+      };
+    }
+    return {
+      error: e
+    };
+  }
+}
+async function aggregate(clientCtx, objectType, objectSet = {
+  type: "base",
+  objectType: objectType["apiName"]
+}, req) {
+  const body = {
+    aggregation: modernToLegacyAggregationClause(req.select),
+    groupBy: [],
+    where: void 0
+  };
+  if (req.groupBy) {
+    body.groupBy = modernToLegacyGroupByClause(req.groupBy);
+  }
+  if (req.where) {
+    body.where = modernToLegacyWhereClause(req.where);
+  }
+  const result = await esm_exports.OntologyObjectSet.aggregateObjectSetV2(addUserAgent(clientCtx, objectType), clientCtx.ontologyRid, {
+    objectSet,
+    groupBy: body.groupBy,
+    aggregation: body.aggregation
+  });
+  if (!req.groupBy) {
+    !(result.data.length === 1) ? process.env.NODE_ENV !== "production" ? invariant2(false, "no group by clause should mean only one data result") : invariant2(false) : void 0;
+    return {
+      ...aggregationToCountResult(result.data[0]),
+      ...legacyToModernSingleAggregationResult(result.data[0])
+    };
+  }
+  const ret = result.data.map((entry) => {
+    return {
+      $group: entry.group,
+      ...aggregationToCountResult(entry),
+      ...legacyToModernSingleAggregationResult(entry)
+    };
+  });
+  return ret;
+}
+function aggregationToCountResult(entry) {
+  for (const aggregateResult of entry.metrics) {
+    if (aggregateResult.name === "count") {
+      return {
+        $count: aggregateResult.value
+      };
+    }
+  }
+}
+
+// src/util/WireObjectSet.ts
+var WIRE_OBJECT_SET_TYPES = /* @__PURE__ */ new Set(["base", "filter", "intersect", "reference", "searchAround", "static", "subtract", "union"]);
+function isWireObjectSet(o) {
+  return o != null && typeof o === "object" && WIRE_OBJECT_SET_TYPES.has(o.type);
+}
+
+// src/objectSet/createObjectSet.ts
+function isObjectTypeDefinition(def) {
+  return def.type === "object";
+}
+function isObjectSet(o) {
+  return o != null && typeof o === "object" && isWireObjectSet(objectSetDefinitions.get(o));
+}
+function getWireObjectSet(objectSet) {
+  return objectSetDefinitions.get(objectSet);
+}
+var objectSetDefinitions = /* @__PURE__ */ new WeakMap();
+function createObjectSet(objectType, clientCtx, objectSet = {
+  type: "base",
+  objectType: objectType["apiName"]
+}) {
+  const base = {
+    aggregate: aggregate.bind(globalThis, clientCtx, objectType, objectSet),
+    fetchPage: fetchPageInternal.bind(globalThis, clientCtx, objectType, objectSet),
+    fetchPageWithErrors: fetchPageWithErrorsInternal.bind(globalThis, clientCtx, objectType, objectSet),
+    where: (clause) => {
+      return clientCtx.objectSetFactory(objectType, clientCtx, {
+        type: "filter",
+        objectSet,
+        where: modernToLegacyWhereClause(clause)
+      });
+    },
+    pivotTo: function(type) {
+      return createSearchAround(type)();
+    },
+    union: (...objectSets) => {
+      return clientCtx.objectSetFactory(objectType, clientCtx, {
+        type: "union",
+        objectSets: [objectSet, ...objectSets.map((os) => objectSetDefinitions.get(os))]
+      });
+    },
+    intersect: (...objectSets) => {
+      return clientCtx.objectSetFactory(objectType, clientCtx, {
+        type: "intersect",
+        objectSets: [objectSet, ...objectSets.map((os) => objectSetDefinitions.get(os))]
+      });
+    },
+    subtract: (...objectSets) => {
+      return clientCtx.objectSetFactory(objectType, clientCtx, {
+        type: "subtract",
+        objectSets: [objectSet, ...objectSets.map((os) => objectSetDefinitions.get(os))]
+      });
+    },
+    asyncIter: async function* () {
+      let nextPageToken = void 0;
+      do {
+        const result = await base.fetchPage({
+          nextPageToken
+        });
+        for (const obj of await convertWireToOsdkObjects(clientCtx, result.data, void 0)) {
+          yield obj;
+        }
+      } while (nextPageToken != null);
+    },
+    get: isObjectTypeDefinition(objectType) ? async (primaryKey, options) => {
+      const withPk = {
+        type: "filter",
+        objectSet,
+        where: {
+          type: "eq",
+          field: objectType.primaryKeyApiName,
+          value: primaryKey
+        }
+      };
+      return await fetchSingle(clientCtx, objectType, options, withPk);
+    } : void 0,
+    fetchOne: isObjectTypeDefinition(objectType) ? async (primaryKey, options) => {
+      const withPk = {
+        type: "filter",
+        objectSet,
+        where: {
+          type: "eq",
+          field: objectType.primaryKeyApiName,
+          value: primaryKey
+        }
+      };
+      return await fetchSingle(clientCtx, objectType, options, withPk);
+    } : void 0,
+    fetchOneWithErrors: isObjectTypeDefinition(objectType) ? async (primaryKey, options) => {
+      const withPk = {
+        type: "filter",
+        objectSet,
+        where: {
+          type: "eq",
+          field: objectType.primaryKeyApiName,
+          value: primaryKey
+        }
+      };
+      return await fetchSingleWithErrors(clientCtx, objectType, options, withPk);
+    } : void 0
+  };
+  function createSearchAround(link) {
+    return () => {
+      return clientCtx.objectSetFactory(objectType, clientCtx, {
+        type: "searchAround",
+        objectSet,
+        link
+      });
+    };
+  }
+  objectSetDefinitions.set(base, objectSet);
+  return base;
+}
+
+// src/object/Attachment.ts
+var Attachment = class {
+  constructor(rid) {
+    this.rid = rid;
+  }
+};
+function isAttachment(o) {
+  return o instanceof Attachment;
+}
+
+// src/object/Cache.ts
+function createClientCache(fn) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  function get(client, key) {
+    if (cache.get(client) == null) {
+      cache.set(client, /* @__PURE__ */ new Map());
+    }
+    let r = cache.get(client).get(key);
+    if (r === void 0 && fn !== void 0) {
+      return set(client, key, fn(client, key));
+    } else {
+      return r;
+    }
+  }
+  function set(client, key, value) {
+    if (cache.get(client) == null) {
+      cache.set(client, /* @__PURE__ */ new Map());
+    }
+    cache.get(client).set(key, value);
+    return value;
+  }
+  function remove(client, key) {
+    if (cache.get(client) == null)
+      return false;
+    return cache.get(client).delete(key);
+  }
+  return {
+    get,
+    set,
+    remove
+  };
+}
+function createAsyncClientCache(fn, createCacheLocal = createClientCache) {
+  const cache = createCacheLocal();
+  const inProgress = createCacheLocal();
+  const ret = {
+    getOrUndefined: function getOrUndefined(client, key) {
+      return cache.get(client, key);
+    },
+    get: async function get(client, key) {
+      return cache.get(client, key) ?? inProgress.get(client, key) ?? ret.set(client, key, fn(client, key));
+    },
+    set: async function set(client, k, v) {
+      try {
+        const r = await inProgress.set(client, k, v);
+        cache.set(client, k, r);
+        inProgress.remove(client, k);
+        return r;
+      } catch (e) {
+        inProgress.remove(client, k);
+        throw e;
+      }
+    }
+  };
+  return ret;
+}
+function createSimpleCache(map = /* @__PURE__ */ new Map(), fn) {
+  function get(key) {
+    let r = map.get(key);
+    if (r === void 0 && fn !== void 0) {
+      return set(key, fn(key));
+    } else {
+      return r;
+    }
+  }
+  function set(key, value) {
+    map.set(key, value);
+    return value;
+  }
+  function remove(key) {
+    return map.delete(key);
+  }
+  return {
+    get,
+    set,
+    remove
+  };
+}
+function createSimpleAsyncCache(type, fn, createCacheLocal = createSimpleCache) {
+  const cache = createCacheLocal(type === "weak" ? /* @__PURE__ */ new WeakMap() : /* @__PURE__ */ new Map());
+  const inProgress = createCacheLocal(type === "weak" ? /* @__PURE__ */ new WeakMap() : /* @__PURE__ */ new Map());
+  const ret = {
+    getOrUndefined: function getOrUndefined(key) {
+      return cache.get(key);
+    },
+    get: async function get(key) {
+      return cache.get(key) ?? inProgress.get(key) ?? ret.set(key, fn(key));
+    },
+    set: async function set(k, v) {
+      try {
+        const r = await inProgress.set(k, v);
+        cache.set(k, r);
+        inProgress.remove(k);
+        return r;
+      } catch (e) {
+        inProgress.remove(k);
+        throw e;
+      }
+    }
+  };
+  return ret;
+}
+
+// src/object/convertWireToOsdkObjects.ts
+var OriginClient = Symbol();
+var UnderlyingObject = Symbol();
+var InterfaceDefinitions = Symbol();
+var LinkFetcherProxyHandler = class {
+  constructor(objDef, primaryKey, client) {
+    this.objDef = objDef;
+    this.primaryKey = primaryKey;
+    this.client = client;
+  }
+  get(_target, p) {
+    const linkDef = this.objDef.links[p];
+    if (linkDef == null) {
+      return;
+    }
+    const objectSet = this.client.objectSetFactory(this.objDef, this.client).where({
+      [this.objDef.primaryKeyApiName]: this.primaryKey
+    }).pivotTo(p);
+    if (!linkDef.multiplicity) {
+      return {
+        /** @deprecated  */
+        get: (options) => fetchSingle(this.client, this.objDef, options ?? {}, getWireObjectSet(objectSet)),
+        fetchOne: (options) => fetchSingle(this.client, this.objDef, options ?? {}, getWireObjectSet(objectSet)),
+        fetchOneWithErrors: (options) => fetchSingleWithErrors(this.client, this.objDef, options ?? {}, getWireObjectSet(objectSet))
+      };
+    } else {
+      return objectSet;
+    }
+  }
+  ownKeys() {
+    return Object.keys(this.objDef.links);
+  }
+  getOwnPropertyDescriptor(target, p) {
+    return {
+      enumerable: true,
+      configurable: true,
+      get: () => {
+        return this.get(target, p);
+      }
+    };
+  }
+};
+function createPrototype(objDef, client) {
+  if (process.env.NODE_ENV !== "production") {
+    !(objDef.type === "object") ? process.env.NODE_ENV !== "production" ? invariant2(false, "Expected object definition") : invariant2(false) : void 0;
+  }
+  const sharedPropertyDefs = {
+    $as: {
+      value: $as
+    }
+  };
+  const interfaceProto = Object.defineProperties({}, sharedPropertyDefs);
+  const objectProto = Object.defineProperties({}, {
+    $link: {
+      get: function() {
+        return new Proxy({}, new LinkFetcherProxyHandler(objDef, this["$primaryKey"], client));
+      }
+    },
+    ...sharedPropertyDefs
+  });
+  function $as(newDef) {
+    if (typeof newDef === "string") {
+      if (newDef === objDef.apiName) {
+        return this[UnderlyingObject];
+      }
+      if (objDef.interfaceMap?.[newDef] == null) {
+        throw new Error(`Object does not implement interface '${newDef}'.`);
+      }
+      const def = objDef[InterfaceDefinitions][newDef];
+      if (!def) {
+        throw new Error(`Object does not implement interface '${newDef}'.`);
+      }
+      newDef = def;
+    } else if (newDef.apiName === objDef.apiName) {
+      return this[UnderlyingObject];
+    }
+    if (newDef.type !== "interface" && newDef.apiName !== this.$apiName) {
+      throw new Error(`'${newDef.apiName}' is not an interface of '${this.$objectType}'.`);
+    }
+    const underlying = this[UnderlyingObject];
+    const common = {
+      enumerable: true,
+      configurable: true
+    };
+    return Object.create(interfaceProto, {
+      $apiName: {
+        value: newDef.apiName,
+        ...common
+      },
+      $objectType: {
+        value: objDef.apiName,
+        ...common
+      },
+      $primaryKey: {
+        value: this["$primaryKey"],
+        ...common
+      },
+      ...Object.fromEntries(Object.keys(newDef.properties).map((p) => {
+        const value = underlying[objDef.interfaceMap[newDef.apiName][p]];
+        return [p, {
+          value,
+          enumerable: value !== void 0
+        }];
+      })),
+      [UnderlyingObject]: {
+        value: underlying
+      }
+    });
+  }
+  return objectProto;
+}
+function createConverter(objDef) {
+  const steps = [];
+  for (const [key, value] of Object.entries(objDef.properties)) {
+    if (value.type === "attachment") {
+      steps.push((o) => {
+        if (o[key] != null) {
+          if (Array.isArray(o[key])) {
+            o[key] = o[key].map((a) => new Attachment(a.rid));
+          } else {
+            o[key] = new Attachment(o[key].rid);
+          }
+        }
+      });
+    }
+  }
+  return steps.length > 0 ? (o) => {
+    for (const step of steps) {
+      step(o);
+    }
+  } : void 0;
+}
+var protoConverterCache = createClientCache((client, objectDef) => {
+  const proto = createPrototype(objectDef, client);
+  const converter = createConverter(objectDef);
+  return [proto, converter];
+});
+async function convertWireToOsdkObjects(client, objects, interfaceApiName, forceRemoveRid = false) {
+  client.logger?.debug(`START convertWireToOsdkObjects()`);
+  if (forceRemoveRid) {
+    for (const obj of objects) {
+      delete obj.__rid;
+    }
+  }
+  fixObjectPropertiesInline(objects);
+  const localObjectCache = createLocalObjectCacheAndInitiatePreseed(objects, client);
+  for (const obj of objects) {
+    const objectDef = await localObjectCache.get(client, obj.$apiName);
+    if (objectDef == null) {
+      throw new Error(`Failed to find ontology definition for '${obj.$apiName}'`);
+    }
+    if (interfaceApiName !== void 0) {
+      if (objectDef.interfaceMap?.[interfaceApiName] == null) {
+        const warning = "Interfaces are only supported 'as views' but your metadata object is missing the correct information. This suggests your interfaces have not been migrated to the newer version yet and you cannot use this version of the SDK.";
+        if (client.logger) {
+          client.logger.warn(warning);
+        } else {
+          console.error(`WARNING! ${warning}`);
+        }
+        throw new Error(warning);
+      }
+      for (const [sptProp, regularProp] of Object.entries(objectDef.interfaceMap[interfaceApiName])) {
+        if (sptProp in obj) {
+          const value = obj[sptProp];
+          delete obj[sptProp];
+          if (value !== void 0) {
+            obj[regularProp] = value;
+          }
+        }
+      }
+    }
+    internalConvertObjectInPlace(objectDef, client, obj);
+  }
+  const ret = interfaceApiName ? objects.map((o) => o.$as(interfaceApiName)) : objects;
+  client.logger?.debug(`END convertWireToOsdkObjects()`);
+  return ret;
+}
+function createLocalObjectCacheAndInitiatePreseed(objects, client) {
+  const localInterfaceCache = createAsyncClientCache((client2, apiName) => client2.ontologyProvider.getInterfaceDefinition(apiName));
+  const localObjectCache = createAsyncClientCache(async (client2, apiName) => {
+    const objectDef = await client2.ontologyProvider.getObjectDefinition(apiName);
+    const interfaceDefs = Object.fromEntries((await Promise.all(objectDef.implements?.map((i) => localInterfaceCache.get(client2, i)) ?? [])).map((i) => [i.apiName, i]));
+    if (objectDef[InterfaceDefinitions] == null) {
+      Object.defineProperty(objectDef, InterfaceDefinitions, {
+        value: interfaceDefs,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    }
+    return objectDef;
+  });
+  const uniqueApiNames = /* @__PURE__ */ new Set();
+  for (const {
+    $apiName
+  } of objects) {
+    if (uniqueApiNames.has($apiName))
+      continue;
+    uniqueApiNames.add($apiName);
+    localObjectCache.get(client, $apiName);
+  }
+  return localObjectCache;
+}
+function fixObjectPropertiesInline(objs) {
+  for (const obj of objs) {
+    if (obj.__rid) {
+      obj.$rid = obj.__rid;
+      delete obj.__rid;
+    }
+    obj.$apiName = obj.__apiName;
+    obj.$objectType = obj.__apiName;
+    obj.$primaryKey = obj.__primaryKey;
+    {
+      Object.defineProperties(obj, {
+        "__apiName": {
+          enumerable: false
+        },
+        "__primaryKey": {
+          enumerable: false
+        }
+      });
+    }
+  }
+}
+function internalConvertObjectInPlace(objectDef, client, obj) {
+  const [proto, converter] = protoConverterCache.get(client, objectDef);
+  Object.setPrototypeOf(obj, proto);
+  Object.defineProperties(obj, {
+    [OriginClient]: {
+      value: client
+    },
+    [UnderlyingObject]: {
+      value: obj
+    }
+  });
+  if (converter) {
+    converter(obj);
+  }
+}
+
+// src/object/fetchPage.ts
+function augment(type, ...properties) {
+  return {
+    [type.apiName]: properties
+  };
+}
+function objectSetToSearchJsonV2(objectSet, expectedApiName, existingWhere = void 0) {
+  if (objectSet.type === "base") {
+    if (objectSet.objectType !== expectedApiName) {
+      throw new Error(`Expected objectSet.objectType to be ${expectedApiName}, but got ${objectSet.objectType}`);
+    }
+    return existingWhere;
+  }
+  if (objectSet.type === "filter") {
+    return objectSetToSearchJsonV2(objectSet.objectSet, expectedApiName, existingWhere == null ? objectSet.where : {
+      type: "and",
+      value: [existingWhere, objectSet.where]
+    });
+  }
+  throw new Error(`Unsupported objectSet type: ${objectSet.type}`);
+}
+async function fetchInterfacePage(client, interfaceType, args, objectSet) {
+  const result = await esm_exports.OntologyObjectV2.searchObjectsForInterface(addUserAgent(client, interfaceType), client.ontologyRid, interfaceType.apiName, applyFetchArgs(args, {
+    augmentedProperties: args.augment ?? {},
+    augmentedSharedPropertyTypes: {},
+    otherInterfaceTypes: [],
+    selectedObjectTypes: [],
+    selectedSharedPropertyTypes: args.select ?? [],
+    where: objectSetToSearchJsonV2(objectSet, interfaceType.apiName)
+  }), {
+    preview: true
+  });
+  result.data = await convertWireToOsdkObjects(
+    client,
+    result.data,
+    // drop readonly
+    interfaceType.apiName,
+    !args.includeRid
+  );
+  return result;
+}
+async function fetchPageInternal(client, objectType, objectSet, args = {}) {
+  if (objectType.type === "interface") {
+    return await fetchInterfacePage(client, objectType, args, objectSet);
+  } else {
+    return await fetchObjectPage(client, objectType, args, objectSet);
+  }
+}
+async function fetchPageWithErrorsInternal(client, objectType, objectSet, args = {}) {
+  try {
+    const result = await fetchPageInternal(client, objectType, objectSet, args);
+    return {
+      value: result
+    };
+  } catch (e) {
+    if (e instanceof Error) {
+      return {
+        error: e
+      };
+    }
+    return {
+      error: e
+    };
+  }
+}
+async function fetchPage(client, objectType, args, objectSet = {
+  type: "base",
+  objectType: objectType["apiName"]
+}) {
+  return fetchPageInternal(client, objectType, objectSet, args);
+}
+function applyFetchArgs(args, body) {
+  if (args?.nextPageToken) {
+    body.pageToken = args.nextPageToken;
+  }
+  if (args?.pageSize != null) {
+    body.pageSize = args.pageSize;
+  }
+  if (args?.orderBy != null) {
+    body.orderBy = {
+      fields: Object.entries(args.orderBy).map(([field, direction]) => ({
+        field,
+        direction
+      }))
+    };
+  }
+  return body;
+}
+async function fetchObjectPage(client, objectType, args, objectSet) {
+  const r = await esm_exports.OntologyObjectSet.loadObjectSetV2(addUserAgent(client, objectType), client.ontologyRid, applyFetchArgs(args, {
+    objectSet,
+    // We have to do the following case because LoadObjectSetRequestV2 isnt readonly
+    select: args?.select ?? [],
+    // FIXME?
+    excludeRid: !args?.includeRid
+  }));
+  return Promise.resolve({
+    data: await convertWireToOsdkObjects(client, r.data, void 0),
+    nextPageToken: r.nextPageToken
+  });
+}
+
+// src/actions/ActionValidationError.ts
+var ActionValidationError = class extends Error {
+  constructor(validation) {
+    super("Validation Error");
+    this.validation = validation;
+  }
+};
+
+// src/util/isOntologyObjectV2.ts
+function isOntologyObjectV2(o) {
+  return o && typeof o === "object" && typeof o.__apiName === "string" && o.__primaryKey != null;
+}
+
+// src/util/toDataValue.ts
+function toDataValue(value) {
+  if (value == null) {
+    return value;
+  }
+  if (Array.isArray(value) || value instanceof Set) {
+    return Array.from(value, toDataValue);
+  }
+  if (isAttachment(value)) {
+    return value.rid;
+  }
+  if (isOntologyObjectV2(value)) {
+    return toDataValue(value.__primaryKey);
+  }
+  if (isWireObjectSet(value)) {
+    return value;
+  }
+  if (isObjectSet(value)) {
+    return getWireObjectSet(value);
+  }
+  if (typeof value === "object") {
+    return Object.entries(value).reduce((acc, [key, structValue]) => {
+      acc[key] = toDataValue(structValue);
+      return acc;
+    }, {});
+  }
+  return value;
+}
+
+// src/actions/applyAction.ts
+async function applyAction2(client, action, parameters, options = {}) {
+  const response = await esm_exports.Action.applyActionV2(addUserAgent(client, action), client.ontologyRid, action.apiName, {
+    parameters: remapActionParams(parameters),
+    options: {
+      mode: options?.validateOnly ? "VALIDATE_ONLY" : "VALIDATE_AND_EXECUTE",
+      returnEdits: options?.returnEdits ? "ALL" : "NONE"
+    }
+  });
+  if (options?.validateOnly) {
+    return response.validation;
+  }
+  if (response.validation?.result === "INVALID") {
+    throw new ActionValidationError(response.validation);
+  }
+  return options?.returnEdits ? response.edits : void 0;
+}
+function remapActionParams(params) {
+  if (params == null) {
+    return {};
+  }
+  const parameterMap = {};
+  const remappedParams = Object.entries(params).reduce((acc, [key, value]) => {
+    acc[key] = toDataValue(value);
+    return acc;
+  }, parameterMap);
+  return remappedParams;
+}
+
+// src/actions/createActionInvoker.ts
+function createActionInvoker(client, action) {
+  return function(...args) {
+    return applyAction2(client, action, ...args);
+  };
+}
+async function loadFullObjectMetadata(client, objtype) {
+  const full = await esm_exports.OntologyObjectV2.getObjectTypeFullMetadata(client, client.ontologyRid, objtype, {
+    preview: true
+  });
+  const ret = wireObjectTypeFullMetadataToSdkObjectTypeDefinition(full, true);
+  client.logger?.debug(`END loadFullObjectMetadata(${objtype})`);
+  return {
+    ...ret,
+    rid: full.objectType.rid
+  };
+}
+async function loadInterfaceDefinition(client, objtype) {
+  const r = await esm_exports.OntologyObjectV2.getInterfaceType(client, client.ontologyRid, objtype, {
+    preview: true
+  });
+  return __UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(r, true);
+}
+
+// src/ontology/StandardOntologyProvider.ts
+var alwaysRevalidateDefault = false;
+var createStandardOntologyProviderFactory = (client) => {
+  const alwaysRevalidate = client.alwaysRevalidate ?? alwaysRevalidateDefault;
+  return (client2) => {
+    async function loadObject(client3, key, skipCache = false) {
+      {
+        return await loadFullObjectMetadata(client3, key);
+      }
+    }
+    async function loadInterface(client3, key, skipCache = false) {
+      {
+        return loadInterfaceDefinition(client3, key);
+      }
+    }
+    function makeGetter(fn) {
+      const cache = createAsyncClientCache((client3, key) => fn(client3, key, false));
+      return async (apiName) => {
+        const n = alwaysRevalidate ? await fn(client2, apiName, true) : await cache.get(client2, apiName);
+        if (alwaysRevalidate) {
+          const og = cache.getOrUndefined(client2, apiName);
+          if (deepEqual(og, n)) {
+            return og;
+          } else {
+            return cache.set(client2, apiName, n);
+          }
+        }
+        return n;
+      };
+    }
+    return {
+      getObjectDefinition: makeGetter(loadObject),
+      getInterfaceDefinition: makeGetter(loadInterface),
+      maybeSeed(definition) {
+      }
+    };
+  };
+};
+
+// src/util/UserAgent.ts
+var USER_AGENT = `osdk-client/${"0.19.1-main-20240520153817"}`;
+
+// src/createMinimalClient.ts
+function createMinimalClient(metadata, baseUrl, tokenProvider, options = {}, fetchFn = global.fetch, objectSetFactory = createObjectSet) {
+  if (process?.env?.NODE_ENV !== "production") {
+    try {
+      new URL(baseUrl);
+    } catch (e) {
+      const hint = !baseUrl.startsWith("http://") || !baseUrl.startsWith("https://") ? ". Did you forget to add 'http://' or 'https://'?" : "";
+      throw new Error(`Invalid stack URL: ${baseUrl}${hint}`);
+    }
+  }
+  const minimalClient = {
+    ...createSharedClientContext(baseUrl, tokenProvider, USER_AGENT, fetchFn),
+    objectSetFactory,
+    ontologyRid: metadata.ontologyRid,
+    logger: options.logger
+  };
+  return Object.assign(minimalClient, {
+    ontologyProvider: createStandardOntologyProviderFactory(options)(minimalClient)
+  });
+}
+
+// src/createClient.ts
+function createClientInternal(objectSetFactory, baseUrl, ontologyRid, tokenProvider, options = void 0, fetchFn = fetch) {
+  const clientCtx = createMinimalClient({
+    ontologyRid
+  }, baseUrl, tokenProvider, options, fetchFn, objectSetFactory);
+  function clientFn(o) {
+    if (o.type === "object" || o.type === "interface") {
+      clientCtx.ontologyProvider.maybeSeed(o);
+      return objectSetFactory(o, clientCtx);
+    } else if (o.type === "action") {
+      clientCtx.ontologyProvider.maybeSeed(o);
+      return createActionInvoker(clientCtx, o);
+    } else {
+      throw new Error("not implemented");
+    }
+  }
+  const client = Object.defineProperties(clientFn, {
+    [symbolClientContext]: {
+      value: clientCtx
+    }
+  });
+  return client;
+}
+var createClient = createClientInternal.bind(void 0, createObjectSet);
+
+export { ActionValidationError, augment, convertWireToOsdkObjects, createClient, createClientInternal, createObjectSet, createSimpleAsyncCache, esm_exports };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=chunk-DSK3YH2L.js.map