@osdk/generator 2.1.0-beta.3 → 2.1.0-beta.30

package/build/cjs/index.cjs

@@ -0,0 +1,1384 @@
+'use strict';
+
+var fs = require('fs');
+var path8 = require('path');
+var generatorConverters = require('@osdk/generator-converters');
+var prettier = require('prettier');
+var fastDeepEqual = require('fast-deep-equal');
+var invariant = require('tiny-invariant');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path8__namespace = /*#__PURE__*/_interopNamespace(path8);
+var fastDeepEqual__default = /*#__PURE__*/_interopDefault(fastDeepEqual);
+var invariant__default = /*#__PURE__*/_interopDefault(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, isLocal = true) {
+    this._common = common;
+    this.fullApiName = fullApiName;
+    [this.apiNamespace, this.shortApiName] = extractNamespace(this.fullApiName);
+    const {
+      importExt
+    } = common;
+    this.importPath = isLocal ? `${basePath}/${this.shortApiName}${importExt}` : basePath;
+    this.uniqueImportName = this.shortApiName;
+  }
+  getImportPathRelTo = (filePath) => {
+    if (this.importPath.startsWith(".")) {
+      const result = path8__namespace.relative(path8__namespace.dirname(filePath), this.importPath).split(path8__namespace.sep).join("/");
+      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;
+  }
+};
+function extractNamespace(fqApiName) {
+  const last = fqApiName.lastIndexOf(".");
+  if (last === -1) return [undefined, 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 !== undefined));
+}
+
+// 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(generatorConverters.__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(generatorConverters.wireObjectTypeFullMetadataToSdkObjectMetadata(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}`;
+  }
+  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, apiNamespace, shortApiName, destinationPackage) {
+    super(_common, apiNamespace ? `${apiNamespace}.${shortApiName}` : shortApiName, destinationPackage, false);
+    this._common = _common;
+  }
+  getImportedDefinitionIdentifier(v2) {
+    return `$Imported$${this.apiNamespace?.replace(/\./g, "$")}$${this.shortApiName}`;
+  }
+  getDefinitionIdentifier(v2) {
+    return this.uniqueImportName;
+  }
+};
+
+// src/GenerateContext/EnhancedOntologyDefinition.ts
+var EnhancedOntologyDefinition = class {
+  #foreignTypes = {};
+  constructor(raw, importExt, externalObjects, externalInterfaces, externalSpts) {
+    this.common = {
+      enhancedOntology: this,
+      importExt
+    };
+    this.raw = raw;
+    this.ontology = raw.ontology;
+    this.objectTypes = remap(raw.objectTypes, this.common, EnhancedObjectType, externalObjects);
+    this.actionTypes = remap(raw.actionTypes, this.common, EnhancedAction);
+    this.queryTypes = remap(raw.queryTypes, this.common, EnhancedQuery);
+    this.interfaceTypes = remap(raw.interfaceTypes, this.common, EnhancedInterfaceType, externalInterfaces);
+    this.sharedPropertyTypes = remap(raw.sharedPropertyTypes, this.common, EnhancedSharedPropertyType, externalSpts);
+  }
+  #createRequireType = (type) => {
+    return (fullApiName, localOnly) => {
+      const ret = this[type][fullApiName];
+      if (!ret) {
+        extractNamespace(fullApiName);
+        throw new Error(`Unable to find ${type}: No entry for '${fullApiName}`);
+      }
+      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, externalMap) {
+  const entries = [];
+  for (const [fullApiName, v] of Object.entries(r ?? {})) {
+    if (externalMap?.has(fullApiName)) ; else {
+      entries.push([fullApiName, new Constructor(common, v)]);
+    }
+  }
+  if (externalMap) {
+    for (const [fullApiName, destPackage] of externalMap) {
+      const [apiNamespace, shortApiName] = extractNamespace(fullApiName);
+      entries.push([fullApiName, new ForeignType(common, apiNamespace, shortApiName, destPackage)]);
+    }
+  }
+  return Object.fromEntries(entries.sort((a, b) => a[0].localeCompare(b[0])));
+}
+
+// src/GenerateContext/enhanceOntology.ts
+function enhanceOntology({
+  sanitized,
+  importExt,
+  externalObjects,
+  externalInterfaces,
+  externalSpts
+}) {
+  return new EnhancedOntologyDefinition(sanitized, importExt, externalObjects, externalInterfaces, externalSpts);
+}
+
+// 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());
+}
+
+// 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;
+    }
+  }
+}
+function formatTs(contents) {
+  try {
+    return prettier.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/v2.0/generateMetadata.ts
+var ExpectedOsdkVersion = "2.1.0";
+async function generateOntologyMetadataFile({
+  fs: fs2,
+  outDir,
+  ontology,
+  ontologyApiNamespace
+}, userAgent) {
+  await fs2.writeFile(path8__namespace.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/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/v2.0/generatePerActionDataFiles.ts
+async function generatePerActionDataFiles({
+  sanitizedOntology: ontology,
+  fs: fs2,
+  outDir: rootOutDir,
+  importExt = "",
+  ontology: enhancedOntology,
+  forInternalUse = false
+}) {
+  const outDir = path8__namespace.default.join(rootOutDir, "ontology", "actions");
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await Promise.all(Object.values(enhancedOntology.actionTypes).map(async (action) => {
+    const currentFilePath = path8__namespace.default.join("ontology", "actions", `${action.shortApiName}.ts`);
+    const uniqueApiNamesArray = extractReferencedObjectsFromAction(action.raw);
+    const uniqueApiNames = new Set(uniqueApiNamesArray);
+    stringUnionFrom([...uniqueApiNames]);
+    const fullActionDef = deleteUndefineds(generatorConverters.wireActionTypeV2ToSdkActionMetadata(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) : undefined,
+          // 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 `ActionMetadata.DataType.Object<${obj.getImportedDefinitionIdentifier(true)}>`;
+            } else if (type.type === "objectSet") {
+              const obj = enhancedOntology.requireObjectType(type.objectSet);
+              return `ActionMetadata.DataType.ObjectSet<${obj.getImportedDefinitionIdentifier(true)}>`;
+            } else if (type.type === "interface") {
+              const obj = enhancedOntology.requireInterfaceType(type.interface);
+              return `ActionMetadata.DataType.Interface<${obj.getImportedDefinitionIdentifier(true)}>`;
+            } else if (type.type === "struct") {
+              return `ActionMetadata.DataType.Struct<${JSON.stringify(type.struct)}>`;
+            }
+            return undefined;
+          }
+        })}
+            }`;
+      }).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)}>`;
+      } else if (input.type === "interface") {
+        return `ActionParam.InterfaceType<${enhancedOntology.requireInterfaceType(input.interface).getImportedDefinitionIdentifier(true)}>`;
+      } else if (input.type === "struct") {
+        return `ActionParam.StructType<${JSON.stringify(input.struct)}>`;
+      }
+    }
+    function createV2Types() {
+      `${action.shortApiName}$Params`;
+      const 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 ActionDefinition<${action.shortApiName}.Signatures> {
+            __DefinitionMetadata?: {
+              ${stringify(fullActionDef, {
+        "parameters": () => action.definitionParamsIdentifier
+      })}
+              
+              signatures: ${action.shortApiName}.Signatures;
+            },
+            ${stringify(fullActionDef, {
+        "description": () => undefined,
+        "displayName": () => undefined,
+        "modifiedEntities": () => undefined,
+        "parameters": () => undefined,
+        "rid": () => undefined,
+        "status": () => undefined
+      })}
+            osdkMetadata: typeof $osdkMetadata;
+            }
+          `;
+    }
+    function createV2Object() {
+      return `  export const ${action.shortApiName}: ${action.shortApiName} = 
+        {
+          ${stringify(fullActionDef, {
+        "description": () => undefined,
+        "displayName": () => undefined,
+        "modifiedEntities": () => undefined,
+        "parameters": () => undefined,
+        "rid": () => undefined,
+        "status": () => undefined
+      })},
+          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 === "interfaceObject") {
+        if (p.dataType.interfaceTypeApiName) {
+          referencedObjectDefs.add(enhancedOntology.requireInterfaceType(p.dataType.interfaceTypeApiName));
+        }
+      }
+      if (p.dataType.type === "array") {
+        if (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));
+          }
+        }
+        if (p.dataType.subType.type === "interfaceObject") {
+          if (p.dataType.subType.interfaceTypeApiName) {
+            referencedObjectDefs.add(enhancedOntology.requireInterfaceType(p.dataType.subType.interfaceTypeApiName));
+          }
+        }
+      }
+    }
+    const imports = getObjectImports(referencedObjectDefs, undefined, currentFilePath, true);
+    await fs2.writeFile(path8__namespace.default.join(rootOutDir, currentFilePath), await formatTs(`
+          import type {
+            ActionDefinition,
+            ActionMetadata,
+            ActionParam,
+            ActionReturnTypeForOptions,
+            ApplyActionOptions,
+            ApplyBatchActionOptions,
+          } from "${forInternalUse ? "@osdk/api" : "@osdk/client"}";
+          import { $osdkMetadata} from "../../OntologyMetadata${importExt}";
+          ${imports}
+
+        
+          ${createV2Types()}
+
+          ${createV2Object()}
+        `));
+  }));
+  const indexFileRelPath = path8__namespace.default.join("ontology", "actions.ts");
+  await fs2.writeFile(path8__namespace.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 undefined;
+  }
+}
+
+// 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 wireObjectTypeV2ToSdkObjectConstV2(wireObject, {
+  ontology,
+  forInternalUse
+}, currentFilePath) {
+  const object = ontology.requireObjectType(wireObject.objectType.apiName, true);
+  if (object instanceof ForeignType) {
+    throw new Error("Should not be generating types for an external type");
+  }
+  const uniqueLinkTargetTypes = new Set(wireObject.linkTypes.map((a) => ontology.requireObjectType(a.objectTypeApiName, false)));
+  const definition = deleteUndefineds(generatorConverters.wireObjectTypeFullMetadataToSdkObjectMetadata(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(object2, forInternalUse2 = false) {
+    return `import type {
+      PropertyKeys as $PropertyKeys,  
+      ObjectTypeDefinition as $ObjectTypeDefinition,
+      ObjectMetadata as $ObjectMetadata,
+    } from "${forInternalUse2 ? "@osdk/api" : "@osdk/client"}";
+     import type {
+      ObjectSet as $ObjectSet, 
+      Osdk as $Osdk,
+      OsdkObject as $OsdkObject,
+      PropertyValueWireToClient as $PropType,
+      SingleLinkAccessor  as $SingleLinkAccessor,
+    } from "${forInternalUse2 ? "@osdk/api" : "@osdk/client"}";
+
+
+    export namespace ${object2.shortApiName} {
+
+      ${createPropertyKeys(object2)}
+
+
+      ${createLinks(ontology, object2, "Links")}
+
+      ${createProps(object2, "Props", false)}
+      ${createProps(object2, "StrictProps", true)}
+
+      ${createObjectSet(object2, identifiers)}
+      
+      ${createOsdkObject(object2, "OsdkInstance", identifiers)}
+    }    
+
+
+
+    ${createDefinition(object2, ontology, object2.shortApiName, identifiers)}
+    `;
+  }
+  const imports = getObjectImports(uniqueLinkTargetTypes, definition.apiName, currentFilePath, true);
+  return `${imports}${getV2Types(object, forInternalUse)}
+
+    export const ${object.shortApiName}: ${objectDefIdentifier}
+    = {
+      type: "${object instanceof EnhancedObjectType ? "object" : "interface"}",
+      apiName: "${object.fullApiName}",
+      osdkMetadata: $osdkMetadata,  
+    };`;
+}
+function createOsdkObject(object, identifier, {
+  osdkObjectPropsIdentifier,
+  objectDefIdentifier,
+  osdkObjectStrictPropsIdentifier,
+  osdkObjectLinksIdentifier
+}) {
+  object.getCleanedUpDefinition(true);
+  return `
+    export type ${identifier}<
+      OPTIONS extends never | "$rid" = never,
+      K extends keyof ${osdkObjectPropsIdentifier}= keyof ${osdkObjectPropsIdentifier},
+    > 
+    = $Osdk.Instance<
+        ${objectDefIdentifier}, 
+        OPTIONS,
+        K
+      >;
+   
+
+    /** @deprecated use ${identifier} */
+    export type OsdkObject<
+      OPTIONS extends never | "$rid" = never,
+      K extends keyof ${osdkObjectPropsIdentifier}= keyof ${osdkObjectPropsIdentifier},
+    > = ${identifier}<OPTIONS, K>;
+  ;
+    `;
+}
+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) {
+  if (identifier === "StrictProps") {
+    return `export type StrictProps = Props`;
+  }
+  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 ? "?" : ""
+      ""}`, (typeof propertyDefinition.type === "object" ? `${remapStructType(propertyDefinition.type)}` : `$PropType[${JSON.stringify(propertyDefinition.type)}]`) + `${propertyDefinition.multiplicity ? "[]" : ""}${propertyDefinition.nullable || !strict && !(definition.type === "object" && definition.primaryKeyApiName === apiName) ? `| 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`} {
+      osdkMetadata: typeof $osdkMetadata;
+      type: "${object instanceof EnhancedObjectType ? "object" : "interface"}";
+      apiName: "${object.fullApiName}";
+      __DefinitionMetadata?: {
+      objectSet: ${objectSetIdentifier};
+      props: ${osdkObjectPropsIdentifier};
+      linksType: ${osdkObjectLinksIdentifier};
+      strictProps: ${osdkObjectStrictPropsIdentifier};
+      ${stringify(definition, {
+    links: (_value) => `{
+        ${stringify(definition.links, {
+      "*": (definition2) => `$ObjectMetadata.Link<${ontology.requireObjectType(definition2.targetType).getImportedDefinitionIdentifier(true)}, ${definition2.multiplicity}>`
+    })}
+      }`,
+    properties: (_value) => `{
+        ${stringify(definition.properties, {
+      "*": (propertyDefinition, _, apiName) => [`${propertyJsdoc(propertyDefinition, {
+        apiName
+      })}"${maybeStripNamespace(object, apiName)}"`, `$PropertyDef<${JSON.stringify(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) {
+  const properties = Object.keys(type.getCleanedUpDefinition(true).properties);
+  return `export type PropertyKeys = ${properties.length === 0 ? "never" : properties.map((a) => maybeStripNamespace(type, a)).map((a) => `"${a}"`).join("|")};`;
+}
+function remapStructType(structType) {
+  let output = `{`;
+  Object.entries(structType).map(([key, value]) => output += `${key}:$PropType[${JSON.stringify(value)}]|undefined;`);
+  output += "}";
+  return output;
+}
+
+// src/v2.0/UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst.ts
+function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, ontology, v2 = false, forInternalUse = false) {
+  const definition = deleteUndefineds(generatorConverters.__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(interfaceDef.raw, v2));
+  const objectDefIdentifier = interfaceDef.getDefinitionIdentifier(v2);
+  const parents = definition.implements?.map((p) => {
+    const parent = ontology.requireInterfaceType(p, true);
+    if (parent instanceof EnhancedInterfaceType) {
+      const it = deleteUndefineds(generatorConverters.__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(parent.raw, v2));
+      return it;
+    }
+  }) ?? [];
+  const mergedProperties = {
+    ...definition.properties
+  };
+  for (const parent of parents) {
+    if (parent == null) {
+      continue;
+    }
+    for (const apiName of Object.keys(parent.properties)) {
+      if (definition.properties[apiName] != null) {
+        !fastDeepEqual__default.default(definition.properties[apiName], parent.properties[apiName]) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Interface ${definition.apiName} redefines property '${apiName}' from parent '${parent.apiName}' but the properties do not match`) : invariant__default.default(false) : undefined;
+      } else if (mergedProperties[apiName] != null) {
+        !fastDeepEqual__default.default(mergedProperties[apiName], parent.properties[apiName]) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Some interface defines a conflicting property '${apiName}' that does not match property from parent '${parent.apiName}'`) : invariant__default.default(false) : undefined;
+      }
+      mergedProperties[apiName] = parent.properties[apiName];
+    }
+  }
+  definition.properties = mergedProperties;
+  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,
+    osdkObjectLinksIdentifier,
+    osdkObjectPropsIdentifier,
+    osdkObjectStrictPropsIdentifier,
+    objectSetIdentifier,
+    osdkObjectIdentifier,
+    propertyKeysIdentifier
+  };
+  if (interfaceDef.apiNamespace) {
+    const badProperties = Object.keys(definition.properties).filter((apiName) => extractNamespace(apiName)[0] == null);
+    if (badProperties.length > 0) {
+      throw new Error(`Interfaces with fully qualified api names MUST NOT have any properties with an unqualified api name. Interface: ${interfaceDef.fullApiName}, properties: ${badProperties.join(", ")}`);
+    }
+  }
+  function getV2Types(forInternalUse2 = false) {
+    return `import type {
+      InterfaceDefinition as $InterfaceDefinition,
+      ObjectSet as $ObjectSet, 
+      Osdk as $Osdk,
+      PropertyValueWireToClient as $PropType,
+    } from "${forInternalUse2 ? "@osdk/api" : "@osdk/client"}";
+    
+        ${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)}
+
+      ${createOsdkObject(interfaceDef, "OsdkInstance", ids)}
+      
+    }    
+
+    ${createDefinition(interfaceDef, ontology, interfaceDef.shortApiName, ids)}
+
+`;
+  }
+  const imports = [];
+  return `${imports.join("\n")}
+    ${v2 ? getV2Types(forInternalUse) : ""}
+
+    export const ${interfaceDef.shortApiName}: ${interfaceDef.shortApiName} = {
+      type: "interface",
+      apiName: "${interfaceDef.fullApiName}",
+      osdkMetadata: $osdkMetadata,
+       };`;
+}
+
+// src/v2.0/generatePerInterfaceDataFiles.ts
+async function generatePerInterfaceDataFiles({
+  fs: fs2,
+  outDir,
+  ontology,
+  importExt,
+  forInternalUse
+}) {
+  const interfacesDir = path8__namespace.default.join(outDir, "ontology", "interfaces");
+  await fs2.mkdir(interfacesDir, {
+    recursive: true
+  });
+  for (const obj of Object.values(ontology.interfaceTypes)) {
+    if (obj instanceof ForeignType) continue;
+    await fs2.writeFile(path8__namespace.default.join(interfacesDir, `${obj.shortApiName}.ts`), await formatTs(`
+        import type { PropertyDef as $PropertyDef } from "${forInternalUse ? "@osdk/api" : "@osdk/client"}";
+        import { $osdkMetadata } from "../../OntologyMetadata${importExt}";
+      ${__UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(obj, ontology, true, forInternalUse)}
+    `));
+  }
+  await fs2.writeFile(interfacesDir + ".ts", await formatTs(`
+    ${Object.values(ontology.interfaceTypes).filter((i) => i instanceof EnhancedInterfaceType).map((interfaceType) => `export {${interfaceType.shortApiName}} from "./interfaces/${interfaceType.shortApiName}${importExt}";`).join("\n")}
+    ${Object.keys(ontology.interfaceTypes).length === 0 ? "export {}" : ""}
+    `));
+}
+async function generatePerObjectDataFiles(ctx) {
+  const {
+    fs: fs2,
+    outDir,
+    ontology,
+    importExt
+  } = ctx;
+  await fs2.mkdir(path8__namespace.default.join(outDir, "ontology", "objects"), {
+    recursive: true
+  });
+  for (const obj of Object.values(ontology.objectTypes)) {
+    if (obj instanceof ForeignType) continue;
+    const relPath = path8__namespace.default.join(".", "ontology", `objects`, `${obj.shortApiName}.ts`);
+    const outFilePath = path8__namespace.default.join(outDir, relPath);
+    await fs2.writeFile(outFilePath, await formatTs(`
+        import type { PropertyDef as $PropertyDef } from "${ctx.forInternalUse ? "@osdk/api" : "@osdk/client"}";
+        import { $osdkMetadata } from "../../OntologyMetadata${importExt}";
+        import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
+        ${wireObjectTypeV2ToSdkObjectConstV2(obj.raw, ctx, relPath)}
+      `));
+  }
+  await fs2.writeFile(path8__namespace.default.join(outDir, "ontology", "objects.ts"), await formatTs(`
+    ${Object.values(ctx.ontology.objectTypes).filter((o) => o instanceof EnhancedObjectType).map((objType) => `export {${objType.shortApiName}} from "./objects/${objType.shortApiName}${importExt}";`).join("\n")}
+    ${Object.keys(ontology.objectTypes).length === 0 ? "export {};" : ""}
+    `));
+}
+
+// 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/v2.0/generatePerQueryDataFiles.ts
+async function generatePerQueryDataFilesV2({
+  fs: fs2,
+  outDir: rootOutDir,
+  ontology,
+  importExt = "",
+  forInternalUse = false
+}, v2) {
+  const relOutDir = path8__namespace.default.join(".", "ontology", "queries");
+  const outDir = path8__namespace.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, forInternalUse);
+  }));
+  const indexFilePath = `${outDir}.ts`;
+  await fs2.writeFile(indexFilePath, await formatTs(`
+    ${Object.values(ontology.queryTypes).map((query) => `export {${query.shortApiName}} from "${query.getImportPathRelTo(relOutDir)}";`).join("\n")}
+      ${Object.keys(ontology.queryTypes).length === 0 ? "export {};" : ""}
+    `));
+}
+async function generateV2QueryFile(fs2, outDir, relOutDir, query, importExt, ontology, forInternalUse) {
+  const relFilePath = path8__namespace.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(generatorConverters.wireQueryTypeV2ToSdkQueryDefinitionNoParams(query.raw));
+  const outputBase = deleteUndefineds(generatorConverters.wireQueryDataTypeToQueryDataTypeDefinition(query.output));
+  objectTypes.length > 0 ? objectTypes.map((apiNameObj) => `"${apiNameObj}"`).join("|") : "never";
+  await fs2.writeFile(path8__namespace.default.join(outDir, `${query.shortApiName}.ts`), await formatTs(`
+        import type { QueryDefinition , QueryParam, QueryResult, VersionBound} from "${forInternalUse ? "@osdk/api" : "@osdk/client"}";
+        import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
+        import { $osdkMetadata} from "../../OntologyMetadata${importExt}";
+        ${importObjects}
+
+        export namespace ${query.shortApiName} {
+          export interface Signature {
+            ${getDescriptionIfPresent(query.description)}
+            (${Object.keys(query.parameters).length > 0 ? `query: ${query.paramsIdentifier}` : ""}): Promise<${query.shortApiName}.ReturnType>
+          }
+
+        ${Object.keys(query.parameters).length > 0 ? `
+            export interface Parameters {
+            ${stringify(query.parameters, {
+    "*": (parameter, formatter, apiName) => {
+      const q = generatorConverters.wireQueryParameterV2ToQueryParameterDefinition(parameter);
+      return [`
+                ${queryParamJsDoc(generatorConverters.wireQueryParameterV2ToQueryParameterDefinition(parameter), {
+        apiName
+      })}readonly "${apiName}"${q.nullable ? "?" : ""}`, `${getQueryParamType(ontology, q, "Param")}`];
+    }
+  })}
+            }` : ""}
+
+            ${query.output.type === "struct" ? `
+            export interface ReturnType 
+            ${getQueryParamType(ontology, generatorConverters.wireQueryParameterV2ToQueryParameterDefinition({
+    dataType: query.output
+  }), "Result")}
+        ` : `
+        export type ReturnType = ${getQueryParamType(ontology, generatorConverters.wireQueryParameterV2ToQueryParameterDefinition({
+    dataType: query.output
+  }), "Result")}
+          `}
+      }
+    
+            
+        export interface ${query.shortApiName} extends QueryDefinition<
+          ${query.shortApiName}.Signature
+        >, VersionBound<$ExpectedClientVersion>{
+         __DefinitionMetadata?: {
+             ${stringify(baseProps)}
+            parameters: {
+            ${parameterDefsForType(ontology, query)}
+            };
+            output: {
+            ${stringify(outputBase)},
+            ${getLineFor__OsdkTargetType(ontology, query.output)}
+            };
+            signature: ${query.shortApiName}.Signature;
+        }, 
+        ${stringify(baseProps, {
+    "description": () => undefined,
+    "displayName": () => undefined,
+    "rid": () => undefined
+  })}, 
+          osdkMetadata: typeof $osdkMetadata;
+              }
+
+
+        export const ${query.shortApiName}: ${query.definitionIdentifier} = {
+            ${stringify(baseProps, {
+    "description": () => undefined,
+    "displayName": () => undefined,
+    "rid": () => undefined
+  })},
+    osdkMetadata: $osdkMetadata
+        };
+        `));
+}
+function parameterDefsForType(ontology, query) {
+  return stringify(query.parameters, {
+    "*": (parameter, valueFormatter, apiName) => [`${queryParamJsDoc(generatorConverters.wireQueryParameterV2ToQueryParameterDefinition(parameter), {
+      apiName
+    })} ${apiName}`, ` {
+          ${stringify(deleteUndefineds(generatorConverters.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 "threeDimensionalAggregation":
+    case "timestamp":
+    case "twoDimensionalAggregation":
+      inner = `Query${type}.PrimitiveType<${JSON.stringify(input.type)}>`;
+      break;
+    case "struct":
+      inner = `{
+            ${stringify(input.struct, {
+        "*": (p, formatter, apiName) => {
+          return [`
+                ${type === "Param" ? "readonly " : ""}"${apiName}"${p.nullable ? "?" : ""}`, `${getQueryParamType(enhancedOntology, p, 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;
+}
+async function generateRootIndexTsFile({
+  fs: fs2,
+  outDir,
+  importExt,
+  ontologyApiNamespace,
+  ontology
+}) {
+  await fs2.writeFile(path8__namespace.default.join(outDir, "index.ts"), await formatTs(`export {${helper(ontology.actionTypes)}} from "./ontology/actions${importExt}";
+        export * as $Actions from "./ontology/actions${importExt}";
+        export {${helper(ontology.interfaceTypes)}} from "./ontology/interfaces${importExt}";
+        export * as $Interfaces from "./ontology/interfaces${importExt}";
+        export {${helper(ontology.objectTypes)}} from "./ontology/objects${importExt}";
+        export * as $Objects from "./ontology/objects${importExt}";
+        export {${helper(ontology.queryTypes)}} from "./ontology/queries${importExt}";
+        export * as $Queries from "./ontology/queries${importExt}";
+        export { $osdkMetadata } from "./OntologyMetadata${importExt}";
+        ${ontologyApiNamespace == null ? `export { $ontologyRid } from "./OntologyMetadata${importExt}";` : ``}
+    `));
+}
+function helper(x) {
+  return Object.values(x).filter((x2) => !(x2 instanceof ForeignType)).map((a) => a.shortApiName).join(", ");
+}
+
+// src/v2.0/generateClientSdkVersionTwoPointZero.ts
+async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs2, outDir, packageType = "commonjs", externalObjects = /* @__PURE__ */ new Map(), externalInterfaces = /* @__PURE__ */ new Map(), externalSpts = /* @__PURE__ */ new Map(), forInternalUse = false) {
+  const importExt = ".js";
+  await verifyOutDir(outDir, fs2);
+  const sanitizedOntology = sanitizeMetadata(ontology);
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  const enhancedOntology = enhanceOntology({
+    sanitized: sanitizedOntology,
+    importExt,
+    externalObjects,
+    externalInterfaces,
+    externalSpts
+  });
+  const ctx = {
+    sanitizedOntology,
+    ontology: enhancedOntology,
+    importExt,
+    fs: fs2,
+    outDir,
+    forInternalUse
+  };
+  await generateRootIndexTsFile(ctx);
+  await generateOntologyMetadataFile(ctx, userAgent);
+  await generatePerObjectDataFiles(ctx);
+  await generatePerInterfaceDataFiles(ctx);
+  await generatePerActionDataFiles(ctx);
+  await generatePerQueryDataFilesV2(ctx);
+}
+
+// src/generateClientSdkPackage.ts
+async function generateClientSdkPackage(packageName, packageVersion, sdkVersion, baseOutDir, ontology, minimalFs, dependencyVersions, cliVersion, externalObjects = /* @__PURE__ */ new Map(), externalInterfaces = /* @__PURE__ */ new Map()) {
+  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 = path8__namespace.join(baseOutDir, "dist", packageType);
+    await generateClientSdkVersionTwoPointZero(ontology, `typescript-sdk/${packageVersion} osdk-cli/${cliVersion}`, minimalFs, outDir, packageType, externalObjects, externalInterfaces);
+    await fs__namespace.promises.mkdir(outDir, {
+      recursive: true
+    });
+    await writeJson(minimalFs, path8__namespace.join(outDir, "package.json"), {
+      type: packageType
+    });
+    await writeJson(minimalFs, path8__namespace.join(outDir, `tsconfig.json`), {
+      compilerOptions: getTsCompilerOptions(packageType)
+    });
+  }
+  await writeJson(minimalFs, path8__namespace.join(baseOutDir, "package.json"), getPackageJsonContents(packageName, packageVersion, dependencyVersions));
+  await minimalFs.mkdir(path8__namespace.join(baseOutDir, "ontology"), {
+    recursive: true
+  });
+  await minimalFs.writeFile(path8__namespace.join(baseOutDir, "ontology", "objects.js"), `module.exports = require("../../dist/module/ontology/objects")`);
+  await minimalFs.writeFile(path8__namespace.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
+}) {
+  return {
+    devDependencies: {
+      "@osdk/api": osdkApiVersion
+    },
+    peerDependencies: {
+      "@osdk/api": osdkApiVersion,
+      "@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 void await minimalFs.writeFile(filePath, JSON.stringify(body, undefined, 2) + "\n");
+}
+
+exports.__UNSTABLE_generateClientSdkPackage = generateClientSdkPackage;
+exports.generateClientSdkVersionTwoPointZero = generateClientSdkVersionTwoPointZero;
+exports.getExpectedDependencies = getExpectedDependencies;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map