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

package/build/browser/index.js

@@ -1,13 +1,726 @@
-import { USER_AGENT } from './chunk-WGFCR4UM.js';
-export { ActionValidationError, createAttachmentFromRid, createAttachmentUpload, createClient } from './chunk-WGFCR4UM.js';
+import { createObjectSet, metadataCacheClient, conjureUnionType, makeConjureContext, InterfaceDefinitions, createAsyncClientCache, addUserAgentAndRequestContextHeaders, augmentRequestContext, esm_exports, createAttachmentFromRid, isWireObjectSet, isObjectSet, getWireObjectSet } from './chunk-CG25K4WC.js';
+export { createAttachmentFromRid } from './chunk-CG25K4WC.js';
 export { isOk } from '@osdk/client.api';
 export { PalantirApiError } from '@osdk/shared.net.errors';
+import { __EXPERIMENTAL__NOT_SUPPORTED_YET__getBulkLinks, __EXPERIMENTAL__NOT_SUPPORTED_YET__preexistingObjectSet } from '@osdk/client.api/unstable';
+import { symbolClientContext } from '@osdk/shared.client';
+import { getBulkLinksPage } from '@osdk/client.unstable';
+import invariant from 'tiny-invariant';
 import { createSharedClientContext } from '@osdk/shared.client.impl';
+import { wireActionTypeV2ToSdkActionMetadata, wireObjectTypeFullMetadataToSdkObjectMetadata, __UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition, wireQueryTypeV2ToSdkQueryMetadata } from '@osdk/generator-converters';
 
