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

package/build/esm/index.js

@@ -1,726 +1,23 @@
-import { createObjectSet, metadataCacheClient, conjureUnionType, makeConjureContext, InterfaceDefinitions, createAsyncClientCache, addUserAgentAndRequestContextHeaders, augmentRequestContext, esm_exports, createAttachmentFromRid, isWireObjectSet, isObjectSet, getWireObjectSet } from './chunk-MQTCPUPF.js';
-export { createAttachmentFromRid } from './chunk-MQTCPUPF.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 { ActionValidationError, createAttachmentUpload, createClient, createPlatformClient };
-//# sourceMappingURL=index.js.map
+/*
+ * Copyright 2023 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export { isOk } from "@osdk/api";
+export { PalantirApiError } from "@osdk/shared.net.errors";
+export { ActionValidationError } from "./actions/ActionValidationError.js";
+export { createAttachmentFromRid } from "./createAttachmentFromRid.js";
+export { createClient } from "./createClient.js";
+export { createPlatformClient } from "./createPlatformClient.js";
+export { createAttachmentUpload } from "./object/AttachmentUpload.js";
 //# sourceMappingURL=index.js.map