@osdk/generator 2.0.0-beta.9 → 2.0.1

package/build/browser/index.js

@@ -1,1560 +1,18 @@
-import * as fs from 'fs';
-import * as path5 from 'path';
-import path5__default from 'path';
-import { __UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition, wireObjectTypeFullMetadataToSdkObjectTypeDefinition } from '@osdk/generator-converters';
-import { format } from 'prettier';
-import fastDeepEqual from 'fast-deep-equal';
-import invariant from 'tiny-invariant';
-
-// src/generateClientSdkPackage.ts
-var AbstractImportable = class {
-  /**
-   * Either a path relative to the ourDir (e.g. "./ontology/objects/foo.js") or a normal
-   * module import (e.g. "@something/foo")/
-   */
-  constructor(common, fullApiName, basePath) {
-    this._common = common;
-    this.fullApiName = fullApiName;
-    [this.apiNamespace, this.shortApiName] = extractNamespace(this.fullApiName);
-    const {
-      ontologyApiNamespace,
-      apiNamespacePackageMap,
-      importExt
-    } = common;
-    this.isLocal = ontologyApiNamespace === this.apiNamespace;
-    this.sourcePackage = this.apiNamespace && !this.isLocal ? apiNamespacePackageMap.get(this.apiNamespace) : void 0;
-    this.importPath = this.isLocal ? `${basePath}/${this.shortApiName}${importExt}` : this.sourcePackage;
-    this.uniqueImportName = this.shortApiName;
-  }
-  getImportPathRelTo = (filePath) => {
-    if (this.importPath.startsWith(".")) {
-      const result = path5.relative(path5.dirname(filePath), this.importPath);
-      if (result.startsWith(".")) {
-        return result;
-      } else {
-        return `./${result}`;
-      }
-    } else {
-      return this.importPath;
-    }
-  };
-};
-var EnhancedBase = class extends AbstractImportable {
-  constructor(common, raw, fullApiName, basePath) {
-    super(common, fullApiName, basePath);
-    this.raw = raw;
-    if (!this.isLocal && !this.sourcePackage) {
-      throw new Error(`Expected { ns:'${this.apiNamespace}', shortName: '${this.shortApiName}'} to be in namespace '${common.ontologyApiNamespace}' or in a provided package mapping`);
-    }
-  }
-};
-function extractNamespace(fqApiName) {
-  const last = fqApiName.lastIndexOf(".");
-  if (last === -1) return [void 0, fqApiName];
-  return [fqApiName.slice(0, last), fqApiName.slice(last + 1)];
-}
-
-// src/GenerateContext/EnhancedAction.ts
-var EnhancedAction = class extends EnhancedBase {
-  constructor(common, raw) {
-    super(common, raw, raw.apiName, "./ontology/actions");
-    this.raw = raw;
-  }
-  get description() {
-    return this.raw.description;
-  }
-  get parameters() {
-    return this.raw.parameters;
-  }
-  get operations() {
-    return this.raw.operations;
-  }
-  get paramsIdentifier() {
-    return `${this.shortApiName}.Params`;
-  }
-  get definitionIdentifier() {
-    return `${this.shortApiName}.Definition`;
-  }
-  get definitionParamsIdentifier() {
-    return `${this.shortApiName}.ParamsDefinition`;
-  }
-};
-
-// src/util/deleteUndefineds.ts
-function deleteUndefineds(obj) {
-  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== void 0));
-}
-
-// src/GenerateContext/EnhancedInterfaceType.ts
-var EnhancedInterfaceType = class extends EnhancedBase {
-  constructor(common, raw) {
-    super(common, raw, raw.apiName, "./ontology/interfaces");
-    this.raw = raw;
-  }
-  getDefinitionIdentifier(v2) {
-    return v2 ? this.shortApiName : `${this.shortApiName}Def`;
-  }
-  getImportedDefinitionIdentifier(v2) {
-    return this.getDefinitionIdentifier(v2);
-  }
-  get properties() {
-    return this.raw.properties;
-  }
-  getCleanedUpDefinition(v2) {
-    return deleteUndefineds(__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(this.raw, v2));
-  }
-};
-var EnhancedObjectType = class extends EnhancedBase {
-  constructor(common, raw) {
-    super(common, raw, raw.objectType.apiName, "./ontology/objects");
-    this.raw = raw;
-  }
-  getDefinitionIdentifier(v2) {
-    return v2 ? `${this.shortApiName}` : `${this.shortApiName}Def`;
-  }
-  getImportedDefinitionIdentifier(v2) {
-    return this.getDefinitionIdentifier(v2);
-  }
-  getCleanedUpDefinition(v2) {
-    return deleteUndefineds(wireObjectTypeFullMetadataToSdkObjectTypeDefinition(this.raw, v2));
-  }
-};
-
-// src/GenerateContext/EnhancedQuery.ts
-var EnhancedQuery = class extends EnhancedBase {
-  constructor(common, raw) {
-    super(common, raw, raw.apiName, "./ontology/queries");
-    this.raw = raw;
-  }
-  get description() {
-    return this.raw.description;
-  }
-  get parameters() {
-    return this.raw.parameters;
-  }
-  get output() {
-    return this.raw.output;
-  }
-  get paramsIdentifier() {
-    return `${this.shortApiName}.Parameters`;
-  }
-  get definitionIdentifier() {
-    return `${this.shortApiName}.Definition`;
-  }
-  get definitionParamsIdentifier() {
-    return `${this.definitionIdentifier}$Params`;
-  }
-};
-
-// src/GenerateContext/EnhancedSharedPropertyType.ts
-var EnhancedSharedPropertyType = class extends EnhancedBase {
-  constructor(common, raw) {
-    super(common, raw, raw.apiName, "./ontology/interfaces");
-    this.raw = raw;
-  }
-};
-
-// src/GenerateContext/ForeignType.ts
-var ForeignType = class extends AbstractImportable {
-  constructor(_common, type, apiNamespace, shortApiName) {
-    super(_common, `${apiNamespace}.${shortApiName}`, _common.apiNamespacePackageMap.get(apiNamespace));
-    this._common = _common;
-    this.type = type;
-  }
-  getImportedDefinitionIdentifier(v2) {
-    return `$Imported$${this.type}$${this.apiNamespace.replace(/\./g, "$")}$${this.shortApiName}`;
-  }
-  getDefinitionIdentifier(v2) {
-    if (this.type === "objectTypes") {
-      return v2 ? this.uniqueImportName : `${this.uniqueImportName}Def`;
-    } else {
-      return this.uniqueImportName;
-    }
-  }
-};
-
-// src/GenerateContext/EnhancedOntologyDefinition.ts
-var EnhancedOntologyDefinition = class {
-  #foreignTypes = {};
-  constructor(raw, ontologyApiNamespace, apiNamespacePackageMap, importExt) {
-    this.common = {
-      apiNamespacePackageMap,
-      enhancedOntology: this,
-      importExt,
-      ontologyApiNamespace
-    };
-    this.raw = raw;
-    this.ontology = raw.ontology;
-    this.objectTypes = remap(raw.objectTypes, this.common, EnhancedObjectType);
-    this.actionTypes = remap(raw.actionTypes, this.common, EnhancedAction);
-    this.queryTypes = remap(raw.queryTypes, this.common, EnhancedQuery);
-    this.interfaceTypes = remap(raw.interfaceTypes, this.common, EnhancedInterfaceType);
-    this.sharedPropertyTypes = remap(raw.sharedPropertyTypes, this.common, EnhancedSharedPropertyType);
-  }
-  #createRequireType = (type) => {
-    return (fullApiName, localOnly) => {
-      const ret = this[type][fullApiName];
-      if (!ret) {
-        const [apiNamespace, shortApiName] = extractNamespace(fullApiName);
-        if (localOnly || !apiNamespace) {
-          throw new Error(`Unable to find ${type}: No entry for '${fullApiName}`);
-        }
-        if (!this.common.apiNamespacePackageMap.has(apiNamespace)) {
-          throw new Error(`Unable to find ${type}: Unknown namespace '${apiNamespace}'`);
-        }
-        const ret2 = this.#foreignTypes[fullApiName] ?? new ForeignType(this.common, type, apiNamespace, shortApiName);
-        this.#foreignTypes[fullApiName] = ret2;
-        return ret2;
-      }
-      return ret;
-    };
-  };
-  requireObjectType = this.#createRequireType("objectTypes");
-  requireInterfaceType = this.#createRequireType("interfaceTypes");
-  requireActionType = this.#createRequireType("actionTypes");
-  requireQueryType = this.#createRequireType("queryTypes");
-  requireSharedPropertyType = this.#createRequireType("sharedPropertyTypes");
-};
-function remap(r, common, Constructor) {
-  return Object.fromEntries(Object.entries(r ?? {}).map(([fullApiName, v]) => {
-    return [fullApiName, new Constructor(common, v)];
-  }).sort((a, b) => a[0].localeCompare(b[0])));
-}
-
-// src/GenerateContext/enhanceOntology.ts
-function enhanceOntology(sanitized, ontologyApiNamespace, apiNamespacePackageMap, importExt) {
-  return new EnhancedOntologyDefinition(sanitized, ontologyApiNamespace, apiNamespacePackageMap, importExt);
-}
-
-// src/shared/sanitizeMetadata.ts
-function sanitizeMetadata(ontology) {
-  return {
-    ...ontology,
-    actionTypes: Object.fromEntries(Object.values(ontology.actionTypes).map((actionType) => {
-      return [camelize(actionType.apiName), {
-        ...actionType,
-        apiName: camelize(actionType.apiName)
-      }];
-    }))
-  };
-}
-function camelize(name) {
-  return name.replace(/-./g, (segment) => segment[1].toUpperCase());
-}
-function formatTs(contents) {
-  try {
-    return format(contents, {
-      parser: "typescript",
-      singleQuote: true,
-      trailingComma: "all",
-      tabWidth: 2,
-      printWidth: 120
-    });
-  } catch (e) {
-    console.error("Failed to format file", e);
-    console.log(contents);
-    return contents;
-  }
-}
-
-// src/util/verifyOutDir.ts
-async function verifyOutDir(outDir, fs2) {
-  try {
-    const contents = await fs2.readdir(outDir);
-    if (contents.length !== 0) {
-      throw new Error(`outDir ${outDir} is not empty, please delete its contents and try again`);
-    }
-  } catch (e) {
-    if (e.code === "ENOENT") ; else {
-      throw e;
-    }
-  }
-}
-var ExpectedOsdkVersion = "2.0.0";
-async function generateOntologyMetadataFile({
-  fs: fs2,
-  outDir,
-  ontology,
-  ontologyApiNamespace
-}, userAgent) {
-  fs2.writeFile(path5__default.join(outDir, "OntologyMetadata.ts"), await formatTs(`
-      export type $ExpectedClientVersion = "${ExpectedOsdkVersion}";
-      export const $osdkMetadata = { extraUserAgent: "${userAgent}" };
-      ${ontologyApiNamespace == null ? `
-        export const $ontologyRid = "${ontology.ontology.rid}";
-        ` : ""}
-      `));
-}
-
-// src/shared/getObjectImports.ts
-function getObjectImports(objects, curApiName, currentFilePath, v2) {
-  return Array.from(objects).filter((obj) => obj.fullApiName !== curApiName).map((obj) => {
-    const defId = obj.getDefinitionIdentifier(v2);
-    const importedId = obj.getImportedDefinitionIdentifier(v2);
-    const nameOrAlias = defId === importedId ? defId : `${defId} as ${importedId}`;
-    return `import type { ${nameOrAlias} } from "${obj.getImportPathRelTo("./" + currentFilePath)}";`;
-  }).join("\n");
-}
-
-// src/shared/getEditedEntities.ts
-function getModifiedEntityTypes(action) {
-  const addedObjects = /* @__PURE__ */ new Set();
-  const modifiedObjects = /* @__PURE__ */ new Set();
-  for (const operation of action.operations) {
-    switch (operation.type) {
-      case "createObject":
-        addedObjects.add(operation.objectTypeApiName);
-        break;
-      case "modifyObject":
-        modifiedObjects.add(operation.objectTypeApiName);
-        break;
-    }
-  }
-  return {
-    addedObjects,
-    modifiedObjects
-  };
-}
-
-// src/shared/wireActionTypeV2ToSdkActionDefinition.ts
-function wireActionTypeV2ToSdkActionDefinition(input) {
-  const modifiedEntityTypes = getModifiedEntityTypes(input);
-  return {
-    type: "action",
-    apiName: input.apiName,
-    parameters: Object.fromEntries(Object.entries(input.parameters).map(([key, value]) => [key, wireActionParameterV2ToSdkParameterDefinition(value)])),
-    displayName: input.displayName,
-    description: input.description,
-    modifiedEntities: createModifiedEntities(modifiedEntityTypes.addedObjects, modifiedEntityTypes.modifiedObjects)
-  };
-}
-function wireActionParameterV2ToSdkParameterDefinition(value) {
-  return {
-    multiplicity: value.dataType.type === "array",
-    type: actionPropertyToSdkPropertyDefinition(value.dataType.type === "array" ? value.dataType.subType : value.dataType),
-    nullable: !value.required,
-    description: value.description
-  };
-}
-function actionPropertyToSdkPropertyDefinition(parameterType) {
-  switch (parameterType.type) {
-    case "string":
-    case "boolean":
-    case "attachment":
-    case "double":
-    case "integer":
-    case "long":
-    case "timestamp":
-    case "marking":
-      return parameterType.type;
-    case "date":
-      return "datetime";
-    case "objectSet":
-      return {
-        type: "objectSet",
-        objectSet: parameterType.objectTypeApiName
-      };
-    case "object":
-      return {
-        type: "object",
-        object: parameterType.objectTypeApiName
-      };
-    case "array":
-      return actionPropertyToSdkPropertyDefinition(parameterType.subType);
-  }
-}
-function createModifiedEntities(addedObjects, modifiedObjects) {
-  let entities = {};
-  for (const key of addedObjects) {
-    entities[key] = {
-      created: true,
-      modified: false
-    };
-  }
-  for (const key of modifiedObjects) {
-    if (entities[key]) {
-      entities[key].modified = true;
-    } else {
-      entities[key] = {
-        created: false,
-        modified: true
-      };
-    }
-  }
-  return entities;
-}
-
-// src/util/stringify.ts
-var defaultCustomizer = (value, defaultValueFormatter, key, defaultKeyFormatter) => {
-  return [defaultKeyFormatter(key), defaultValueFormatter(value)];
-};
-function stringify(obj, customizer = {}, separator = ",\n") {
-  const defaultKeyFormatter = (key) => `${JSON.stringify(key)}`;
-  const entries = [];
-  const sortedKeys = Object.keys(obj).sort((a, b) => a.localeCompare(b));
-  for (const key of sortedKeys) {
-    const value = obj[key];
-    const res = (customizer[key] ?? customizer["*"] ?? defaultCustomizer)(value, (value2) => JSON.stringify(value2, null, 2), key, defaultKeyFormatter);
-    if (res) {
-      if (typeof res === "string") {
-        entries.push(`${defaultKeyFormatter(key)}: ${res}`);
-      } else {
-        entries.push(`${res[0]}: ${res[1]}`);
-      }
-    }
-  }
-  return entries.join(separator);
-}
-
-// src/util/stringUnionFrom.ts
-function stringUnionFrom(values) {
-  if (values.length === 0) {
-    return "never";
-  } else {
-    return values.map((v) => `"${v}"`).join("|");
-  }
-}
-
-// src/v2.0/getDescriptionIfPresent.ts
-function getDescriptionIfPresent(description, includeNewline) {
-  if (description) {
-    return `/**
- * ${description}
- */${""}`;
-  }
-  return "";
-}
-
-// src/shared/propertyJsdoc.ts
-function propertyJsdoc(property, {
-  isInherited,
-  apiName
-}) {
-  let ret = `/**
-`;
-  const renderDisplayName = property.displayName && property.displayName !== apiName;
-  if (isInherited || renderDisplayName || property.description) {
-    if (isInherited) {
-      ret += ` * (inherited from parent)
-`;
-    }
-    if (renderDisplayName) {
-      ret += ` *   display name: '${property.displayName}'${property.description ? "," : ""}
-`;
-    }
-    if (property.description) {
-      ret += ` *   description: ${property.description}
-`;
-    }
-  } else {
-    ret += ` * (no ontology metadata)
-`;
-  }
-  ret += ` */
-`;
-  return ret;
-}
-
-// src/v2.0/wireObjectTypeV2ToSdkObjectConstV2.ts
-function getObjectDefIdentifier(name, v2) {
-  return v2 ? name : `${name}Def`;
-}
-function wireObjectTypeV2ToSdkObjectConstV2(wireObject, {
-  ontology
-}, currentFilePath) {
-  const object = ontology.requireObjectType(wireObject.objectType.apiName, true);
-  const uniqueLinkTargetTypes = new Set(wireObject.linkTypes.map((a) => ontology.requireObjectType(a.objectTypeApiName, false)));
-  const definition = deleteUndefineds(wireObjectTypeFullMetadataToSdkObjectTypeDefinition(object.raw, true));
-  const objectDefIdentifier = object.getDefinitionIdentifier(true);
-  const objectSetIdentifier = `${object.shortApiName}.ObjectSet`;
-  const propertyKeysIdentifier = `${object.shortApiName}.PropertyKeys`;
-  const osdkObjectPropsIdentifier = `${object.shortApiName}.Props`;
-  const osdkObjectStrictPropsIdentifier = `${object.shortApiName}.StrictProps`;
-  const osdkObjectLinksIdentifier = `${object.shortApiName}.Links`;
-  const osdkObjectIdentifier = `${object.shortApiName}.OsdkObject`;
-  const identifiers = {
-    objectDefIdentifier: `${object.shortApiName}`,
-    osdkObjectLinksIdentifier,
-    osdkObjectPropsIdentifier,
-    osdkObjectStrictPropsIdentifier,
-    objectSetIdentifier,
-    osdkObjectIdentifier,
-    propertyKeysIdentifier
-  };
-  function getV2Types() {
-    return `import type {
-      ObjectOrInterfacePropertyKeysFrom2 as $ObjectOrInterfacePropertyKeysFrom2,  
-      ObjectTypeDefinition as $ObjectTypeDefinition,
-      ObjectTypeLinkDefinition as $ObjectTypeLinkDefinition,
-    } from "@osdk/api";
-     import type {
-      ObjectSet as $ObjectSet, 
-      Osdk as $Osdk,
-      OsdkObject as $OsdkObject,
-      PropertyValueWireToClient as $PropType,
-      SingleLinkAccessor  as $SingleLinkAccessor,
-    } from "@osdk/client.api";
-
-
-    export namespace ${object.shortApiName} {
-
-      ${createPropertyKeys(object)}
-
-
-      ${createLinks(ontology, object, "Links")}
-
-      ${createProps(object, "Props", false)}
-      ${createProps(object, "StrictProps", true)}
-
-      ${createObjectSet(object, identifiers)}
-      
-      ${createOsdkObject(object, "OsdkObject", identifiers)}
-    }    
-
-
-
-    ${createDefinition(object, ontology, object.shortApiName, identifiers)}
-  
-  
-
-
-    `;
-  }
-  const imports = getObjectImports(uniqueLinkTargetTypes, definition.apiName, currentFilePath, true);
-  return `${imports}${getV2Types()}
-
-    export const ${object.shortApiName}: ${objectDefIdentifier}
-    = {
-      osdkMetadata: $osdkMetadata,
-      objectSet: undefined as any,
-      props: undefined as any,
-      linksType: undefined as any,
-      strictProps: undefined as any,
-      ${stringify(definition, {
-    osdkMetadata: (value) => void 0
-  })}
-    
-    };`;
-}
-function createOsdkObject(object, identifier, {
-  osdkObjectPropsIdentifier,
-  objectDefIdentifier,
-  osdkObjectStrictPropsIdentifier,
-  osdkObjectLinksIdentifier
-}) {
-  object.getCleanedUpDefinition(true);
-  return `
-  export type ${identifier}<
-      OPTIONS extends never | "$notStrict" | "$rid" = never,
-      K extends keyof ${osdkObjectPropsIdentifier}= keyof ${osdkObjectPropsIdentifier},
-
-  > 
-    = $Osdk<
-        ${objectDefIdentifier}, 
-        K | OPTIONS
-      > 
-   
-  ;
-    `;
-}
-function createObjectSet(object, {
-  objectDefIdentifier,
-  objectSetIdentifier,
-  propertyKeysIdentifier,
-  osdkObjectIdentifier
-}) {
-  return `
-export interface ObjectSet extends 
-$ObjectSet<${objectDefIdentifier},
-
-${objectSetIdentifier}
->
-{
-
-}
-`;
-}
-function maybeStripNamespace(type, q) {
-  if (type.apiNamespace && q.startsWith(`${type.apiNamespace}.`)) {
-    return q.slice(type.apiNamespace.length + 1);
-  } else {
-    return q;
-  }
-}
-function createProps(type, identifier, strict) {
-  const definition = type.getCleanedUpDefinition(true);
-  return `export interface ${identifier} {
-${stringify(definition.properties, {
-    "*": (propertyDefinition, _, apiName) => {
-      return [`readonly "${maybeStripNamespace(type, apiName)}"${// after we convert everything over we can do this:
-      // !strict || propertyDefinition.nullable ? "?" : ""
-      ""}`, `$PropType[${JSON.stringify(propertyDefinition.type)}]${propertyDefinition.multiplicity ? "[]" : ""}${propertyDefinition.nullable || !strict ? `| undefined` : ""}`];
-    }
-  })}
-    }`;
-}
-function createDefinition(object, ontology, identifier, {
-  objectDefIdentifier,
-  objectSetIdentifier,
-  osdkObjectPropsIdentifier,
-  osdkObjectStrictPropsIdentifier,
-  osdkObjectLinksIdentifier
-}) {
-  const definition = object.getCleanedUpDefinition(true);
-  return `
-    export interface ${identifier} extends ${object instanceof EnhancedObjectType ? `$ObjectTypeDefinition` : `$InterfaceDefinition`}<"${object.fullApiName}", ${objectDefIdentifier}> {
-      osdkMetadata: typeof $osdkMetadata;
-      objectSet: ${objectSetIdentifier};
-      props: ${osdkObjectPropsIdentifier};
-      linksType: ${osdkObjectLinksIdentifier};
-      strictProps: ${osdkObjectStrictPropsIdentifier};
-      ${stringify(definition, {
-    osdkMetadata: () => void 0,
-    // we are going to reference another object instead
-    type: () => void 0,
-    apiName: () => void 0,
-    links: (_value) => `{
-        ${stringify(definition.links, {
-      "*": (definition2) => `$ObjectTypeLinkDefinition<${ontology.requireObjectType(definition2.targetType).getImportedDefinitionIdentifier(true)}, ${definition2.multiplicity}>`
-    })}
-      }`,
-    properties: (_value) => `{
-        ${stringify(definition.properties, {
-      "*": (propertyDefinition, _, apiName) => [`${propertyJsdoc(propertyDefinition, {
-        apiName
-      })}"${maybeStripNamespace(object, apiName)}"`, `$PropertyDef<"${propertyDefinition.type}", "${propertyDefinition.nullable ? "nullable" : "non-nullable"}", "${propertyDefinition.multiplicity ? "array" : "single"}">`]
-    })}
-      }`
-  })}
-}
-  `;
-}
-function createLinks(ontology, object, identifier) {
-  const definition = object.getCleanedUpDefinition(true);
-  return `
-    ${Object.keys(definition.links).length === 0 ? `export type ${identifier} = {};` : `
-        export interface ${identifier}  {
-${stringify(definition.links, {
-    "*": (definition2, _, key) => {
-      const linkTarget = ontology.requireObjectType(definition2.targetType).getImportedDefinitionIdentifier(true);
-      return [`readonly ${key}`, `${definition2.multiplicity ? `${linkTarget}.ObjectSet` : `$SingleLinkAccessor<${linkTarget}>`}
-          `];
-    }
-  })}
-    }
-    `}`;
-}
-function createPropertyKeys(type) {
-  return `export type PropertyKeys = ${Object.keys(type.getCleanedUpDefinition(true).properties).map((a) => maybeStripNamespace(type, a)).map((a) => `"${a}"`).join("|")};`;
-}
-
-// src/v2.0/generatePerActionDataFiles.ts
-async function generatePerActionDataFiles({
-  sanitizedOntology: ontology,
-  fs: fs2,
-  outDir: rootOutDir,
-  importExt = "",
-  ontology: enhancedOntology
-}) {
-  const outDir = path5__default.join(rootOutDir, "ontology", "actions");
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await Promise.all(Object.values(enhancedOntology.actionTypes).map(async (action) => {
-    const currentFilePath = `${path5__default.join("ontology", "actions", `${action.shortApiName}.ts`)}`;
-    const uniqueApiNamesArray = extractReferencedObjectsFromAction(action.raw);
-    const uniqueApiNames = new Set(uniqueApiNamesArray);
-    const uniqueApiNamesString = stringUnionFrom([...uniqueApiNames]);
-    const fullActionDef = deleteUndefineds(wireActionTypeV2ToSdkActionDefinition(action.raw));
-    function createParamsDef() {
-      const entries = Object.entries(fullActionDef.parameters ?? {});
-      entries.sort((a, b) => a[0].localeCompare(b[0]));
-      if (entries.length === 0) {
-        return `// Represents the definition of the parameters for the action
-          export type ParamsDefinition = Record<string, never>;`;
-      }
-      return `// Represents the definition of the parameters for the action
-        export type ParamsDefinition = {
-          ${entries.map(([key, value]) => {
-        return `"${key}": {
-                ${stringify(value, {
-          description: (value2, d) => value2 ? d(value2) : void 0,
-          // trick to remove undefineds
-          type: (type) => {
-            if (typeof type === "string") {
-              return JSON.stringify(type);
-            } else if (type.type === "object") {
-              const obj = enhancedOntology.requireObjectType(type.object);
-              return `ObjectActionDataType<"${obj.fullApiName}", ${obj.getImportedDefinitionIdentifier(true)}>`;
-            } else if (type.type === "objectSet") {
-              return `ObjectSetActionDataType<"${type.objectSet}", ${getObjectDefIdentifier(type.objectSet, true)}>`;
-            }
-            return void 0;
-          }
-        })}
-            }`;
-      }).join(";\n")}
-        }`;
-    }
-    function getActionParamType(input) {
-      if (typeof input === "string") {
-        return `ActionParam.PrimitiveType<${JSON.stringify(input)}>`;
-      } else if (input.type === "object") {
-        return `ActionParam.ObjectType<${enhancedOntology.requireObjectType(input.object).getImportedDefinitionIdentifier(true)}>`;
-      } else if (input.type === "objectSet") {
-        return `ActionParam.ObjectSetType<${enhancedOntology.requireObjectType(input.objectSet).getImportedDefinitionIdentifier(true)}>`;
-      }
-    }
-    function createV2Types() {
-      `${action.shortApiName}$Params`;
-      let jsDocBlock = ["/**"];
-      if (action.description != null) {
-        jsDocBlock.push(`* ${action.description}`);
-      }
-      return `
-        
-          export namespace ${action.shortApiName}{
-            ${createParamsDef()}
-
-            ${getDescriptionIfPresent(action.description)}
-            export interface Params {
-              ${stringify(fullActionDef.parameters, {
-        "*": (ogValue, _, ogKey) => {
-          const key = `${getDescriptionIfPresent(ogValue.description)}
-                  readonly "${ogKey}"${ogValue.nullable ? "?" : ""}`;
-          const value = ogValue.multiplicity ? `ReadonlyArray<${getActionParamType(ogValue.type)}>` : `${getActionParamType(ogValue.type)}`;
-          jsDocBlock.push(`* @param {${getActionParamType(ogValue.type)}} ${ogValue.nullable ? `[${ogKey}]` : `${ogKey}`} ${ogValue.description ?? ""} `);
-          return [key, value];
-        }
-      })}
-            }
-
-            // Represents a fqn of the action
-            export interface Signatures {
-              ${getDescriptionIfPresent(action.description)}
-              applyAction<P extends ${action.paramsIdentifier}, OP extends ApplyActionOptions>(args: P, options?: OP): Promise<ActionReturnTypeForOptions<OP>>;
-           
-              batchApplyAction<P extends ReadonlyArray<${action.paramsIdentifier}>, OP extends ApplyBatchActionOptions>(args: P, options?: OP): Promise<ActionReturnTypeForOptions<OP>>;
-            }
-  
-          }
-
-          
-          ${jsDocBlock.join("\n")}
-          */
-          export interface ${action.shortApiName} extends MinimalActionDefinition<"${action.shortApiName}", ${uniqueApiNamesString}, ${action.shortApiName}.Signatures> {
-            __DefinitionMetadata?: {
-              ${stringify(fullActionDef, {
-        "parameters": () => action.definitionParamsIdentifier
-      })}
-              
-              signatures: ${action.shortApiName}.Signatures;
-            },
-            ${stringify(fullActionDef, {
-        "description": () => void 0,
-        "displayName": () => void 0,
-        "modifiedEntities": () => void 0,
-        "parameters": () => void 0
-      })}
-            osdkMetadata: typeof $osdkMetadata;
-            }
-          `;
-    }
-    function createV2Object() {
-      return `  export const ${action.shortApiName}: ${action.shortApiName} = 
-        {
-          ${stringify(fullActionDef, {
-        "description": () => void 0,
-        "displayName": () => void 0,
-        "modifiedEntities": () => void 0,
-        "parameters": () => void 0
-      })},
-          osdkMetadata: $osdkMetadata
-        }
-        `;
-    }
-    const referencedObjectDefs = /* @__PURE__ */ new Set();
-    for (const p of Object.values(action.parameters)) {
-      if (p.dataType.type === "object" || p.dataType.type === "objectSet") {
-        if (p.dataType.objectApiName) {
-          referencedObjectDefs.add(enhancedOntology.requireObjectType(p.dataType.objectApiName));
-        }
-        if (p.dataType.objectTypeApiName) {
-          referencedObjectDefs.add(enhancedOntology.requireObjectType(p.dataType.objectTypeApiName));
-        }
-      }
-      if (p.dataType.type === "array" && (p.dataType.subType.type === "object" || p.dataType.subType.type === "objectSet")) {
-        if (p.dataType.subType.objectApiName) {
-          referencedObjectDefs.add(enhancedOntology.requireObjectType(p.dataType.subType.objectApiName));
-        }
-        if (p.dataType.subType.objectTypeApiName) {
-          referencedObjectDefs.add(enhancedOntology.requireObjectType(p.dataType.subType.objectTypeApiName));
-        }
-      }
-    }
-    const imports = getObjectImports(referencedObjectDefs, void 0, currentFilePath, true);
-    await fs2.writeFile(path5__default.join(rootOutDir, currentFilePath), await formatTs(`
-          import type { MinimalActionDefinition, ObjectActionDataType, ObjectSetActionDataType } from "@osdk/api";
-          import type { ActionParam, ActionReturnTypeForOptions, ApplyActionOptions, ApplyBatchActionOptions,  } from '@osdk/client.api';
-          import { $osdkMetadata} from "../../OntologyMetadata${importExt}";
-          ${imports}
-
-        
-          ${createV2Types()}
-
-          ${createV2Object()}
-        `));
-  }));
-  const indexFileRelPath = path5__default.join("ontology", "actions.ts");
-  await fs2.writeFile(path5__default.join(rootOutDir, indexFileRelPath), await formatTs(`
-      ${Object.values(enhancedOntology.actionTypes).map((action) => {
-    const exportConstLine = `export {${action.shortApiName} } from "${action.getImportPathRelTo(indexFileRelPath)}";`;
-    return exportConstLine;
-  }).join("\n")}
-    ${Object.keys(ontology.actionTypes).length === 0 ? "export {};" : ""}
-      `));
-}
-function extractReferencedObjectsFromAction(actionType) {
-  const referencedObjectsInParameters = Object.values(actionType.parameters).flatMap(({
-    dataType
-  }) => {
-    const objectTypeReference = extractReferencedObjectsFromActionParameter(dataType);
-    return objectTypeReference ? [objectTypeReference] : [];
-  });
-  const referenceObjectsInEdits = actionType.operations.flatMap((value) => {
-    switch (value.type) {
-      case "createObject":
-        return [value.objectTypeApiName];
-      case "modifyObject":
-        return [value.objectTypeApiName];
-      case "deleteObject":
-      case "createLink":
-      case "deleteLink":
-      default:
-        return [];
-    }
-  });
-  return [...referenceObjectsInEdits, ...referencedObjectsInParameters];
-}
-function extractReferencedObjectsFromActionParameter(actionParameter) {
-  switch (actionParameter.type) {
-    case "objectSet":
-    case "object":
-      return actionParameter.objectTypeApiName;
-    case "array":
-      return extractReferencedObjectsFromActionParameter(actionParameter.subType);
-    case "string":
-    case "boolean":
-    case "attachment":
-    case "date":
-    case "double":
-    case "integer":
-    case "long":
-    case "timestamp":
-      return void 0;
-  }
-}
-
-// src/shared/getObjectTypesFromQueryDataType.ts
-function getObjectTypesFromQueryDataType(dataType, types) {
-  switch (dataType.type) {
-    case "array":
-    case "set":
-      getObjectTypesFromQueryDataType(dataType.subType, types);
-      return;
-    case "object":
-      types.add(dataType.objectTypeApiName);
-      return;
-    case "objectSet":
-      types.add(dataType.objectTypeApiName);
-      return;
-    case "struct":
-      for (const prop of Object.values(dataType.fields)) {
-        getObjectTypesFromQueryDataType(prop.fieldType, types);
-      }
-      return;
-    case "union":
-      for (const type of dataType.unionTypes) {
-        getObjectTypesFromQueryDataType(type, types);
-      }
-      return;
-    case "attachment":
-    case "boolean":
-    case "date":
-    case "double":
-    case "float":
-    case "integer":
-    case "long":
-    case "null":
-    case "string":
-    case "threeDimensionalAggregation":
-    case "timestamp":
-    case "twoDimensionalAggregation":
-    case "unsupported":
-      return;
-    default:
-      throw new Error(`Cannot find object types from unsupported QueryDataType ${dataType.type}`);
-  }
-}
-
-// src/shared/getObjectTypeApiNamesFromQuery.ts
-function getObjectTypeApiNamesFromQuery(query) {
-  const types = /* @__PURE__ */ new Set();
-  for (const {
-    dataType
-  } of Object.values(query.parameters)) {
-    getObjectTypesFromQueryDataType(dataType, types);
-  }
-  getObjectTypesFromQueryDataType(query.output, types);
-  return Array.from(types);
-}
-
-// src/shared/isNullableQueryDataType.ts
-function isNullableQueryDataType(input) {
-  if (input.type === "null") {
-    return true;
-  }
-  if (input.type === "union") {
-    return input.unionTypes.some((t) => isNullableQueryDataType(t));
-  }
-  return false;
-}
-
-// src/shared/wireQueryDataTypeToQueryDataTypeDefinition.ts
-function wireQueryDataTypeToQueryDataTypeDefinition(input) {
-  switch (input.type) {
-    case "double":
-    case "float":
-    case "integer":
-    case "long":
-    case "attachment":
-    case "boolean":
-    case "date":
-    case "string":
-    case "timestamp":
-      return {
-        type: input.type,
-        nullable: false
-      };
-    case "object":
-      return {
-        type: "object",
-        object: input.objectTypeApiName,
-        nullable: false
-      };
-    case "objectSet":
-      return {
-        type: "objectSet",
-        objectSet: input.objectTypeApiName,
-        nullable: false
-      };
-    case "array":
-      return {
-        ...wireQueryDataTypeToQueryDataTypeDefinition(input.subType),
-        multiplicity: true
-      };
-    case "set":
-      return {
-        type: "set",
-        set: wireQueryDataTypeToQueryDataTypeDefinition(input.subType),
-        nullable: false
-      };
-    case "union":
-      const allowNulls = isNullableQueryDataType(input);
-      if (allowNulls && input.unionTypes.length === 2) {
-        const nonNull = input.unionTypes.find((t) => t.type != null);
-        if (nonNull) {
-          return {
-            ...wireQueryDataTypeToQueryDataTypeDefinition(nonNull),
-            nullable: true
-          };
-        }
-      }
-      return {
-        type: "union",
-        union: input.unionTypes.reduce((acc, t) => {
-          if (t.type === "null") {
-            return acc;
-          }
-          acc.push(wireQueryDataTypeToQueryDataTypeDefinition(t));
-          return acc;
-        }, []),
-        nullable: allowNulls
-      };
-    case "struct":
-      return {
-        type: "struct",
-        struct: Object.fromEntries(input.fields.map((f) => [f.name, wireQueryDataTypeToQueryDataTypeDefinition(f.fieldType)])),
-        nullable: false
-      };
-    case "twoDimensionalAggregation":
-      return {
-        type: "twoDimensionalAggregation",
-        twoDimensionalAggregation: get2DQueryAggregationProps(input),
-        nullable: false
-      };
-    case "threeDimensionalAggregation":
-      return {
-        type: "threeDimensionalAggregation",
-        threeDimensionalAggregation: get3DQueryAggregationProps(input),
-        nullable: false
-      };
-    case "null":
-    case "unsupported":
-      throw new Error(`Accidentally tried to handle QueryDataType.type ${input.type}`);
-    default:
-      throw new Error(`Unsupported QueryDataType.type ${input.type}`);
-  }
-}
-function get2DQueryAggregationProps(input) {
-  if (input.keyType.type === "range") {
-    return {
-      keyType: input.keyType.type,
-      keySubtype: input.keyType.subType.type,
-      valueType: input.valueType.type
-    };
-  } else {
-    if (guardInvalidKeyTypes(input.keyType)) {
-      return {
-        keyType: input.keyType.type,
-        valueType: input.valueType.type
-      };
-    }
-    throw new Error(`Cannot create 2D aggregation with ${input.keyType.type} as its type`);
-  }
-}
-function get3DQueryAggregationProps(input) {
-  if (input.keyType.type === "range") {
-    return {
-      keyType: input.keyType.type,
-      keySubtype: input.keyType.subType.type,
-      valueType: get2DQueryAggregationProps(input.valueType)
-    };
-  } else {
-    if (guardInvalidKeyTypes(input.keyType)) {
-      return {
-        keyType: input.keyType.type,
-        valueType: get2DQueryAggregationProps(input.valueType)
-      };
-    }
-    throw new Error(`Cannot create 3D aggregation with ${input.keyType.type} as its type`);
-  }
-}
-function guardInvalidKeyTypes(key) {
-  return key.type === "string" || key.type === "boolean";
-}
-
-// src/shared/wireQueryTypeV2ToSdkQueryDefinition.ts
-function wireQueryTypeV2ToSdkQueryDefinitionNoParams(input) {
-  return {
-    type: "query",
-    apiName: input.apiName,
-    description: input.description,
-    displayName: input.displayName,
-    version: input.version
-  };
-}
-function wireQueryParameterV2ToQueryParameterDefinition(parameter) {
-  return {
-    description: parameter.description,
-    ...wireQueryDataTypeToQueryDataTypeDefinition(parameter.dataType)
-  };
-}
-
-// src/v2.0/generatePerQueryDataFiles.ts
-async function generatePerQueryDataFilesV2({
-  fs: fs2,
-  outDir: rootOutDir,
-  ontology,
-  importExt = ""
-}, v2) {
-  const relOutDir = path5__default.join(".", "ontology", "queries");
-  const outDir = path5__default.join(rootOutDir, "ontology", "queries");
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await Promise.all(Object.values(ontology.queryTypes).map(async (query) => {
-    await generateV2QueryFile(fs2, outDir, relOutDir, query, importExt, ontology);
-  }));
-  const indexFilePath = `${outDir}.ts`;
-  await fs2.writeFile(indexFilePath, await formatTs(`
-    ${Object.values(ontology.queryTypes).map((query) => `export * from "${query.getImportPathRelTo(relOutDir)}";`).join("\n")}
-      ${Object.keys(ontology.queryTypes).length === 0 ? "export {};" : ""}
-    `));
-}
-async function generateV2QueryFile(fs2, outDir, relOutDir, query, importExt, ontology) {
-  const relFilePath = path5__default.join(relOutDir, `${query.shortApiName}.ts`);
-  const objectTypes = getObjectTypeApiNamesFromQuery(query);
-  const objectTypeObjects = new Set(objectTypes.map((o) => ontology.requireObjectType(o)));
-  const importObjects = getObjectImports(objectTypeObjects, "", relFilePath, true);
-  const baseProps = deleteUndefineds(wireQueryTypeV2ToSdkQueryDefinitionNoParams(query.raw));
-  const outputBase = deleteUndefineds(wireQueryDataTypeToQueryDataTypeDefinition(query.output));
-  const referencedObjectTypes = objectTypes.length > 0 ? objectTypes.map((apiNameObj) => `"${apiNameObj}"`).join("|") : "never";
-  await fs2.writeFile(path5__default.join(outDir, `${query.shortApiName}.ts`), await formatTs(`
-        import type { QueryDefinition , VersionBound} from "@osdk/api";
-        import type { QueryParam, QueryResult } from "@osdk/client.api";
-        import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
-        ${importObjects}
-
-        export namespace ${query.shortApiName} {
-          export interface Signature {
-            ${getDescriptionIfPresent(query.description)}
-            (${Object.keys(query.parameters).length > 0 ? `query: ${query.paramsIdentifier}` : ""}): Promise<${getQueryParamType(ontology, wireQueryParameterV2ToQueryParameterDefinition({
-    dataType: query.output
-  }), "Result")}>
-          }
-
-        ${Object.keys(query.parameters).length > 0 ? `
-            export interface Parameters {
-            ${stringify(query.parameters, {
-    "*": (parameter, formatter, apiName) => {
-      const q = wireQueryParameterV2ToQueryParameterDefinition(parameter);
-      return [`
-                ${queryParamJsDoc(wireQueryParameterV2ToQueryParameterDefinition(parameter), {
-        apiName
-      })}readonly "${apiName}"${q.nullable ? "?" : ""}`, `${getQueryParamType(ontology, q, "Param")}`];
-    }
-  })}
-            }
-    
-            ` : ""}
-
-        export interface Definition extends QueryDefinition<
-          "${query.fullApiName}", 
-          ${referencedObjectTypes},
-          ${query.shortApiName}.Signature
-        >, VersionBound<$ExpectedClientVersion>{
-            ${stringify(baseProps)},
-            parameters: {
-            ${parameterDefsForType(ontology, query)}
-            };
-            output: {
-            ${stringify(outputBase)},
-            ${getLineFor__OsdkTargetType(ontology, query.output)}
-            };
-        }
-
-        }
-
-        /** @deprecated use \`${query.shortApiName}.Signature' instead */
-        export type ${query.shortApiName} = ${query.shortApiName}.Signature;
-
-
-
-
-
-        export const ${query.shortApiName}: ${query.definitionIdentifier} = {
-            ${stringify(baseProps)},
-            parameters: {
-            ${parametersForConst(query)}
-            },
-            output: {
-            ${stringify(outputBase)},
-            }
-        };
-        `));
-}
-function parametersForConst(query) {
-  return stringify(query.parameters, {
-    "*": (parameter, formatter) => formatter(deleteUndefineds(wireQueryParameterV2ToQueryParameterDefinition(parameter)))
-  });
-}
-function parameterDefsForType(ontology, query) {
-  return stringify(query.parameters, {
-    "*": (parameter, valueFormatter, apiName) => [`${queryParamJsDoc(wireQueryParameterV2ToQueryParameterDefinition(parameter), {
-      apiName
-    })} ${apiName}`, ` {
-          ${stringify(deleteUndefineds(wireQueryParameterV2ToQueryParameterDefinition(parameter)))},
-          ${getLineFor__OsdkTargetType(ontology, parameter.dataType)}
-        }`]
-  });
-}
-function getLineFor__OsdkTargetType(ontology, qdt) {
-  if (qdt.type === "object" || qdt.type === "objectSet") {
-    return `__OsdkTargetType?: ${ontology.requireObjectType(qdt.objectTypeApiName).getImportedDefinitionIdentifier(true)}`;
-  }
-  return "";
-}
-function queryParamJsDoc(param, {
-  apiName
-}) {
-  let ret = `/**
-`;
-  if (param.description) {
-    if (param.description) {
-      ret += ` *   description: ${param.description}
-`;
-    }
-  } else {
-    ret += ` * (no ontology metadata)
-`;
-  }
-  ret += ` */
-`;
-  return ret;
-}
-function getQueryParamType(enhancedOntology, input, type) {
-  let inner = `unknown /* ${input.type} */`;
-  switch (input.type) {
-    case "date":
-      inner = `Query${type}.PrimitiveType<${JSON.stringify("datetime")}>`;
-      break;
-    case "attachment":
-    case "boolean":
-    case "double":
-    case "float":
-    case "integer":
-    case "long":
-    case "string":
-    case "struct":
-    case "threeDimensionalAggregation":
-    case "timestamp":
-    case "twoDimensionalAggregation":
-      inner = `Query${type}.PrimitiveType<${JSON.stringify(input.type)}>`;
-      break;
-    case "object":
-      inner = `Query${type}.ObjectType<${enhancedOntology.requireObjectType(input.object).getImportedDefinitionIdentifier(true)}>`;
-      break;
-    case "objectSet":
-      inner = `Query${type}.ObjectSetType<${enhancedOntology.requireObjectType(input.objectSet).getImportedDefinitionIdentifier(true)}>`;
-      break;
-    case "set":
-      inner = `${type === "Param" ? "Readonly" : ""}Set<${getQueryParamType(enhancedOntology, input.set, type)}>`;
-      break;
-    case "union":
-      inner = input.union.map((u) => getQueryParamType(enhancedOntology, u, type)).join(" | ");
-      break;
-  }
-  if (input.multiplicity && type === "Param") {
-    return `ReadonlyArray<${inner}>`;
-  } else if (input.multiplicity) {
-    return `Array<${inner}>`;
-  }
-  return inner;
-}
-function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, ontology, v2 = false) {
-  const definition = deleteUndefineds(__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(interfaceDef.raw, v2));
-  const objectDefIdentifier = interfaceDef.getDefinitionIdentifier(v2);
-  const parents = definition.implements?.map((p) => {
-    !(ontology.interfaceTypes[p] != null) ? process.env.NODE_ENV !== "production" ? invariant(false, `Expected to find a parent interface named ${p} in the ontology and did not.`) : invariant(false) : void 0;
-    const it = deleteUndefineds(__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(ontology.requireInterfaceType(p, true).raw, v2));
-    return it;
-  }) ?? [];
-  const mergedProperties = {
-    ...definition.properties
-  };
-  for (const parent of parents) {
-    for (const apiName of Object.keys(parent.properties)) {
-      if (definition.properties[apiName] != null) {
-        !fastDeepEqual(definition.properties[apiName], parent.properties[apiName]) ? process.env.NODE_ENV !== "production" ? invariant(false, `Interface ${definition.apiName} redefines property '${apiName}' from parent '${parent.apiName}' but the properties do not match`) : invariant(false) : void 0;
-      } else if (mergedProperties[apiName] != null) {
-        !fastDeepEqual(mergedProperties[apiName], parent.properties[apiName]) ? process.env.NODE_ENV !== "production" ? invariant(false, `Some interface defines a conflicting property '${apiName}' that does not match property from parent '${parent.apiName}'`) : invariant(false) : void 0;
-      }
-      mergedProperties[apiName] = parent.properties[apiName];
-    }
-  }
-  definition.properties;
-  definition.properties = mergedProperties;
-  function maybeStripNamespace2(q) {
-    if (interfaceDef.apiNamespace && q.startsWith(`${interfaceDef.apiNamespace}.`)) {
-      return q.slice(interfaceDef.apiNamespace.length + 1);
-    } else {
-      return q;
-    }
-  }
-  const objectSetIdentifier = `${interfaceDef.shortApiName}.ObjectSet`;
-  const propertyKeysIdentifier = `${interfaceDef.shortApiName}.PropertyKeys`;
-  const osdkObjectPropsIdentifier = `${interfaceDef.shortApiName}.Props`;
-  const osdkObjectStrictPropsIdentifier = `${interfaceDef.shortApiName}.StrictProps`;
-  const osdkObjectLinksIdentifier = `OsdkObjectLinks$${objectDefIdentifier}`;
-  const osdkObjectIdentifier = `${interfaceDef.shortApiName}.OsdkObject`;
-  const ids = {
-    objectDefIdentifier: `${interfaceDef.shortApiName}.Definition`,
-    osdkObjectLinksIdentifier,
-    osdkObjectPropsIdentifier,
-    osdkObjectStrictPropsIdentifier,
-    objectSetIdentifier,
-    osdkObjectIdentifier,
-    propertyKeysIdentifier
-  };
-  function getV2Types() {
-    return `    import type {
-    InterfaceDefinition as $InterfaceDefinition,
-    } from "@osdk/api";
-     import type {
-      ObjectSet as $ObjectSet, 
-      Osdk as $Osdk,
-      PropertyValueWireToClient as $PropType,    } from "@osdk/client.api";
-    
-
-
-    
-
-        ${Object.keys(definition.links).length === 0 ? `export type ${osdkObjectLinksIdentifier} = {};` : `
-        export interface ${osdkObjectLinksIdentifier}  {
-${stringify(definition.links, {
-      "*": (definition2) => {
-        const linkTarget = ontology.requireObjectType(definition2.targetType).getImportedDefinitionIdentifier(v2);
-        return `${definition2.multiplicity ? `${linkTarget}["objectSet"]` : `SingleLinkAccessor<${linkTarget}>`}
-          `;
-      }
-    })}
-    }
-    `}
-
-    export namespace ${interfaceDef.shortApiName} {
-
-      ${createPropertyKeys(interfaceDef)}
-
-
-      ${createProps(interfaceDef, "Props", false)}
-      ${createProps(interfaceDef, "StrictProps", true)}
-
-
-      ${createObjectSet(interfaceDef, ids)}
-
-      ${createDefinition(interfaceDef, ontology, "Definition", ids)}
-
-      ${createOsdkObject(interfaceDef, "OsdkObject", ids)}
-      
-    }    
-
-
-
-
-  /** @deprecated use ${interfaceDef.shortApiName}.Definition **/
-  export type ${objectDefIdentifier} = ${interfaceDef.shortApiName}.Definition;
-
-
-
-
-`;
-  }
-  const imports = [];
-  return `${imports.join("\n")}
-    ${v2 ? getV2Types() : ""}
-
-    export const ${interfaceDef.shortApiName}: ${interfaceDef.shortApiName}.Definition = {
-      osdkMetadata: $osdkMetadata,
-      objectSet: undefined as any,
-      props: undefined as any,
-      linksType: undefined as any,
-      strictProps: undefined as any,
-      ${stringify(definition, {
-    osdkMetadata: () => void 0,
-    properties: (properties) => `{
-        ${stringify(properties, {
-      "*": (propertyDefinition, _, key) => [`"${maybeStripNamespace2(key)}"`, _(propertyDefinition)]
-    })}
-      }`
-  })}
-      
-    };`;
-}
-
-// src/v2.0/generateClientSdkVersionTwoPointZero.ts
-async function generateRootIndexTsFile({
-  fs: fs2,
-  outDir,
-  importExt,
-  ontologyApiNamespace
-}) {
-  fs2.writeFile(path5__default.join(outDir, "index.ts"), await formatTs(`export * from "./ontology/actions${importExt}";
-        export * as $Actions from "./ontology/actions${importExt}";
-        export * from "./ontology/interfaces${importExt}";
-        export * as $Interfaces from "./ontology/interfaces${importExt}";
-        export * from "./ontology/objects${importExt}";
-        export * as $Objects from "./ontology/objects${importExt}";
-        export * from "./ontology/queries${importExt}";
-        export * as $Queries from "./ontology/queries${importExt}";
-        ${ontologyApiNamespace == null ? `export { $ontologyRid } from "./OntologyMetadata${importExt}";` : ``}
-    `));
-}
-async function generateEachObjectFile(ctx) {
-  const {
-    fs: fs2,
-    outDir,
-    ontology,
-    importExt
-  } = ctx;
-  await fs2.mkdir(path5__default.join(outDir, "ontology", "objects"), {
-    recursive: true
-  });
-  for (const obj of Object.values(ontology.objectTypes)) {
-    const relPath = path5__default.join(".", "ontology", `objects`, `${obj.shortApiName}.ts`);
-    const outFilePath = path5__default.join(outDir, relPath);
-    await fs2.writeFile(outFilePath, await formatTs(`
-        import type { PropertyDef as $PropertyDef } from "@osdk/api";
-        import { $osdkMetadata } from "../../OntologyMetadata${importExt}";
-        import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
-        ${wireObjectTypeV2ToSdkObjectConstV2(obj.raw, ctx, relPath)}
-      `));
-  }
-}
-async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs2, outDir, packageType = "commonjs", ontologyApiNamespace, apiNamespacePackageMap = /* @__PURE__ */ new Map()) {
-  const importExt = packageType === "module" ? ".js" : "";
-  await verifyOutDir(outDir, fs2);
-  const sanitizedOntology = sanitizeMetadata(ontology);
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  const enhancedOntology = enhanceOntology(sanitizedOntology, ontologyApiNamespace, apiNamespacePackageMap, importExt);
-  const ctx = {
-    sanitizedOntology,
-    ontology: enhancedOntology,
-    importExt,
-    fs: fs2,
-    outDir,
-    ontologyApiNamespace,
-    apiNamespacePackageMap
-  };
-  await generateRootIndexTsFile(ctx);
-  await generateOntologyMetadataFile(ctx, userAgent);
-  await generateEachObjectFile(ctx);
-  await generateOntologyInterfaces(ctx);
-  const actionsDir = path5__default.join(outDir, "ontology", "actions");
-  await fs2.mkdir(actionsDir, {
-    recursive: true
-  });
-  await generatePerActionDataFiles(ctx);
-  await fs2.writeFile(path5__default.join(outDir, "ontology", "objects.ts"), await formatTs(`
-    ${Object.values(enhancedOntology.objectTypes).map((objType) => `export * from "./objects/${objType.shortApiName}${importExt}";`).join("\n")}
-    ${Object.keys(ontology.objectTypes).length === 0 ? "export {};" : ""}
-    `));
-  await generatePerQueryDataFilesV2(ctx);
-}
-async function generateOntologyInterfaces({
-  fs: fs2,
-  outDir,
-  ontology,
-  importExt
-}) {
-  const interfacesDir = path5__default.join(outDir, "ontology", "interfaces");
-  await fs2.mkdir(interfacesDir, {
-    recursive: true
-  });
-  for (const obj of Object.values(ontology.interfaceTypes)) {
-    await fs2.writeFile(path5__default.join(interfacesDir, `${obj.shortApiName}.ts`), await formatTs(`
-        import type { PropertyDef as $PropertyDef } from "@osdk/api";
-        import { $osdkMetadata } from "../../OntologyMetadata${importExt}";
-      ${__UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(obj, ontology, true)}
-    `));
-  }
-  await fs2.writeFile(interfacesDir + ".ts", await formatTs(`
-    ${Object.values(ontology.interfaceTypes).map((interfaceType) => `export * from "./interfaces/${interfaceType.shortApiName}${importExt}";`).join("\n")}
-    ${Object.keys(ontology.interfaceTypes).length === 0 ? "export {}" : ""}
-    `));
-}
-
-// src/generateClientSdkPackage.ts
-async function generateClientSdkPackage(packageName, packageVersion, sdkVersion, baseOutDir, ontology, minimalFs, dependencyVersions, cliVersion, ontologyApiNamespace, apiNamespacePackageMap) {
-  if (!packageName) throw new Error("Package name is required");
-  if (sdkVersion === "1.1") {
-    throw new Error("This generator version does not support generating v1 sdks");
-  }
-  for (const packageType of ["module", "commonjs"]) {
-    const outDir = path5.join(baseOutDir, "dist", packageType);
-    generateClientSdkVersionTwoPointZero(ontology, `typescript-sdk/${packageVersion} osdk-cli/${cliVersion}`, minimalFs, outDir, packageType, ontologyApiNamespace, apiNamespacePackageMap);
-    await fs.promises.mkdir(outDir, {
-      recursive: true
-    });
-    await writeJson(minimalFs, path5.join(outDir, "package.json"), {
-      type: packageType
-    });
-    await writeJson(minimalFs, path5.join(outDir, `tsconfig.json`), {
-      compilerOptions: getTsCompilerOptions(packageType)
-    });
-  }
-  await writeJson(minimalFs, path5.join(baseOutDir, "package.json"), await getPackageJsonContents(packageName, packageVersion, dependencyVersions));
-  await minimalFs.mkdir(path5.join(baseOutDir, "ontology"), {
-    recursive: true
-  });
-  await minimalFs.writeFile(path5.join(baseOutDir, "ontology", "objects.js"), `module.exports = require("../../dist/module/ontology/objects")`);
-  await minimalFs.writeFile(path5.join(baseOutDir, "ontology", "objects.d.ts"), `export * from "../dist/module/ontology/objects"`);
-}
-function getTsCompilerOptions(packageType) {
-  const commonTsconfig = {
-    importHelpers: true,
-    declaration: true,
-    isolatedModules: true,
-    esModuleInterop: true,
-    forceConsistentCasingInFileNames: true,
-    strict: true,
-    skipLibCheck: true
-  };
-  const compilerOptions = packageType === "commonjs" ? {
-    ...commonTsconfig,
-    module: "commonjs",
-    target: "es2018"
-  } : {
-    ...commonTsconfig,
-    module: "NodeNext",
-    target: "ES2020"
-  };
-  return compilerOptions;
-}
-function getExpectedDependencies({
-  osdkApiVersion,
-  osdkClientVersion,
-  osdkClientApiVersion
-}) {
-  return {
-    devDependencies: {
-      "@osdk/api": osdkApiVersion,
-      "@osdk/client.api": osdkClientApiVersion
-    },
-    peerDependencies: {
-      "@osdk/api": osdkApiVersion,
-      "@osdk/client.api": osdkClientApiVersion,
-      "@osdk/client": osdkClientVersion
-    }
-  };
-}
-function getExpectedDependenciesFull(dependencyVersions) {
-  const {
-    typescriptVersion,
-    tslibVersion,
-    areTheTypesWrongVersion
-  } = dependencyVersions;
-  const base = getExpectedDependencies(dependencyVersions);
-  return {
-    devDependencies: {
-      ...base.devDependencies,
-      "typescript": typescriptVersion,
-      "tslib": tslibVersion,
-      "@arethetypeswrong/cli": areTheTypesWrongVersion
-    },
-    peerDependencies: {
-      ...base.peerDependencies
-    }
-  };
-}
-function getPackageJsonContents(name, version, dependencyVersions) {
-  const esmPrefix = "./dist/module";
-  const commonjsPrefix = "./dist/commonjs";
-  return {
-    name,
-    version,
-    main: `${commonjsPrefix}/index.js`,
-    module: `${esmPrefix}/index.js`,
-    exports: {
-      ".": {
-        import: `${esmPrefix}/index.js`,
-        require: `${commonjsPrefix}/index.js`
-      }
-    },
-    scripts: {
-      prepack: `tsc -p ${esmPrefix}/tsconfig.json && tsc -p ${commonjsPrefix}/tsconfig.json`,
-      check: "npm exec attw $(npm pack)"
-    },
-    ...getExpectedDependenciesFull(dependencyVersions),
-    files: ["**/*.js", "**/*.d.ts", "dist/**/package.json"]
-  };
-}
-async function writeJson(minimalFs, filePath, body) {
-  return await minimalFs.writeFile(filePath, JSON.stringify(body, void 0, 2) + "\n");
-}
-
-export { generateClientSdkPackage as __UNSTABLE_generateClientSdkPackage, generateClientSdkVersionTwoPointZero, getExpectedDependencies };
-//# 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 { generateClientSdkPackage as __UNSTABLE_generateClientSdkPackage, getExpectedDependencies } from "./generateClientSdkPackage.js";
+export { generateClientSdkVersionTwoPointZero } from "./v2.0/generateClientSdkVersionTwoPointZero.js";
 //# sourceMappingURL=index.js.map