+// src/actions/ActionValidationError.ts
+var ActionValidationError = class extends Error {
+  constructor(validation) {
+    super("Validation Error");
+    this.validation = validation;
+  }
+};
+
+// src/pageRequestAsAsyncIter.ts
+function getResults(x) {
+  return x.results;
+}
+function applyPageToken(payload, {
+  pageToken
+}) {
+  return pageToken ? {
+    ...payload,
+    pageToken
+  } : void 0;
+}
+async function* pageRequestAsAsyncIter(call, values, nextArgs, initialPayload) {
+  let payload = initialPayload;
+  while (payload) {
+    const r = await call(payload);
+    for (const q of values(r)) {
+      yield q;
+    }
+    payload = nextArgs(payload, r);
+  }
+}
+
+// src/__unstable/createBulkLinksAsyncIterFactory.ts
+function createBulkLinksAsyncIterFactory(ctx) {
+  return async function* (objs, linkTypes) {
+    if (objs.length === 0) {
+      return;
+    }
+    ctx.logger?.debug("Preparing to fetch bulk links");
+    !objs.every((a) => a.$objectType === objs[0].$objectType) ? process.env.NODE_ENV !== "production" ? invariant(false) : invariant(false) : void 0;
+    const mcc = await metadataCacheClient(ctx);
+    const helper = await mcc.forObjectByApiName(objs[0].$objectType);
+    const [objectTypeRid, propertyMapping, fullLinkMapping] = await Promise.all([helper.getRid(), helper.getPropertyMapping(), helper.getLinkMapping()]);
+    const linkMapping = Object.fromEntries(Object.entries(fullLinkMapping).filter(([apiName]) => linkTypes.includes(apiName)));
+    for (const linkType of linkTypes) {
+      if (linkMapping[linkType] == null) {
+        throw "Unable to find link type: " + linkType;
+      }
+    }
+    const req = {
+      objectSetContext: {
+        forkRid: void 0,
+        objectSetFilterContext: {
+          parameterOverrides: {}
+        },
+        ontologyBranchRid: void 0,
+        owningRid: void 0,
+        reportUsage: void 0,
+        workstateRid: void 0
+      },
+      responseOptions: {
+        includeObjectSetEntities: true,
+        includeUsageCost: false
+      },
+      pageSize: 1e3,
+      pageToken: void 0,
+      linksRequests: [{
+        directedLinkTypes: Object.values(linkMapping).map(({
+          directedLinkTypeRid
+        }) => directedLinkTypeRid),
+        objects: conjureUnionType("objects", objs.map((o) => conjureUnionType("objectLocatorV2", {
+          objectTypeRid,
+          objectPrimaryKey: {
+            [propertyMapping.pk.rid]: conjureUnionType(propertyMapping.pk.type.type, o.$primaryKey)
+          }
+        })))
+      }]
+    };
+    const bulkLinksIter = pageRequestAsAsyncIter(getBulkLinksPage.bind(void 0, makeConjureContext(ctx, "/object-set-service/api")), getResults, applyPageToken, req);
+    for await (const item of bulkLinksIter) {
+      const {
+        objectIdentifier
+      } = item;
+      const obj = findObject(objectIdentifier, objs);
+      for (const link of item.links) {
+        const ref = link.link[link.linkSide === "SOURCE" ? "objectSideB" : "objectSideA"];
+        const pk = getPrimaryKeyOrThrow(ref);
+        const otherObjectApiName = await (await mcc.forObjectByRid(pk.objectTypeRid)).getApiName();
+        const mappedLink = Object.values(linkMapping).find((a) => a.directedLinkTypeRid.linkTypeRid === link.link.linkTypeRid && a.directedLinkTypeRid.linkSide === link.linkSide);
+        if (!mappedLink) throw new Error("Could not find link type");
+        yield {
+          object: obj,
+          linkApiName: mappedLink.apiName,
+          otherObjectApiName,
+          otherObjectPk: pk.pkValue
+        };
+      }
+    }
+  };
+}
+function findObject(objectIdentifier, objs) {
+  const {
+    pkValue
+  } = getPrimaryKeyOrThrow(objectIdentifier);
+  const obj = objs.find((o) => o.$primaryKey === pkValue);
+  if (obj == null) {
+    throw new Error(`Needed to find object with pk ${pkValue}} and could not`);
+  }
+  return obj;
+}
+function getPrimaryKeyOrThrow(ref) {
+  if ("type" in ref && ref.type !== "objectLocatorV2") {
+    throw new Error("We do not support looking up object by rid");
+  }
+  const pks = Object.entries(ref.objectLocatorV2.objectPrimaryKey);
+  if (pks.length !== 1) {
+    throw new Error("Unable to support this request due to multiple pks");
+  }
+  return {
+    objectTypeRid: ref.objectLocatorV2.objectTypeRid,
+    pkValue: pks[0][1][pks[0][1].type]
+  };
+}
+
+// src/object/AttachmentUpload.ts
+function isAttachmentUpload(o) {
+  return o instanceof Blob && "name" in o;
+}
+function createAttachmentUpload(data, name) {
+  const attachmentUpload = Object.create(data, {
+    name: {
+      value: name
+    }
+  });
+  return attachmentUpload;
+}
+
+// src/util/isOntologyObjectV2.ts
+function isOntologyObjectV2(o) {
+  return o && typeof o === "object" && typeof o.__apiName === "string" && o.__primaryKey != null;
+}
+
+// src/util/isOsdkObject.ts
+function isOsdkBaseObject(o) {
+  return o && typeof o === "object" && typeof o.$apiName === "string" && o.$primaryKey != null;
+}
+
+// src/util/toDataValue.ts
+async function toDataValue(value, client) {
+  if (value == null) {
+    return value;
+  }
+  if (Array.isArray(value) || value instanceof Set) {
+    const promiseArray = Array.from(value, async (innerValue) => await toDataValue(innerValue, client));
+    return Promise.all(promiseArray);
+  }
+  if (isAttachmentUpload(value)) {
+    const attachment = await esm_exports.Attachments.uploadAttachmentV2(client, value, {
+      filename: value.name
+    });
+    return await toDataValue(attachment.rid, client);
+  }
+  if (isOntologyObjectV2(value)) {
+    return await toDataValue(value.__primaryKey, client);
+  }
+  if (isOsdkBaseObject(value)) {
+    return await toDataValue(value.$primaryKey, client);
+  }
+  if (isWireObjectSet(value)) {
+    return value;
+  }
+  if (isObjectSet(value)) {
+    return getWireObjectSet(value);
+  }
+  if (typeof value === "object") {
+    return Object.entries(value).reduce(async (promisedAcc, [key, structValue]) => {
+      const acc = await promisedAcc;
+      acc[key] = await toDataValue(structValue, client);
+      return acc;
+    }, Promise.resolve({}));
+  }
+  return value;
+}
+
+// src/actions/applyAction.ts
+async function applyAction(client, action, parameters, options = {}) {
+  const clientWithHeaders = addUserAgentAndRequestContextHeaders(augmentRequestContext(client, (_) => ({
+    finalMethodCall: "applyAction"
+  })), action);
+  if (Array.isArray(parameters)) {
+    const response = await esm_exports.Actions.applyActionBatchV2(clientWithHeaders, await client.ontologyRid, action.apiName, {
+      requests: parameters ? await remapBatchActionParams(parameters, client) : [],
+      options: {
+        returnEdits: options?.$returnEdits ? "ALL" : "NONE"
+      }
+    });
+    const edits = response.edits;
+    return options?.$returnEdits ? edits?.type === "edits" ? remapActionResponse(response) : edits : void 0;
+  } else {
+    const response = await esm_exports.Actions.applyActionV2(clientWithHeaders, await client.ontologyRid, action.apiName, {
+      parameters: await remapActionParams(parameters, client),
+      options: {
+        mode: options?.$validateOnly ? "VALIDATE_ONLY" : "VALIDATE_AND_EXECUTE",
+        returnEdits: options?.$returnEdits ? "ALL" : "NONE"
+      }
+    });
+    if (options?.$validateOnly) {
+      return response.validation;
+    }
+    if (response.validation?.result === "INVALID") {
+      throw new ActionValidationError(response.validation);
+    }
+    const edits = response.edits;
+    return options?.$returnEdits ? edits?.type === "edits" ? remapActionResponse(response) : edits : void 0;
+  }
+}
+async function remapActionParams(params, client) {
+  if (params == null) {
+    return {};
+  }
+  const parameterMap = {};
+  for (const [key, value] of Object.entries(params)) {
+    parameterMap[key] = await toDataValue(value, client);
+  }
+  return parameterMap;
+}
+async function remapBatchActionParams(params, client) {
+  const remappedParams = await Promise.all(params.map(async (param) => {
+    return {
+      parameters: await remapActionParams(param, client)
+    };
+  }));
+  return remappedParams;
+}
+function remapActionResponse(response) {
+  const editResponses = response?.edits;
+  if (editResponses?.type === "edits") {
+    const remappedActionResponse = {
+      type: editResponses.type,
+      deletedLinksCount: editResponses.deletedLinksCount,
+      deletedObjectsCount: editResponses.deletedObjectsCount,
+      addedLinks: [],
+      addedObjects: [],
+      modifiedObjects: [],
+      editedObjectTypes: []
+    };
+    const editedObjectTypesSet = /* @__PURE__ */ new Set();
+    for (const edit of editResponses.edits) {
+      if (edit.type === "addLink") {
+        remappedActionResponse.addedLinks.push({
+          linkTypeApiNameAtoB: edit.linkTypeApiNameAtoB,
+          linkTypeApiNameBtoA: edit.linkTypeApiNameBtoA,
+          aSideObject: edit.aSideObject,
+          bSideObject: edit.bSideObject
+        });
+        editedObjectTypesSet.add(edit.aSideObject.objectType);
+        editedObjectTypesSet.add(edit.bSideObject.objectType);
+      } else if (edit.type === "addObject") {
+        remappedActionResponse.addedObjects.push({
+          objectType: edit.objectType,
+          primaryKey: edit.primaryKey
+        });
+        editedObjectTypesSet.add(edit.objectType);
+      } else if (edit.type === "modifyObject") {
+        remappedActionResponse.modifiedObjects.push({
+          objectType: edit.objectType,
+          primaryKey: edit.primaryKey
+        });
+        editedObjectTypesSet.add(edit.objectType);
+      } else {
+        process.env.NODE_ENV !== "production" ? invariant(false, "Unknown edit type") : invariant(false) ;
+      }
+    }
+    remappedActionResponse.editedObjectTypes = [...editedObjectTypesSet];
+    return remappedActionResponse;
+  }
+}
+async function loadActionMetadata(client, actionType) {
+  const r = await esm_exports.ActionTypesV2.getActionTypeV2(client, await client.ontologyRid, actionType);
+  return wireActionTypeV2ToSdkActionMetadata(r);
+}
+async function loadFullObjectMetadata(client, objectType) {
+  const full = await esm_exports.ObjectTypesV2.getObjectTypeFullMetadata(client, await client.ontologyRid, objectType, {
+    preview: true
+  });
+  const ret = wireObjectTypeFullMetadataToSdkObjectMetadata(full, true);
+  client.logger?.debug(`END loadFullObjectMetadata(${objectType})`);
+  return {
+    ...ret
+  };
+}
+async function loadInterfaceMetadata(client, objectType) {
+  const r = await esm_exports.OntologyInterfaces.getInterfaceType(client, await client.ontologyRid, objectType, {
+    preview: true
+  });
+  return __UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(r, true);
+}
+async function loadQueryMetadata(client, queryType) {
+  const r = await esm_exports.QueryTypes.getQueryTypeV2(client, await client.ontologyRid, queryType);
+  return wireQueryTypeV2ToSdkQueryMetadata(r);
+}
+
+// src/ontology/StandardOntologyProvider.ts
+var createStandardOntologyProviderFactory = (client) => {
+  return (client2) => {
+    async function loadObject(client3, key) {
+      let objectDef = await loadFullObjectMetadata(client3, key);
+      const interfaceDefs = Object.fromEntries((await Promise.all(objectDef.implements?.map((i) => ret.getInterfaceDefinition(i)) ?? [])).map((i) => [i.apiName, {
+        def: i,
+        handler: void 0
+      }]));
+      const fullObjectDef = {
+        ...objectDef,
+        [InterfaceDefinitions]: interfaceDefs
+      };
+      return fullObjectDef;
+    }
+    async function loadInterface(client3, key) {
+      return loadInterfaceMetadata(client3, key);
+    }
+    async function loadQuery(client3, key) {
+      const r = await loadQueryMetadata(client3, key);
+      return r;
+    }
+    async function loadAction(client3, key) {
+      const r = await loadActionMetadata(client3, key);
+      return r;
+    }
+    function makeGetter(fn) {
+      const cache = createAsyncClientCache((client3, key) => fn(client3, key, false));
+      return async (apiName) => {
+        return await cache.get(client2, apiName);
+      };
+    }
+    const ret = {
+      getObjectDefinition: makeGetter(loadObject),
+      getInterfaceDefinition: makeGetter(loadInterface),
+      getQueryDefinition: makeGetter(loadQuery),
+      getActionDefinition: makeGetter(loadAction)
+    };
+    return ret;
+  };
+};
+
+// src/util/UserAgent.ts
+var USER_AGENT = `osdk-client/${"2.0.0-beta.13"}`;
+
+// src/createMinimalClient.ts
+function createMinimalClient(metadata, baseUrl, tokenProvider, options = {}, fetchFn = global.fetch, objectSetFactory = createObjectSet) {
+  if (process?.env?.NODE_ENV !== "production") {
+    try {
+      new URL(baseUrl);
+    } catch (e) {
+      const hint = !baseUrl.startsWith("http://") || !baseUrl.startsWith("https://") ? ". Did you forget to add 'http://' or 'https://'?" : "";
+      throw new Error(`Invalid stack URL: ${baseUrl}${hint}`);
+    }
+  }
+  const minimalClient = {
+    ...createSharedClientContext(baseUrl, tokenProvider, USER_AGENT, fetchFn),
+    objectSetFactory,
+    ontologyRid: metadata.ontologyRid,
+    logger: options.logger,
+    clientCacheKey: {},
+    requestContext: {}
+  };
+  return Object.assign(minimalClient, {
+    ontologyProvider: createStandardOntologyProviderFactory()(minimalClient)
+  });
+}
+
+// src/fetchMetadata.ts
+var fetchMetadataInternal = async (client, definition) => {
+  if (definition.type === "object") {
+    const {
+      [InterfaceDefinitions]: interfaceDefs,
+      ...objectTypeDef
+    } = await client.ontologyProvider.getObjectDefinition(definition.apiName);
+    return objectTypeDef;
+  } else if (definition.type === "interface") {
+    return client.ontologyProvider.getInterfaceDefinition(definition.apiName);
+  } else if (definition.type === "action") {
+    return client.ontologyProvider.getActionDefinition(definition.apiName);
+  } else if (definition.type === "query") {
+    return client.ontologyProvider.getQueryDefinition(definition.apiName);
+  } else {
+    throw new Error("Not implemented for given definition");
+  }
+};
+
+// src/util/isOsdkBaseObject.ts
+function isOsdkBaseObject2(o) {
+  return o && typeof o === "object" && typeof o.$apiName === "string" && o.$primaryKey != null;
+}
+
+// src/util/toDataValueQueries.ts
+async function toDataValueQueries(value, client, desiredType) {
+  if (value == null) {
+    return value;
+  }
+  if (Array.isArray(value) && desiredType.multiplicity) {
+    const promiseArray = Array.from(value, async (innerValue) => await toDataValueQueries(innerValue, client, desiredType));
+    return Promise.all(promiseArray);
+  }
+  switch (desiredType.type) {
+    case "attachment": {
+      if (isAttachmentUpload(value)) {
+        const attachment = await esm_exports.Attachments.uploadAttachmentV2(client, value, {
+          filename: value.name
+        });
+        return attachment.rid;
+      }
+      return value;
+    }
+    case "twoDimensionalAggregation": {
+      return {
+        groups: value
+      };
+    }
+    case "threeDimensionalAggregation": {
+      return {
+        groups: value
+      };
+    }
+    case "set": {
+      if (value instanceof Set) {
+        const promiseArray = Array.from(value, async (innerValue) => await toDataValueQueries(innerValue, client, desiredType["set"]));
+        return Promise.all(promiseArray);
+      }
+      break;
+    }
+    case "object": {
+      if (isOsdkBaseObject2(value)) {
+        return value.$primaryKey;
+      }
+      break;
+    }
+    case "objectSet": {
+      if (isWireObjectSet(value)) {
+        return value;
+      }
+      if (isObjectSet(value)) {
+        return getWireObjectSet(value);
+      }
+      break;
+    }
+    case "struct": {
+      if (typeof value === "object") {
+        const structMap = {};
+        for (const [key, structValue] of Object.entries(value)) {
+          structMap[key] = await toDataValueQueries(structValue, client, desiredType["struct"][key]);
+        }
+        return structMap;
+      }
+    }
+    case "boolean":
+    case "date":
+    case "double":
+    case "float":
+    case "integer":
+    case "long":
+    case "string":
+    case "timestamp":
+      return value;
+  }
+  return value;
+}
+
+// src/queries/applyQuery.ts
+async function applyQuery(client, query, params) {
+  const qd = await client.ontologyProvider.getQueryDefinition(query.apiName);
+  const response = await esm_exports.Queries.executeQueryV2(addUserAgentAndRequestContextHeaders(augmentRequestContext(client, (_) => ({
+    finalMethodCall: "applyQuery"
+  })), query), await client.ontologyRid, query.apiName, {
+    parameters: params ? await remapQueryParams(params, client, qd.parameters) : {}
+  });
+  const objectOutputDefs = await getRequiredDefinitions(qd.output, client);
+  const remappedResponse = await remapQueryResponse(client, qd.output, response.value, objectOutputDefs);
+  return remappedResponse;
+}
+async function remapQueryParams(params, client, paramTypes) {
+  const parameterMap = {};
+  for (const [key, value] of Object.entries(params)) {
+    parameterMap[key] = await toDataValueQueries(value, client, paramTypes[key]);
+  }
+  return parameterMap;
+}
+async function remapQueryResponse(client, responseDataType, responseValue, definitions) {
+  if (responseValue == null) {
+    if (responseDataType.nullable) {
+      return void 0;
+    } else {
+      throw new Error("Got null response when nullable was not allowed");
+    }
+  }
+  if (responseDataType.multiplicity != null && responseDataType.multiplicity !== false) {
+    const withoutMultiplicity = {
+      ...responseDataType,
+      multiplicity: false
+    };
+    for (let i = 0; i < responseValue.length; i++) {
+      responseValue[i] = await remapQueryResponse(responseValue[i], withoutMultiplicity, client, definitions);
+    }
+    return responseValue;
+  }
+  switch (responseDataType.type) {
+    case "union": {
+      throw new Error("Union return types are not yet supported");
+    }
+    case "set": {
+      for (let i = 0; i < responseValue.length; i++) {
+        responseValue[i] = await remapQueryResponse(responseValue[i], responseDataType.set, client, definitions);
+      }
+      return responseValue;
+    }
+    case "attachment": {
+      return createAttachmentFromRid(client, responseValue);
+    }
+    case "object": {
+      const def = definitions.get(responseDataType.object);
+      if (!def) {
+        throw new Error(`Missing definition for ${responseDataType.object}`);
+      }
+      return createQueryObjectResponse(responseValue, def);
+    }
+    case "objectSet": {
+      const def = definitions.get(responseDataType.objectSet);
+      if (!def) {
+        throw new Error(`Missing definition for ${responseDataType.objectSet}`);
+      }
+      if (typeof responseValue === "string") {
+        return createObjectSet(def, client, {
+          type: "intersect",
+          objectSets: [{
+            type: "base",
+            objectType: responseDataType.objectSet
+          }, {
+            type: "reference",
+            reference: responseValue
+          }]
+        });
+      }
+      return createObjectSet(def, client, responseValue);
+    }
+    case "struct": {
+      for (const [key, subtype] of Object.entries(responseDataType.struct)) {
+        if (requiresConversion(subtype)) {
+          responseValue[key] = await remapQueryResponse(responseValue[key], subtype, client, definitions);
+        }
+      }
+      return responseValue;
+    }
+    case "twoDimensionalAggregation": {
+      const result = [];
+      for (const {
+        key,
+        value
+      } of responseValue.groups) {
+        result.push({
+          key,
+          value
+        });
+      }
+      return result;
+    }
+    case "threeDimensionalAggregation": {
+      const result = [];
+      for (const {
+        key,
+        groups
+      } of responseValue.groups) {
+        const subResult = [];
+        for (const {
+          key: subKey,
+          value
+        } of groups) {
+          subResult.push({
+            key: subKey,
+            value
+          });
+        }
+        result.push({
+          key,
+          groups: subResult
+        });
+      }
+      return result;
+    }
+  }
+  return responseValue;
+}
+async function getRequiredDefinitions(dataType, client) {
+  const result = /* @__PURE__ */ new Map();
+  switch (dataType.type) {
+    case "objectSet": {
+      const objectDef = await client.ontologyProvider.getObjectDefinition(dataType.objectSet);
+      result.set(dataType.objectSet, objectDef);
+      break;
+    }
+    case "object": {
+      const objectDef = await client.ontologyProvider.getObjectDefinition(dataType.object);
+      result.set(dataType.object, objectDef);
+      break;
+    }
+    case "set": {
+      return getRequiredDefinitions(dataType.set, client);
+    }
+    case "struct": {
+      for (const value of Object.values(dataType.struct)) {
+        for (const [type, objectDef] of await getRequiredDefinitions(value, client)) {
+          result.set(type, objectDef);
+        }
+      }
+      break;
+    }
+  }
+  return result;
+}
+function requiresConversion(dataType) {
+  switch (dataType.type) {
+    case "boolean":
+    case "date":
+    case "double":
+    case "float":
+    case "integer":
+    case "long":
+    case "object":
+    case "string":
+    case "timestamp":
+      return false;
+    case "union":
+      return true;
+    case "struct":
+      return Object.values(dataType.struct).some(requiresConversion);
+    case "set":
+      return requiresConversion(dataType.set);
+    case "attachment":
+    case "objectSet":
+    case "twoDimensionalAggregation":
+    case "threeDimensionalAggregation":
+      return true;
+    default:
+      return false;
+  }
+}
+function createQueryObjectResponse(primaryKey, objectDef) {
+  return {
+    $apiName: objectDef.apiName,
+    $title: void 0,
+    $objectType: objectDef.apiName,
+    $primaryKey: primaryKey
+  };
+}
+
+// src/createClient.ts
+var ActionInvoker = class {
+  constructor(clientCtx, actionDef) {
+    this.applyAction = applyAction.bind(void 0, clientCtx, actionDef);
+    this.batchApplyAction = applyAction.bind(void 0, clientCtx, actionDef);
+  }
+};
+var QueryInvoker = class {
+  constructor(clientCtx, queryDef) {
+    this.executeFunction = applyQuery.bind(void 0, clientCtx, queryDef);
+  }
+};
+function createClientInternal(objectSetFactory, baseUrl, ontologyRid, tokenProvider, options = void 0, fetchFn = fetch) {
+  const clientCtx = createMinimalClient({
+    ontologyRid
+  }, baseUrl, tokenProvider, options, fetchFn, objectSetFactory);
+  function clientFn(o) {
+    if (o.type === "object" || o.type === "interface") {
+      return objectSetFactory(o, clientCtx);
+    } else if (o.type === "action") {
+      return new ActionInvoker(clientCtx, o);
+    } else if (o.type === "query") {
+      return new QueryInvoker(clientCtx, o);
+    } else {
+      throw new Error("not implemented");
+    }
+  }
+  const fetchMetadata = fetchMetadataInternal.bind(void 0, clientCtx);
+  const client = Object.defineProperties(clientFn, {
+    [symbolClientContext]: {
+      value: clientCtx
+    },
+    [__EXPERIMENTAL__NOT_SUPPORTED_YET__getBulkLinks]: {
+      get: () => createBulkLinksAsyncIterFactory(clientCtx)
+    },
+    [__EXPERIMENTAL__NOT_SUPPORTED_YET__preexistingObjectSet]: {
+      get: () => (definition, rid) => {
+        return createObjectSet(definition, client[symbolClientContext], {
+          type: "intersect",
+          objectSets: [{
+            type: "base",
+            objectType: definition.apiName
+          }, {
+            type: "reference",
+            reference: rid
+          }]
+        });
+      }
+    },
+    fetchMetadata: {
+      value: fetchMetadata
+    }
+  });
+  return client;
+}
+var createClient = createClientInternal.bind(void 0, createObjectSet);
 function createPlatformClient(baseUrl, tokenProvider, options = void 0, fetchFn = fetch) {
   return createSharedClientContext(baseUrl, tokenProvider, USER_AGENT, fetchFn);
 }
 
-export { createPlatformClient };
+export { ActionValidationError, createAttachmentUpload, createClient, createPlatformClient };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map