@osdk/generator 1.13.0-beta.1 → 1.14.0-beta.0

package/build/browser/index.js

@@ -1,136 +1,257 @@
 import * as fs from 'fs';
 import * as path16 from 'path';
 import path16__default, { join } from 'path';
+import { __UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition, wireObjectTypeFullMetadataToSdkObjectTypeDefinition } from '@osdk/generator-converters';
 import { format } from 'prettier';
 import organizeImports from 'prettier-plugin-organize-imports';
-import { wireObjectTypeFullMetadataToSdkObjectTypeDefinition, __UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition } from '@osdk/generator-converters';
 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 = path16.relative(path16.dirname(filePath), this.importPath);
+      if (result.startsWith(".")) {
+        return result;
+      } else {
+        return `./${result}`;
+      }
+    } else {
+      return this.importPath;
+    }
+  };
+};
+var EnhancedBase = class extends AbstractImportable {
+  constructor(common, og, fullApiName, basePath) {
+    super(common, fullApiName, basePath);
+    this.og = og;
+    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, og) {
+    super(common, og, og.apiName, "./ontology/actions");
+    this.og = og;
+  }
+  get description() {
+    return this.og.description;
+  }
+  get parameters() {
+    return this.og.parameters;
+  }
+  get operations() {
+    return this.og.operations;
+  }
+  get paramsIdentifier() {
+    return `${this.shortApiName}.Parameters`;
+  }
+  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/util/stringify.ts
-var defaultCustomizer = (value, defaultValueFormatter, key, defaultKeyFormatter) => {
-  return [defaultKeyFormatter(key), defaultValueFormatter(value)];
+// src/GenerateContext/EnhancedInterfaceType.ts
+var EnhancedInterfaceType = class extends EnhancedBase {
+  constructor(common, og) {
+    super(common, og, og.apiName, "./ontology/interfaces");
+    this.og = og;
+  }
+  getDefinitionIdentifier(v2) {
+    return v2 ? this.shortApiName : `${this.shortApiName}Def`;
+  }
+  getImportedDefinitionIdentifier(v2) {
+    return this.getDefinitionIdentifier(v2);
+  }
+  get properties() {
+    return this.og.properties;
+  }
+  getCleanedUpDefinition(v2) {
+    return deleteUndefineds(__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(this.og, v2));
+  }
 };
-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]}`);
-      }
-    }
+var EnhancedObjectType = class extends EnhancedBase {
+  constructor(common, og) {
+    super(common, og, og.objectType.apiName, "./ontology/objects");
+    this.og = og;
   }
-  return entries.join(separator);
-}
-function formatTs(contents) {
-  return format(contents, {
-    parser: "typescript",
-    singleQuote: true,
-    trailingComma: "all",
-    plugins: [organizeImports],
-    tabWidth: 2,
-    printWidth: 120
-  });
-}
+  getDefinitionIdentifier(v2) {
+    return v2 ? `${this.shortApiName}` : `${this.shortApiName}Def`;
+  }
+  getImportedDefinitionIdentifier(v2) {
+    return this.getDefinitionIdentifier(v2);
+  }
+  getCleanedUpDefinition(v2) {
+    return deleteUndefineds(wireObjectTypeFullMetadataToSdkObjectTypeDefinition(this.og, v2));
+  }
+};
 
-// src/util/reservedKeywords.ts
-var reservedKeywords = /* @__PURE__ */ new Set(["break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do", "else", "enum", "export", "extends", "false", "finally", "for", "function", "if", "import", "in", "instanceof", "new", "null", "return", "super", "switch", "this", "throw", "true", "try", "typeof", "var", "void", "while", "with", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"]);
-function isReservedKeyword(name) {
-  return reservedKeywords.has(name);
-}
+// src/GenerateContext/EnhancedQuery.ts
+var EnhancedQuery = class extends EnhancedBase {
+  constructor(common, og) {
+    super(common, og, og.apiName, "./ontology/queries");
+    this.og = og;
+  }
+  get description() {
+    return this.og.description;
+  }
+  get parameters() {
+    return this.og.parameters;
+  }
+  get output() {
+    return this.og.output;
+  }
+  get paramsIdentifier() {
+    return `${this.shortApiName}.Parameters`;
+  }
+  get definitionIdentifier() {
+    return `${this.shortApiName}.Definition`;
+  }
+  get definitionParamsIdentifier() {
+    return `${this.definitionIdentifier}$Params`;
+  }
+};
 
-// src/v1.1/wireObjectTypeV2ToV1ObjectInterfaceString.ts
-function wireObjectTypeV2ToObjectInterfaceStringV1(objectTypeWithLinks, importExt = "") {
-  const uniqueLinkTargets = new Set(objectTypeWithLinks.linkTypes.map((a) => a.objectTypeApiName).filter((a) => a !== objectTypeWithLinks.objectType.apiName));
-  return `import type { OntologyObject, LocalDate, Timestamp, GeoShape, GeoPoint, Attachment, TimeSeries, MultiLink, SingleLink, StringLong } from "@osdk/legacy-client";
-${Array.from(uniqueLinkTargets).map((linkTarget) => `import type { ${linkTarget} } from "./${linkTarget}${importExt}";`).join("\n")}
+// src/GenerateContext/EnhancedSharedPropertyType.ts
+var EnhancedSharedPropertyType = class extends EnhancedBase {
+  constructor(common, og) {
+    super(common, og, og.apiName, "./ontology/interfaces");
+    this.og = og;
+  }
+};
 
-  ${getDescriptionIfPresent(objectTypeWithLinks.objectType.description)}
-  export interface ${objectTypeWithLinks.objectType.apiName} extends OntologyObject {
-  /** @deprecated please migrate to $apiName instead */
-  readonly __apiName: "${objectTypeWithLinks.objectType.apiName}" & {${objectTypeWithLinks.linkTypes.map((linkType) => {
-    return `/** @deprecated please migrate to pivotTo(${linkType.apiName}) instead */ searchAround${linkType.apiName.charAt(0).toUpperCase() + linkType.apiName.slice(1)}?: never`;
-  })}};
-  /** @deprecated please migrate to $primaryKey instead */
-  readonly __primaryKey: ${wirePropertyTypeV2ToTypeScriptType(objectTypeWithLinks.objectType.properties[objectTypeWithLinks.objectType.primaryKey].dataType)};
-  readonly $apiName: "${objectTypeWithLinks.objectType.apiName}";
-  readonly $primaryKey: ${wirePropertyTypeV2ToTypeScriptType(objectTypeWithLinks.objectType.properties[objectTypeWithLinks.objectType.primaryKey].dataType)};
-${Object.entries(objectTypeWithLinks.objectType.properties).sort((a, b) => a[0].localeCompare(b[0])).flatMap(([propertyName, propertyDefinition]) => {
-    const propertyType = wirePropertyTypeV2ToTypeScriptType(propertyDefinition.dataType);
-    const entries = [`${getDescriptionIfPresent(propertyDefinition.description, true)}readonly ${propertyName}: ${propertyType} | undefined`];
-    if (isReservedKeyword(propertyName)) {
-      entries.push(`/** @deprecated please migrate to '${propertyName}' instead */
-          readonly ${propertyName}_: ${propertyType} | undefined`);
+// 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;
     }
-    return entries;
-  }).join(";\n")}
-${objectTypeWithLinks.linkTypes.flatMap((linkType) => {
-    const entries = [`readonly ${linkType.apiName}: ${linkType.cardinality === "MANY" ? "MultiLink" : "SingleLink"}<${linkType.objectTypeApiName}>`];
-    return entries;
-  }).join(";\n")}
+  }
+};
+
+// src/GenerateContext/EnhancedOntologyDefinition.ts
+var EnhancedOntologyDefinition = class {
+  constructor(original, ontologyApiNamespace, apiNamespacePackageMap, importExt) {
+    this.common = {
+      apiNamespacePackageMap,
+      enhancedOntology: this,
+      importExt,
+      ontologyApiNamespace
+    };
+    this.og = original;
+    this.ontology = original.ontology;
+    this.objectTypes = remap(original.objectTypes, this.common, EnhancedObjectType);
+    this.actionTypes = remap(original.actionTypes, this.common, EnhancedAction);
+    this.queryTypes = remap(original.queryTypes, this.common, EnhancedQuery);
+    this.interfaceTypes = remap(original.interfaceTypes, this.common, EnhancedInterfaceType);
+    this.sharedPropertyTypes = remap(original.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}'`);
+        }
+        return new ForeignType(this.common, type, apiNamespace, shortApiName);
+      }
+      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);
 }
-function wirePropertyTypeV2ToTypeScriptType(property) {
-  switch (property.type) {
-    case "string":
-      return "string";
-    case "boolean":
-      return "boolean";
-    case "array":
-      return wirePropertyTypeV2ToTypeScriptType(property.subType) + "[]";
-    case "integer":
-      return "number";
-    case "attachment":
-      return "Attachment";
-    case "byte":
-      return "number";
-    case "date":
-      return "LocalDate";
-    case "decimal":
-      return "string";
-    case "double":
-      return "number";
-    case "float":
-      return "number";
-    case "geopoint":
-      return "GeoPoint";
-    case "geoshape":
-      return "GeoShape";
-    case "long":
-      return "StringLong";
-    case "short":
-      return "number";
-    case "timestamp":
-      return "Timestamp";
-    case "timeseries":
-      return property.itemType.type === "string" ? `TimeSeries<string>` : `TimeSeries<number>`;
-    case "marking":
-      return "string";
-    default:
-      throw new Error(`Unknown property type ${property}`);
-  }
+
+// 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 getDescriptionIfPresent(description, includeNewline) {
-  if (description) {
-    return `/**
- * ${description}
- */${includeNewline ? "\n" : ""}`;
+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;
+    }
   }
-  return "";
 }
 
 // src/shared/getEditedEntities.ts
@@ -152,350 +273,24 @@ function getModifiedEntityTypes(action) {
     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
-      };
-    }
+function formatTs(contents) {
+  try {
+    return format(contents, {
+      parser: "typescript",
+      singleQuote: true,
+      trailingComma: "all",
+      plugins: [organizeImports],
+      tabWidth: 2,
+      printWidth: 120
+    });
+  } catch (e) {
+    console.error("Failed to format file", e);
+    console.log(contents);
+    return contents;
   }
-  return entities;
 }
 
-// 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/shared/wireObjectTypeV2ToSdkObjectConst.ts
-function getObjectDefIdentifier(name, v2) {
-  return v2 ? name : `${name}Def`;
-}
-function wireObjectTypeV2ToSdkObjectConst(object, importExt, v2 = false) {
-  const uniqueLinkTargetTypes = new Set(object.linkTypes.map((a) => a.objectTypeApiName));
-  const definition = deleteUndefineds(wireObjectTypeFullMetadataToSdkObjectTypeDefinition(object, v2));
-  const objectDefIdentifier = getObjectDefIdentifier(object.objectType.apiName, v2);
-  function getV1Types() {
-    return `
-      export interface ${objectDefIdentifier} extends ObjectTypeDefinition<"${object.objectType.apiName}", ${object.objectType.apiName}> {
-        ${stringify(definition, {
-      osdkMetadata: () => void 0,
-      // not used in v1
-      links: (_value) => `{
-          ${stringify(definition.links, {
-        "*": (definition2) => `ObjectTypeLinkDefinition<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
-      })}
-        }`
-    })}
-      }
-    `;
-  }
-  function getV2Types() {
-    return `
-      export interface ${objectDefIdentifier} extends ObjectTypeDefinition<"${object.objectType.apiName}", ${object.objectType.apiName}>, VersionBound<$ExpectedClientVersion> {
-        osdkMetadata: typeof $osdkMetadata;
-        ${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<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
-      })}
-        }`,
-      properties: (_value) => `{
-          ${stringify(definition.properties, {
-        "*": (propertyDefinition, _, apiName) => [`${propertyJsdoc(propertyDefinition, {
-          apiName
-        })}${apiName}`, `PropertyDef<"${propertyDefinition.type}", "${propertyDefinition.nullable ? "nullable" : "non-nullable"}", "${propertyDefinition.multiplicity ? "array" : "single"}">`]
-      })}
-        }`
-    })}
-    
-      }
-
-    `;
-  }
-  const imports = Array.from(uniqueLinkTargetTypes).filter((type) => type !== definition.apiName).map((type) => `import type { ${getObjectDefIdentifier(type, v2)} } from "./${type}${importExt}";`);
-  return `${imports.join("\n")}
-
-    ${v2 ? getV2Types() : getV1Types()}
-
-    export const ${object.objectType.apiName}: ${objectDefIdentifier} = {
-      ${v2 ? `osdkMetadata: $osdkMetadata,` : ""}
-      ${stringify(definition, {
-    osdkMetadata: (value) => void 0
-  })}
-    
-    };`;
-}
-
-// src/shared/generatePerActionDataFiles.ts
-async function generatePerActionDataFiles(ontology, fs2, outDir, importExt, v2) {
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await Promise.all(Object.values(ontology.actionTypes).map(async (action) => {
-    const uniqueApiNames = new Set(extractReferencedObjectsFromAction(action));
-    const uniqueApiNamesString = uniqueApiNames.size > 0 ? [...uniqueApiNames].map((apiName) => `"${apiName}"`).join("|") : "never";
-    const fullActionDef = deleteUndefineds(wireActionTypeV2ToSdkActionDefinition(action));
-    const {
-      parameters,
-      ...actionDefSansParameters
-    } = fullActionDef;
-    const actionDefIdentifier = `ActionDef$${action.apiName}`;
-    const paramsDefIdentifier = `${actionDefIdentifier}$Params`;
-    const paramsIdentifier = `${action.apiName}$Params`;
-    function createParamsDef() {
-      const entries = Object.entries(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 ${paramsDefIdentifier} = Record<string, never>;`;
-      }
-      return `// Represents the definition of the parameters for the action
-        export type ${paramsDefIdentifier} = {
-          ${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") {
-              return `ObjectActionDataType<"${type.object}", ${getObjectDefIdentifier(type.object, v2)}>`;
-            } else if (type.type === "objectSet") {
-              return `ObjectSetActionDataType<"${type.objectSet}", ${getObjectDefIdentifier(type.objectSet, v2)}>`;
-            }
-            return void 0;
-          }
-        })}
-            }`;
-      }).join(";\n")}
-        }`;
-    }
-    function createV2Types() {
-      return `
-        
-          ${createParamsDef()}
-          
-
-          // Represents the runtime arguments for the action
-          export type ${paramsIdentifier} = NOOP<OsdkActionParameters<${paramsDefIdentifier}>> | NOOP<OsdkActionParameters<${paramsDefIdentifier}>>[];
-
-          
-          // Represents a fqn of the action
-          export interface ${action.apiName} {
-            ${getDescriptionIfPresent(action.description)}
-             <P extends ${paramsIdentifier}, OP extends P extends NOOP<OsdkActionParameters<${paramsDefIdentifier}>>[]? ApplyBatchActionOptions: ApplyActionOptions>(args: P, options?: OP): Promise<ActionReturnTypeForOptions<OP>>;
-          }
-
-          
-          // Represents the definition of the action
-          export interface ${actionDefIdentifier} extends ActionDefinition<"${action.apiName}", ${uniqueApiNamesString}, ${action.apiName}>, VersionBound<$ExpectedClientVersion> {
-          ${Object.entries(actionDefSansParameters).sort((a, b) => a[0].localeCompare(b[0])).map(([key, value]) => {
-        return `${key}: ${JSON.stringify(value)};`;
-      }).join("\n")}
-          parameters: ${paramsDefIdentifier};
-          osdkMetadata: typeof $osdkMetadata;
-        }`;
-    }
-    function createV2Object() {
-      return `  export const ${action.apiName}: ${actionDefIdentifier} = 
-        {
-          ${stringify(fullActionDef)},
-          osdkMetadata: $osdkMetadata
-        }
-        `;
-    }
-    function createV1Object() {
-      return `  export const ${action.apiName} = ${JSON.stringify(fullActionDef, null, 2)} satisfies ActionDefinition<"${action.apiName}", ${uniqueApiNamesString}>;`;
-    }
-    const referencedObjectDefs = /* @__PURE__ */ new Set();
-    for (const p of Object.values(action.parameters)) {
-      if (p.dataType.type === "object" || p.dataType.type === "objectSet") {
-        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.objectApiName, v2));
-        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.objectTypeApiName, v2));
-      }
-      if (p.dataType.type === "array" && (p.dataType.subType.type === "object" || p.dataType.subType.type === "objectSet")) {
-        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.subType.objectApiName, v2));
-        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.subType.objectTypeApiName, v2));
-      }
-    }
-    const importObjects = referencedObjectDefs.size > 0 ? `import type {${[...referencedObjectDefs].join(",")}} from "../objects${importExt}";` : "";
-    await fs2.writeFile(path16__default.join(outDir, `${action.apiName}.ts`), await formatTs(`
-          import type { ActionDefinition, ObjectActionDataType, ObjectSetActionDataType, VersionBound} from "@osdk/api";
-          import type { ActionSignature, ApplyActionOptions, ApplyBatchActionOptions, OsdkActionParameters,ActionReturnTypeForOptions, NOOP } from '@osdk/client.api';
-          import { $osdkMetadata} from "../../OntologyMetadata${importExt}";
-          import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
-          ${importObjects}
-
-        
-          ${v2 ? createV2Types() : ""}
-
-          ${v2 ? createV2Object() : createV1Object()}
-        `));
-  }));
-  await fs2.writeFile(path16__default.join(outDir, `index.ts`), await formatTs(`
-      ${Object.values(ontology.actionTypes).map((action) => `export {${action.apiName}} from "./${action.apiName}${importExt}";`).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":
-        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/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;
-    }
-  }
-}
+// src/v1.1/generateActions.ts
 async function generateActions(ontology, fs2, outDir, importExt = "") {
   const importedObjects = /* @__PURE__ */ new Set();
   let actionSignatures = [];
@@ -1242,455 +1037,1497 @@ async function generateOntologyIndexFile(fs2, outDir) {
         export type { ObjectSet } from "@osdk/legacy-client";
     `));
 }
-async function generatePerObjectInterfaceAndDataFiles(ontology, fs2, outDir, importExt = "") {
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await Promise.all(Object.values(ontology.objectTypes).map(async (object) => {
-    object.linkTypes;
-    await fs2.writeFile(path16__default.join(outDir, `${object.objectType.apiName}.ts`), await formatTs(`
-        import type { ObjectTypeDefinition, ObjectTypeLinkDefinition, PropertyDef } from "@osdk/api";
-        ${wireObjectTypeV2ToObjectInterfaceStringV1(object, importExt)}
-
-        ${wireObjectTypeV2ToSdkObjectConst(object, importExt)}
-        `));
-  }));
-  await fs2.writeFile(path16__default.join(outDir, "index.ts"), await formatTs(`
-    ${Object.keys(ontology.objectTypes).map((apiName) => `export * from "./${apiName}${importExt}";`).join("\n")}
-      export type { ObjectSet } from "@osdk/legacy-client";
 
-    `));
+// src/shared/getObjectImports.ts
+function getObjectImports(objects, curApiName, currentFilePath, v2) {
+  return Array.from(objects).filter((obj) => obj.fullApiName !== curApiName).map((obj) => {
+    return `import type { ${obj.getDefinitionIdentifier(v2)} as ${obj.getImportedDefinitionIdentifier(v2)} } from "${obj.getImportPathRelTo("./" + currentFilePath)}";`;
+  }).join("\n");
 }
 
-// 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/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)
+  };
 }
-
-// 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
-      };
+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: 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
+        objectSet: parameterType.objectTypeApiName
       };
-    case "threeDimensionalAggregation":
+    case "object":
       return {
-        type: "threeDimensionalAggregation",
-        threeDimensionalAggregation: get3DQueryAggregationProps(input),
-        nullable: false
+        type: "object",
+        object: parameterType.objectTypeApiName
       };
-    case "null":
-    case "unsupported":
-      throw new Error(`Accidentally tried to handle QueryDataType.type ${input.type}`);
-    default:
-      throw new Error(`Unsupported QueryDataType.type ${input.type}`);
+    case "array":
+      return actionPropertyToSdkPropertyDefinition(parameterType.subType);
   }
 }
-function get2DQueryAggregationProps(input) {
-  if (input.keyType.type === "range") {
-    return {
-      keyType: input.keyType.type,
-      keySubtype: input.keyType.subType.type,
-      valueType: input.valueType.type
+function createModifiedEntities(addedObjects, modifiedObjects) {
+  let entities = {};
+  for (const key of addedObjects) {
+    entities[key] = {
+      created: true,
+      modified: false
     };
-  } 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)
+  for (const key of modifiedObjects) {
+    if (entities[key]) {
+      entities[key].modified = true;
+    } else {
+      entities[key] = {
+        created: false,
+        modified: true
       };
     }
-    throw new Error(`Cannot create 3D aggregation with ${input.keyType.type} as its type`);
   }
-}
-function guardInvalidKeyTypes(key) {
-  return key.type === "string" || key.type === "boolean";
+  return entities;
 }
 
-// src/shared/wireQueryTypeV2ToSdkQueryDefinition.ts
-function wireQueryTypeV2ToSdkQueryDefinition(input) {
-  return {
-    type: "query",
-    apiName: input.apiName,
-    description: input.description,
-    displayName: input.displayName,
-    version: input.version,
-    parameters: Object.fromEntries(Object.entries(input.parameters).map(([name, parameter]) => [name, wireQueryParameterV2ToQueryParameterDefinition(parameter)])),
-    output: wireQueryDataTypeToQueryDataTypeDefinition(input.output)
-  };
-}
-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/util/stringUnionFrom.ts
+function stringUnionFrom2(values) {
+  if (values.length === 0) {
+    return "never";
+  } else {
+    return values.map((v) => `"${v}"`).join("|");
+  }
 }
 
-// src/v1.1/generatePerQueryDataFiles.ts
-async function generatePerQueryDataFiles(ontology, fs2, outDir, importExt = "", v2 = false) {
+// src/v1.1/generatePerActionDataFilesV1.ts
+async function generatePerActionDataFilesV1({
+  sanitizedOntology: ontology,
+  fs: fs2,
+  outDir: rootOutDir,
+  importExt = "",
+  ontology: enhancedOntology
+}) {
+  const outDir = path16__default.join(rootOutDir, "ontology", "actions");
   await fs2.mkdir(outDir, {
     recursive: true
   });
-  await Promise.all(Object.values(ontology.queryTypes).map(async (query) => {
-    const objectTypes = getObjectTypesFromQuery(query);
-    const importObjects = objectTypes.length > 0 ? `import {${[...objectTypes].join(",")}} from "../objects${importExt}";` : "";
-    if (v2) {
-      await fs2.writeFile(path16__default.join(outDir, `${query.apiName}.ts`), await formatTs(`
-          import { QueryDefinition } from "@osdk/api";
-          ${importObjects}
-          export const ${query.apiName} = {
-            ${stringify(deleteUndefineds(wireQueryTypeV2ToSdkQueryDefinitionNoParams(query)))},
-              parameters: {${Object.entries(query.parameters).map(([name, parameter]) => {
-        return `${name} : {${stringify(deleteUndefineds(wireQueryParameterV2ToQueryParameterDefinition(parameter)))},
-            ${parameter.dataType.type === "object" || parameter.dataType.type === "objectSet" ? getOsdkTargetTypeIfPresent(parameter.dataType.objectTypeApiName, v2) : ``}}`;
-      })}},
-              output: {${stringify(deleteUndefineds(wireQueryDataTypeToQueryDataTypeDefinition(query.output)))},
-            ${query.output.type === "object" || query.output.type === "objectSet" ? getOsdkTargetTypeIfPresent(query.output.objectTypeApiName, v2) : ``}}
-          } ${getQueryDefSatisfies(query.apiName, objectTypes)}`));
-    } else {
-      await fs2.writeFile(path16__default.join(outDir, `${query.apiName}.ts`), await formatTs(`
-            import { QueryDefinition } from "@osdk/api";
-    
-            export const ${query.apiName} = ${JSON.stringify(wireQueryTypeV2ToSdkQueryDefinition(query))} ${getQueryDefSatisfies(query.apiName, objectTypes)}`));
+  await Promise.all(Object.values(enhancedOntology.actionTypes).map(async (action) => {
+    const currentFilePath = `${path16__default.join("ontology", "actions", `${action.shortApiName}.ts`)}`;
+    const uniqueApiNamesArray = extractReferencedObjectsFromAction(action.og);
+    const uniqueApiNames = new Set(uniqueApiNamesArray);
+    const uniqueApiNamesString = stringUnionFrom2([...uniqueApiNames]);
+    const fullActionDef = deleteUndefineds(wireActionTypeV2ToSdkActionDefinition(action.og));
+    function createV1Object() {
+      return `  export const ${action.shortApiName} = ${JSON.stringify(fullActionDef, null, 2)} satisfies ActionDefinition<"${action.shortApiName}", ${uniqueApiNamesString}>;`;
+    }
+    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, false);
+    await fs2.writeFile(path16__default.join(rootOutDir, currentFilePath), await formatTs(`
+          import type { ActionDefinition, ObjectActionDataType, ObjectSetActionDataType, VersionBound} from "@osdk/api";
+          import type { ApplyActionOptions, ApplyBatchActionOptions, ActionReturnTypeForOptions, ActionParam } from '@osdk/client.api';
+          import { $osdkMetadata} from "../../OntologyMetadata${importExt}";
+          import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
+          ${imports}
+
+          ${createV1Object()}
+        `));
   }));
-  await fs2.writeFile(path16__default.join(outDir, "index.ts"), await formatTs(`
-  ${Object.values(ontology.queryTypes).map((query) => `export * from "./${query.apiName}${importExt}";`).join("\n")}
-    ${Object.keys(ontology.queryTypes).length === 0 ? "export {};" : ""}
-  `));
+  const indexFileRelPath = path16__default.join("ontology", "actions", `index.ts`);
+  await fs2.writeFile(path16__default.join(rootOutDir, indexFileRelPath), await formatTs(`
+      ${Object.values(enhancedOntology.actionTypes).map((action) => {
+    const exportConstLine = `export {${action.shortApiName} } from "${action.getImportPathRelTo(indexFileRelPath)}";`;
+    `export type { ${action.paramsIdentifier} } from "${action.getImportPathRelTo(indexFileRelPath)}";`;
+    return exportConstLine;
+  }).join("\n")}
+    ${Object.keys(ontology.actionTypes).length === 0 ? "export {};" : ""}
+      `));
 }
-function getObjectTypesFromQuery(query) {
-  const types = /* @__PURE__ */ new Set();
-  for (const {
+function extractReferencedObjectsFromAction(actionType) {
+  const referencedObjectsInParameters = Object.values(actionType.parameters).flatMap(({
     dataType
-  } of Object.values(query.parameters)) {
-    getObjectTypesFromDataType(dataType, types);
-  }
-  getObjectTypesFromDataType(query.output, types);
-  return Array.from(types);
+  }) => {
+    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":
+        return [];
+    }
+  });
+  return [...referenceObjectsInEdits, ...referencedObjectsInParameters];
 }
-function getObjectTypesFromDataType(dataType, types) {
-  switch (dataType.type) {
-    case "array":
-    case "set":
-      getObjectTypesFromDataType(dataType.subType, types);
-      return;
-    case "object":
-      types.add(dataType.objectTypeApiName);
-      return;
+function extractReferencedObjectsFromActionParameter(actionParameter) {
+  switch (actionParameter.type) {
     case "objectSet":
-      types.add(dataType.objectTypeApiName);
-      return;
-    case "struct":
-      for (const prop of Object.values(dataType.fields)) {
-        getObjectTypesFromDataType(prop.fieldType, types);
-      }
-      return;
-    case "union":
-      for (const type of dataType.unionTypes) {
-        getObjectTypesFromDataType(type, types);
-      }
-      return;
-    case "attachment":
+    case "object":
+      return actionParameter.objectTypeApiName;
+    case "array":
+      return extractReferencedObjectsFromActionParameter(actionParameter.subType);
+    case "string":
     case "boolean":
+    case "attachment":
     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}`);
+      return void 0;
   }
 }
-function getQueryDefSatisfies(apiName, objectTypes) {
-  return `satisfies QueryDefinition<"${apiName}", ${objectTypes.length > 0 ? objectTypes.map((apiNameObj) => `"${apiNameObj}"`).join("|") : "never"}>;`;
+
+// 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);
 }
-function getOsdkTargetTypeIfPresent(objectTypeApiName, v2) {
-  return `
-      __OsdkTargetType: ${getObjectDefIdentifier(objectTypeApiName, v2)}
+
+// src/v1.1/wireObjectTypeV2ToSdkObjectConstV1.ts
+function wireObjectTypeV2ToSdkObjectConstV1(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.og, false));
+  const objectDefIdentifier = object.getDefinitionIdentifier(false);
+  function getV1Types() {
+    return `
+      export interface ${objectDefIdentifier} extends ObjectTypeDefinition<"${object.fullApiName}", ${object.uniqueImportName}> {
+        ${stringify(definition, {
+      osdkMetadata: () => void 0,
+      // not used in v1
+      links: (_value) => `{
+          ${stringify(definition.links, {
+        "*": (definition2) => `ObjectTypeLinkDefinition<${ontology.requireObjectType(definition2.targetType).getImportedDefinitionIdentifier(false)}, ${definition2.multiplicity}>`
+      })}
+        }`
+    })}
+      }
     `;
+  }
+  const imports = getObjectImports(uniqueLinkTargetTypes, definition.apiName, currentFilePath, false);
+  return `${imports}${getV1Types()}
+
+    export const ${object.shortApiName}: ${objectDefIdentifier} = {
+      ${stringify(definition, {
+    osdkMetadata: (value) => void 0
+  })}
+    
+    };`;
 }
-async function generateQueries(ontology, fs2, outDir, importExt = "") {
-  const importedObjects = /* @__PURE__ */ new Set();
-  const signatures = [];
-  for (const query of Object.values(ontology.queryTypes)) {
-    const jsDocBlock = ["/**"];
-    if (query.description) {
-      jsDocBlock.push(`* ${query.description}`);
-    }
-    const outputType = handleQueryDataType(query.output, importedObjects, true);
-    const paramEntries = [];
-    for (const [name, parameter] of Object.entries(query.parameters)) {
-      const nullable = isNullableQueryDataType(parameter.dataType);
-      const type = handleQueryDataType(parameter.dataType, importedObjects, false);
-      paramEntries.push(`"${name}"${nullable ? "?" : ""}: ${type}`);
-      jsDocBlock.push(`* @param {${sanitizeDocTypeName(type)}} params.${name}${parameter.description ? ` - ${parameter.description}` : ""}`);
+
+// src/util/reservedKeywords.ts
+var reservedKeywords = /* @__PURE__ */ new Set(["break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do", "else", "enum", "export", "extends", "false", "finally", "for", "function", "if", "import", "in", "instanceof", "new", "null", "return", "super", "switch", "this", "throw", "true", "try", "typeof", "var", "void", "while", "with", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"]);
+function isReservedKeyword(name) {
+  return reservedKeywords.has(name);
+}
+
+// src/v1.1/wireObjectTypeV2ToV1ObjectInterfaceString.ts
+function wireObjectTypeV2ToObjectInterfaceStringV1(objectTypeWithLinks, importExt = "") {
+  const uniqueLinkTargets = new Set(objectTypeWithLinks.linkTypes.map((a) => a.objectTypeApiName).filter((a) => a !== objectTypeWithLinks.objectType.apiName));
+  return `import type { OntologyObject, LocalDate, Timestamp, GeoShape, GeoPoint, Attachment, TimeSeries, MultiLink, SingleLink, StringLong } from "@osdk/legacy-client";
+${Array.from(uniqueLinkTargets).map((linkTarget) => `import type { ${linkTarget} } from "./${linkTarget}${importExt}";`).join("\n")}
+
+  ${getDescriptionIfPresent(objectTypeWithLinks.objectType.description)}
+  export interface ${objectTypeWithLinks.objectType.apiName} extends OntologyObject {
+  /** @deprecated please migrate to $apiName instead */
+  readonly __apiName: "${objectTypeWithLinks.objectType.apiName}" & {${objectTypeWithLinks.linkTypes.map((linkType) => {
+    return `/** @deprecated please migrate to pivotTo(${linkType.apiName}) instead */ searchAround${linkType.apiName.charAt(0).toUpperCase() + linkType.apiName.slice(1)}?: never`;
+  })}};
+  /** @deprecated please migrate to $primaryKey instead */
+  readonly __primaryKey: ${wirePropertyTypeV2ToTypeScriptType(objectTypeWithLinks.objectType.properties[objectTypeWithLinks.objectType.primaryKey].dataType)};
+  readonly $apiName: "${objectTypeWithLinks.objectType.apiName}";
+  readonly $primaryKey: ${wirePropertyTypeV2ToTypeScriptType(objectTypeWithLinks.objectType.properties[objectTypeWithLinks.objectType.primaryKey].dataType)};
+${Object.entries(objectTypeWithLinks.objectType.properties).sort((a, b) => a[0].localeCompare(b[0])).flatMap(([propertyName, propertyDefinition]) => {
+    const propertyType = wirePropertyTypeV2ToTypeScriptType(propertyDefinition.dataType);
+    const entries = [`${getDescriptionIfPresent(propertyDefinition.description, true)}readonly ${propertyName}: ${propertyType} | undefined`];
+    if (isReservedKeyword(propertyName)) {
+      entries.push(`/** @deprecated please migrate to '${propertyName}' instead */
+          readonly ${propertyName}_: ${propertyType} | undefined`);
     }
-    const param = paramEntries.length === 0 ? "" : `params: { ${paramEntries.join("; ")} }`;
-    jsDocBlock.push(`* @returns ${sanitizeDocTypeName(outputType)}`, "*/");
-    signatures.push(`
-      ${jsDocBlock.join("\n")}
-      ${query.apiName}(${param}): Promise<Result<QueryResponse<${outputType}>, QueryError>>;
-      `);
+    return entries;
+  }).join(";\n")}
+${objectTypeWithLinks.linkTypes.flatMap((linkType) => {
+    const entries = [`readonly ${linkType.apiName}: ${linkType.cardinality === "MANY" ? "MultiLink" : "SingleLink"}<${linkType.objectTypeApiName}>`];
+    return entries;
+  }).join(";\n")}
+}
+  `;
+}
+function wirePropertyTypeV2ToTypeScriptType(property) {
+  switch (property.type) {
+    case "string":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return wirePropertyTypeV2ToTypeScriptType(property.subType) + "[]";
+    case "integer":
+      return "number";
+    case "attachment":
+      return "Attachment";
+    case "byte":
+      return "number";
+    case "date":
+      return "LocalDate";
+    case "decimal":
+      return "string";
+    case "double":
+      return "number";
+    case "float":
+      return "number";
+    case "geopoint":
+      return "GeoPoint";
+    case "geoshape":
+      return "GeoShape";
+    case "long":
+      return "StringLong";
+    case "short":
+      return "number";
+    case "timestamp":
+      return "Timestamp";
+    case "timeseries":
+      return property.itemType.type === "string" ? `TimeSeries<string>` : `TimeSeries<number>`;
+    case "marking":
+      return "string";
+    default:
+      throw new Error(`Unknown property type ${property}`);
+  }
+}
+function getDescriptionIfPresent(description, includeNewline) {
+  if (description) {
+    return `/**
+ * ${description}
+ */${includeNewline ? "\n" : ""}`;
   }
+  return "";
+}
+
+// src/v1.1/generatePerObjectInterfaceAndDataFiles.ts
+async function generatePerObjectInterfaceAndDataFiles(ontology, fs2, outDir, importExt = "") {
   await fs2.mkdir(outDir, {
     recursive: true
   });
-  await fs2.writeFile(path16__default.join(outDir, "Queries.ts"), await formatTs(`
-    import type { QueryResponse, QueryError, Result, Timestamp, LocalDate, Range, Attachment, ObjectSet, TwoDimensionalAggregation, ThreeDimensionalAggregation  } from "@osdk/legacy-client";
-    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
+  await Promise.all(Object.values(ontology.og.objectTypes).map(async (object) => {
+    const relPath = path16__default.join(".", "ontology", `objects`, `${object.objectType.apiName}.ts`);
+    await fs2.writeFile(path16__default.join(outDir, `${object.objectType.apiName}.ts`), await formatTs(`
+        import type { ObjectTypeDefinition, ObjectTypeLinkDefinition, PropertyDef } from "@osdk/api";
+        ${wireObjectTypeV2ToObjectInterfaceStringV1(object, importExt)}
 
-    export interface Queries {
-    ${signatures.join("\n")}
-    }
-  `));
+        ${wireObjectTypeV2ToSdkObjectConstV1(object, {
+      ontology
+    }, relPath)}
+        `));
+  }));
+  await fs2.writeFile(path16__default.join(outDir, "index.ts"), await formatTs(`
+    ${Object.keys(ontology.og.objectTypes).map((apiName) => `export * from "./${apiName}${importExt}";`).join("\n")}
+      export type { ObjectSet } from "@osdk/legacy-client";
+
+    `));
 }
-function handleQueryDataType(dataType, importedObjects, isReturnValue) {
+
+// 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":
-      return "boolean";
+    case "date":
+    case "double":
+    case "float":
+    case "integer":
+    case "long":
+    case "null":
     case "string":
-      return "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 wireQueryTypeV2ToSdkQueryDefinition(input) {
+  return {
+    type: "query",
+    apiName: input.apiName,
+    description: input.description,
+    displayName: input.displayName,
+    version: input.version,
+    parameters: Object.fromEntries(Object.entries(input.parameters).map(([name, parameter]) => [name, wireQueryParameterV2ToQueryParameterDefinition(parameter)])),
+    output: wireQueryDataTypeToQueryDataTypeDefinition(input.output)
+  };
+}
+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/v1.1/generatePerQueryDataFiles.ts
+async function generatePerQueryDataFiles({
+  fs: fs2,
+  outDir: rootOutDir,
+  ontology
+}, v2) {
+  const relOutDir = path16__default.join(".", "ontology", "queries");
+  const outDir = path16__default.join(rootOutDir, "ontology", "queries");
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await Promise.all(Object.values(ontology.queryTypes).map(async (query) => {
+    await generateV1QueryFile(fs2, outDir, query);
+  }));
+  await fs2.writeFile(path16__default.join(outDir, "index.ts"), await formatTs(`
+  ${Object.values(ontology.queryTypes).map((query) => `export * from "${query.getImportPathRelTo(path16__default.join(relOutDir, "index.ts"))}";`).join("\n")}
+    ${Object.keys(ontology.queryTypes).length === 0 ? "export {};" : ""}
+  `));
+}
+async function generateV1QueryFile(fs2, outDir, query) {
+  const objectTypes = getObjectTypeApiNamesFromQuery(query);
+  await fs2.writeFile(path16__default.join(outDir, `${query.shortApiName}.ts`), await formatTs(`
+      import { QueryDefinition } from "@osdk/api";
+
+      export const ${query.shortApiName} = ${JSON.stringify(wireQueryTypeV2ToSdkQueryDefinition(query.og))} ${getQueryDefSatisfies(query.fullApiName, objectTypes)}`));
+}
+function getQueryDefSatisfies(apiName, objectTypes) {
+  return `satisfies QueryDefinition<"${apiName}", ${objectTypes.length > 0 ? objectTypes.map((apiNameObj) => `"${apiNameObj}"`).join("|") : "never"}>;`;
+}
+async function generateQueries(ontology, fs2, outDir, importExt = "") {
+  const importedObjects = /* @__PURE__ */ new Set();
+  const signatures = [];
+  for (const query of Object.values(ontology.queryTypes)) {
+    const jsDocBlock = ["/**"];
+    if (query.description) {
+      jsDocBlock.push(`* ${query.description}`);
+    }
+    const outputType = handleQueryDataType(query.output, importedObjects, true);
+    const paramEntries = [];
+    for (const [name, parameter] of Object.entries(query.parameters)) {
+      const nullable = isNullableQueryDataType(parameter.dataType);
+      const type = handleQueryDataType(parameter.dataType, importedObjects, false);
+      paramEntries.push(`"${name}"${nullable ? "?" : ""}: ${type}`);
+      jsDocBlock.push(`* @param {${sanitizeDocTypeName(type)}} params.${name}${parameter.description ? ` - ${parameter.description}` : ""}`);
+    }
+    const param = paramEntries.length === 0 ? "" : `params: { ${paramEntries.join("; ")} }`;
+    jsDocBlock.push(`* @returns ${sanitizeDocTypeName(outputType)}`, "*/");
+    signatures.push(`
+      ${jsDocBlock.join("\n")}
+      ${query.apiName}(${param}): Promise<Result<QueryResponse<${outputType}>, QueryError>>;
+      `);
+  }
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__default.join(outDir, "Queries.ts"), await formatTs(`
+    import type { QueryResponse, QueryError, Result, Timestamp, LocalDate, Range, Attachment, ObjectSet, TwoDimensionalAggregation, ThreeDimensionalAggregation  } from "@osdk/legacy-client";
+    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
+
+    export interface Queries {
+    ${signatures.join("\n")}
+    }
+  `));
+}
+function handleQueryDataType(dataType, importedObjects, isReturnValue) {
+  switch (dataType.type) {
+    case "boolean":
+      return "boolean";
+    case "string":
+      return "string";
+    case "double":
+    case "float":
+    case "integer":
+      return "number";
+    case "long":
+      return isReturnValue ? "string" : "string | number";
+    case "date":
+      return "LocalDate";
+    case "timestamp":
+      return "Timestamp";
+    case "attachment":
+      return "Attachment";
+    case "array":
+      return `Array<${handleQueryDataType(dataType.subType, importedObjects, isReturnValue)}>`;
+    case "object": {
+      const objectType = dataType.objectTypeApiName;
+      importedObjects.add(objectType);
+      return isReturnValue ? objectType : `${objectType} | ${objectType}["__primaryKey"]`;
+    }
+    case "objectSet": {
+      const objectType = dataType.objectTypeApiName;
+      importedObjects.add(objectType);
+      return `ObjectSet<${objectType}>`;
+    }
+    case "set":
+      return `Set<${handleQueryDataType(dataType.subType, importedObjects, isReturnValue)}>`;
+    case "struct":
+      const properties = dataType.fields.map((field) => {
+        const isNullable = isNullableQueryDataType(field.fieldType);
+        return `${field.name}${isNullable ? "?" : ""}: ${handleQueryDataType(field.fieldType, importedObjects, isReturnValue)}`;
+      });
+      return `{ ${properties.join(",\n")} }`;
+    case "union":
+      return dataType.unionTypes.map((type) => handleQueryDataType(type, importedObjects, isReturnValue)).filter((type) => type !== "null").join("|");
+    case "twoDimensionalAggregation":
+      dataType.valueType;
+      return `TwoDimensionalAggregation<
+        ${aggregationKeyToTypescriptType(dataType.keyType)},
+        ${aggregationValueToTypescriptType(dataType.valueType)}
+      >`;
+    case "threeDimensionalAggregation":
+      return `ThreeDimensionalAggregation<
+        ${aggregationKeyToTypescriptType(dataType.keyType)},
+        ${aggregationKeyToTypescriptType(dataType.valueType.keyType)},
+        ${aggregationValueToTypescriptType(dataType.valueType.valueType)}
+      >`;
+    case "null":
+      return "null";
+    case "unsupported":
+      throw new Error("Cannot generate queries for unsupported type");
+    default:
+      throw new Error(`Cannot generate queries for type ${dataType.type}`);
+  }
+}
+function aggregationKeyToTypescriptType(keyType) {
+  switch (keyType.type) {
+    case "boolean":
+      return "boolean";
+    case "double":
+    case "integer":
+      return "number";
+    case "string":
+      return "string";
+    case "date":
+      return "LocalDate";
+    case "timestamp":
+      return "Timestamp";
+    case "range":
+      return `Range<${aggregationRangeToTypescriptType(keyType.subType)}>`;
+    default:
+      throw new Error(`Unknown TwoDimensionalAggregation keyType ${keyType.type}`);
+  }
+}
+function aggregationRangeToTypescriptType(subType) {
+  switch (subType.type) {
+    case "date":
+      return "LocalDate";
+    case "double":
+    case "integer":
+      return "number";
+    case "timestamp":
+      return "Timestamp";
+    default:
+      throw new Error(`Unsupported QueryAggregationRangeSubType ${subType.type}`);
+  }
+}
+function aggregationValueToTypescriptType(valueType) {
+  switch (valueType.type) {
+    case "date":
+      return "LocalDate";
+    case "double":
+      return "number";
+    case "timestamp":
+      return "Timestamp";
+    default:
+      throw new Error(`Unsupported QueryAggregationValueType ${valueType.type}`);
+  }
+}
+function sanitizeDocTypeName(type) {
+  return type.replace(/\s/g, "");
+}
+
+// src/v1.1/generateClientSdkVersionOneDotOne.ts
+async function generateClientSdkVersionOneDotOne(ontology, userAgent, fs2, outDir, packageType = "commonjs") {
+  const importExt = packageType === "module" ? ".js" : "";
+  const objectsDir = path16.join(outDir, "ontology", "objects");
+  const actionsDir = path16.join(outDir, "ontology", "actions");
+  const queriesDir = path16.join(outDir, "ontology", "queries");
+  await verifyOutDir(outDir, fs2);
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  const sanitizedOntology = sanitizeMetadata(ontology);
+  const enhancedOntology = enhanceOntology(sanitizedOntology, void 0, /* @__PURE__ */ new Map(), importExt);
+  await generateFoundryClientFile(fs2, outDir, importExt);
+  await generateMetadataFile(sanitizedOntology, userAgent, fs2, outDir, importExt);
+  await generateOntologyIndexFile(fs2, path16.join(outDir, "ontology"));
+  await generateObjectsInterfaceFile(sanitizedOntology, fs2, objectsDir, importExt);
+  await generateObjectsInterfaceSupportFiles(sanitizedOntology, fs2, path16.join(objectsDir, "objects-api"), importExt);
+  await generatePerObjectInterfaceAndDataFiles(enhancedOntology, fs2, objectsDir, importExt);
+  const common = {
+    sanitizedOntology,
+    fs: fs2,
+    outDir,
+    ontology: enhancedOntology
+  };
+  await generateActions(sanitizedOntology, fs2, actionsDir, importExt);
+  await generateBatchActions(sanitizedOntology, fs2, actionsDir, importExt);
+  await generateBulkActions(sanitizedOntology, fs2, actionsDir, importExt);
+  await generatePerActionDataFilesV1(common);
+  await generateQueries(sanitizedOntology, fs2, queriesDir, importExt);
+  await generatePerQueryDataFiles(common);
+  await generateIndexFile(fs2, outDir, importExt);
+  await generateBackCompatDeprecatedExports(fs2, outDir, importExt);
+}
+var ExpectedOsdkVersion = "0.22.0";
+async function generateOntologyMetadataFile({
+  fs: fs2,
+  outDir,
+  ontology,
+  ontologyApiNamespace
+}, userAgent) {
+  fs2.writeFile(path16__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/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.og, 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}.Definition`,
+    osdkObjectLinksIdentifier,
+    osdkObjectPropsIdentifier,
+    osdkObjectStrictPropsIdentifier,
+    objectSetIdentifier,
+    osdkObjectIdentifier,
+    propertyKeysIdentifier
+  };
+  function getV2Types() {
+    return `import type {
+      AggregateOpts as $AggregateOpts,
+      AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy as $AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy,
+      AggregationsResults as $AggregationsResults, 
+      Augments as $Augments,
+      ConvertProps as $ConvertProps,
+      DefaultToFalse as $DefaultToFalse,
+      FetchPageArgs as $FetchPageArgs,
+      FetchPageResult as $FetchPageResult,
+      LinkedType as $LinkedType,
+      LinkNames as $LinkNames,
+      NullabilityAdherence as $NullabilityAdherence,
+      NullabilityAdherenceDefault as $NullabilityAdherenceDefault,
+      ObjectSet as $ObjectSet, 
+      Osdk as $Osdk,
+      OsdkObject as $OsdkObject,
+      OsdkObjectLinksEntry as $OsdkObjectLinksEntry,
+      OsdkObjectLinksObject as $OsdkObjectLinksObject,
+      OsdkObjectPropertyType as $OsdkObjectPropertyType,
+      PageResult as $PageResult,
+      PropertyValueClientToWire as $PropertyValueClientToWire,
+      PropertyValueWireToClient as $PropType,
+      Result as $Result,
+      SelectArg as $SelectArg, 
+      SingleLinkAccessor  as $SingleLinkAccessor,
+      SingleLinkAccessor as $SingleLinkAccessor
+      SingleOsdkResult as $SingleOsdkResult,
+      ValidToFrom as $ValidToFrom,
+      WhereClause as $WhereClause,
+    } from "@osdk/client.api";
+    import type * as $clientApi from "@osdk/client.api";
+    import type {
+      ObjectOrInterfacePropertyKeysFrom2 as $ObjectOrInterfacePropertyKeysFrom2,  
+      ObjectTypeDefinition as $ObjectTypeDefinition,
+      ObjectTypeLinkDefinition as $ObjectTypeLinkDefinition,
+    } from "@osdk/api";
+
+    export namespace ${object.shortApiName} {
+
+      ${createPropertyKeys(object)}
+
+
+      ${createLinks(ontology, object, "Links")}
+
+      ${createProps(object, "Props", false)}
+      ${createProps(object, "StrictProps", true)}
+
+      ${createObjectSet(object, identifiers)}
+
+      ${createDefinition(object, ontology, "Definition", identifiers)}
+      ${createOsdkObject(object, "OsdkObject", identifiers)}
+    }    
+
+
+
+
+  /** @deprecated use ${object.shortApiName}.Definition **/
+  export type ${objectDefIdentifier} = ${object.shortApiName}.Definition;
+
+
+    `;
+  }
+  const imports = getObjectImports(uniqueLinkTargetTypes, definition.apiName, currentFilePath, true);
+  return `${imports}${getV2Types()}
+
+    export const ${object.shortApiName}: ${objectDefIdentifier}  & $VersionBound<$ExpectedClientVersion>
+    = {
+      osdkMetadata: $osdkMetadata,
+      objectSet: undefined as any,
+      props: undefined as any,
+      strictProps: undefined as any,
+      ${stringify(definition, {
+    osdkMetadata: (value) => void 0
+  })}
+    
+    };`;
+}
+function createOsdkObject(object, identifier, {
+  osdkObjectPropsIdentifier,
+  objectDefIdentifier,
+  osdkObjectStrictPropsIdentifier,
+  osdkObjectLinksIdentifier
+}) {
+  const definition = object.getCleanedUpDefinition(true);
+  return `
+  export type ${identifier}<
+      OPTIONS extends "$strict" | "$notStrict" | "$rid" = "$strict",
+      K extends keyof ${osdkObjectPropsIdentifier}= keyof ${osdkObjectPropsIdentifier},
+
+  > 
+    = $Osdk<
+        ${objectDefIdentifier}, 
+        K | OPTIONS
+      > & Pick<
+        OPTIONS extends "$notStrict" ? ${osdkObjectPropsIdentifier} : ${osdkObjectStrictPropsIdentifier}
+        , K
+> & {
+    readonly $link: ${osdkObjectLinksIdentifier};
+    readonly $title: string | undefined; // FIXME
+    readonly $primaryKey: ${"primaryKeyApiName" in definition ? `
+      $OsdkObjectPropertyType<${JSON.stringify(definition.properties[definition.primaryKeyApiName])},${true}>` : "string | number"}
+  ;
+    
+    readonly $as: <NEW_Q extends $ValidToFrom<${objectDefIdentifier}>>(type: NEW_Q | string) => $Osdk<
+  NEW_Q,
+  $ConvertProps<${objectDefIdentifier}, NEW_Q, K>
+>;
+} & $OsdkObject<"${object.fullApiName}">;`;
+}
+function createObjectSet(object, {
+  objectDefIdentifier,
+  objectSetIdentifier,
+  propertyKeysIdentifier,
+  osdkObjectIdentifier
+}) {
+  return `
+export interface ObjectSet extends 
+$ObjectSet<${objectDefIdentifier},
+
+${objectSetIdentifier}
+>
+{
+readonly aggregate: <AO extends $AggregateOpts<${objectDefIdentifier}>>(
+  req: $AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy<${objectDefIdentifier}, AO>,
+) => Promise<$AggregationsResults<${objectDefIdentifier}, AO>>;
+
+
+readonly pivotTo: <L extends $LinkNames<${objectDefIdentifier}>>(type: L) => $LinkedType<${objectDefIdentifier}, L>["objectSet"];
+ ${object instanceof EnhancedObjectType ? ` 
+readonly fetchOne: <
+    L extends ${propertyKeysIdentifier},
+    R extends boolean,
+    S extends false | "throw" = $NullabilityAdherenceDefault,
+  >(
+    primaryKey: $PropertyValueClientToWire[${objectDefIdentifier}["primaryKeyType"]],
+    options?: $SelectArg<${objectDefIdentifier}, L, R, S>,
+  ) => Promise<
+   ${osdkObjectIdentifier}<
+    (S extends false ? "$notStrict" : "$strict") | ($DefaultToFalse<R> extends false? never:  "$rid" ),
+    L
+   >>
+  ;
+
+readonly fetchOneWithErrors: <
+    L extends ${propertyKeysIdentifier},
+    R extends boolean,
+    S extends false | "throw" = $NullabilityAdherenceDefault,
+  >(
+    primaryKey: $PropertyValueClientToWire[${objectDefIdentifier}["primaryKeyType"]],
+    options?: $SelectArg<${objectDefIdentifier}, L, R, S>,
+  ) => Promise<$Result<
+        ${osdkObjectIdentifier}<
+        (S extends false ? "$notStrict" : "$strict") | ($DefaultToFalse<R> extends false?never: "$rid"),
+        L
+      >
+   >> 
+  
+;
+
+` : ""}
+
+readonly fetchPage: <
+  L extends ${propertyKeysIdentifier},
+  R extends boolean,
+  const A extends $Augments,
+  S extends $NullabilityAdherence = $NullabilityAdherenceDefault,
+>(
+  args?: $FetchPageArgs<${objectDefIdentifier}, L, R, A, S>,
+) => Promise<
+  $PageResult<${osdkObjectIdentifier}<
+    (S extends false ? "$notStrict" : "$strict") | ($DefaultToFalse<R> extends false? never: "$rid"),
+    L
+  >>
+>;
+
+readonly fetchPageWithErrors: <
+  L extends ${propertyKeysIdentifier},
+  R extends boolean,
+  const A extends $Augments,
+  S extends $NullabilityAdherence = $NullabilityAdherenceDefault,
+>(
+  args?: $FetchPageArgs<${objectDefIdentifier}, L, R, A, S>,
+) => Promise<$Result<
+ $PageResult<${osdkObjectIdentifier}<
+ (S extends false ? "$notStrict" : "$strict") | ($DefaultToFalse<R> extends false? never : "$rid"),
+ L>>
+ >>;
+
+readonly asyncIter: () => AsyncIterableIterator<${osdkObjectIdentifier}>;
+}
+`;
+}
+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
+}) {
+  const definition = object.getCleanedUpDefinition(true);
+  return `
+    export interface ${identifier} extends ${object instanceof EnhancedObjectType ? `$ObjectTypeDefinition` : `$InterfaceDefinition`}<"${object.fullApiName}", ${objectDefIdentifier}>, $VersionBound<$ExpectedClientVersion> {
+      osdkMetadata: typeof $osdkMetadata;
+      objectSet: ${objectSetIdentifier};
+      props: ${osdkObjectPropsIdentifier};
+      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} = never;` : `
+        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}.Definition>`}
+          `];
+    }
+  })}
+    }
+    `}`;
+}
+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 = path16__default.join(rootOutDir, "ontology", "actions");
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await Promise.all(Object.values(enhancedOntology.actionTypes).map(async (action) => {
+    const currentFilePath = `${path16__default.join("ontology", "actions", `${action.shortApiName}.ts`)}`;
+    const uniqueApiNamesArray = extractReferencedObjectsFromAction2(action.og);
+    const uniqueApiNames = new Set(uniqueApiNamesArray);
+    const uniqueApiNamesString = stringUnionFrom2([...uniqueApiNames]);
+    const fullActionDef = deleteUndefineds(wireActionTypeV2ToSdkActionDefinition(action.og));
+    const {
+      parameters,
+      ...actionDefSansParameters
+    } = fullActionDef;
+    function createParamsDef() {
+      const entries = Object.entries(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() {
+      const oldParamsIdentifier = `${action.shortApiName}$Params`;
+      return `
+        
+          export namespace ${action.shortApiName}{
+            ${createParamsDef()}
+
+            ${getDescriptionIfPresent(action.description)}
+            export interface Parameters {
+              ${stringify(parameters, {
+        "*": (ogValue, _, ogKey) => {
+          const key = `${getDescriptionIfPresent(ogValue.description)}
+                  readonly "${ogKey}"${ogValue.nullable ? "?" : ""}`;
+          const value = ogValue.multiplicity ? `ReadonlyArray<${getActionParamType(ogValue.type)}>` : `${getActionParamType(ogValue.type)}`;
+          return [key, value];
+        }
+      })}
+            }
+
+
+              // Represents the definition of the action
+              export interface Definition extends ActionDefinition<"${action.shortApiName}", ${uniqueApiNamesString}, ${action.shortApiName}>, VersionBound<$ExpectedClientVersion> {
+              ${Object.entries(actionDefSansParameters).sort((a, b) => a[0].localeCompare(b[0])).map(([key, value]) => {
+        return `${key}: ${JSON.stringify(value)};`;
+      }).join("\n")}
+              parameters: ${action.definitionParamsIdentifier};
+              osdkMetadata: typeof $osdkMetadata;
+            }
+
+            // Represents a fqn of the action
+            export interface Signature {
+              ${getDescriptionIfPresent(action.description)}
+               <P extends ${action.paramsIdentifier} | ReadonlyArray<${action.paramsIdentifier}>, OP extends (P extends  ReadonlyArray<${action.paramsIdentifier}> ? ApplyBatchActionOptions: ApplyActionOptions)>(args: P, options?: OP): Promise<ActionReturnTypeForOptions<OP>>;
+            }
+  
+          }
+
+          /**
+           * @deprecated Use \`${action.paramsIdentifier}\`
+           */
+          export type ${oldParamsIdentifier} = ${action.paramsIdentifier} | ReadonlyArray<${action.paramsIdentifier}>;
+
+          /** @deprecated Use \`${action.definitionIdentifier}\` **/
+          export type ${action.shortApiName} = ${action.shortApiName}.Signature;
+          `;
+    }
+    function createV2Object() {
+      return `  export const ${action.shortApiName}: ${action.definitionIdentifier} = 
+        {
+          ${stringify(fullActionDef)},
+          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(path16__default.join(rootOutDir, currentFilePath), await formatTs(`
+          import type { ActionDefinition, ObjectActionDataType, ObjectSetActionDataType, VersionBound} from "@osdk/api";
+          import type { ApplyActionOptions, ApplyBatchActionOptions, ActionReturnTypeForOptions, ActionParam } from '@osdk/client.api';
+          import { $osdkMetadata} from "../../OntologyMetadata${importExt}";
+          import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
+          ${imports}
+
+        
+          ${createV2Types()}
+
+          ${createV2Object()}
+        `));
+  }));
+  const indexFileRelPath = path16__default.join("ontology", "actions.ts");
+  await fs2.writeFile(path16__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 extractReferencedObjectsFromAction2(actionType) {
+  const referencedObjectsInParameters = Object.values(actionType.parameters).flatMap(({
+    dataType
+  }) => {
+    const objectTypeReference = extractReferencedObjectsFromActionParameter2(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":
+        return [];
+    }
+  });
+  return [...referenceObjectsInEdits, ...referencedObjectsInParameters];
+}
+function extractReferencedObjectsFromActionParameter2(actionParameter) {
+  switch (actionParameter.type) {
+    case "objectSet":
+    case "object":
+      return actionParameter.objectTypeApiName;
+    case "array":
+      return extractReferencedObjectsFromActionParameter2(actionParameter.subType);
+    case "string":
+    case "boolean":
+    case "attachment":
+    case "date":
     case "double":
-    case "float":
     case "integer":
-      return "number";
     case "long":
-      return isReturnValue ? "string" : "string | number";
-    case "date":
-      return "LocalDate";
     case "timestamp":
-      return "Timestamp";
-    case "attachment":
-      return "Attachment";
-    case "array":
-      return `Array<${handleQueryDataType(dataType.subType, importedObjects, isReturnValue)}>`;
-    case "object": {
-      const objectType = dataType.objectTypeApiName;
-      importedObjects.add(objectType);
-      return isReturnValue ? objectType : `${objectType} | ${objectType}["__primaryKey"]`;
+      return void 0;
+  }
+}
+async function generatePerQueryDataFilesV2({
+  fs: fs2,
+  outDir: rootOutDir,
+  ontology,
+  importExt = ""
+}, v2) {
+  const relOutDir = path16__default.join(".", "ontology", "queries");
+  const outDir = path16__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 = path16__default.join(relOutDir, `${query.shortApiName}.ts`);
+  const objectTypes = getObjectTypeApiNamesFromQuery(query);
+  const importObjects = getObjectImports2(ontology, objectTypes, relFilePath);
+  const baseProps = deleteUndefineds(wireQueryTypeV2ToSdkQueryDefinitionNoParams(query.og));
+  const outputBase = deleteUndefineds(wireQueryDataTypeToQueryDataTypeDefinition(query.output));
+  const referencedObjectTypes = objectTypes.length > 0 ? objectTypes.map((apiNameObj) => `"${apiNameObj}"`).join("|") : "never";
+  await fs2.writeFile(path16__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")}`];
     }
-    case "objectSet": {
-      const objectType = dataType.objectTypeApiName;
-      importedObjects.add(objectType);
-      return `ObjectSet<${objectType}>`;
+  })}
+            }
+    
+            ` : ""}
+
+        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}
+`;
     }
-    case "set":
-      return `Set<${handleQueryDataType(dataType.subType, importedObjects, isReturnValue)}>`;
-    case "struct":
-      const properties = dataType.fields.map((field) => {
-        const isNullable = isNullableQueryDataType(field.fieldType);
-        return `${field.name}${isNullable ? "?" : ""}: ${handleQueryDataType(field.fieldType, importedObjects, isReturnValue)}`;
-      });
-      return `{ ${properties.join(",\n")} }`;
-    case "union":
-      return dataType.unionTypes.map((type) => handleQueryDataType(type, importedObjects, isReturnValue)).filter((type) => type !== "null").join("|");
-    case "twoDimensionalAggregation":
-      dataType.valueType;
-      return `TwoDimensionalAggregation<
-        ${aggregationKeyToTypescriptType(dataType.keyType)},
-        ${aggregationValueToTypescriptType(dataType.valueType)}
-      >`;
-    case "threeDimensionalAggregation":
-      return `ThreeDimensionalAggregation<
-        ${aggregationKeyToTypescriptType(dataType.keyType)},
-        ${aggregationKeyToTypescriptType(dataType.valueType.keyType)},
-        ${aggregationValueToTypescriptType(dataType.valueType.valueType)}
-      >`;
-    case "null":
-      return "null";
-    case "unsupported":
-      throw new Error("Cannot generate queries for unsupported type");
-    default:
-      throw new Error(`Cannot generate queries for type ${dataType.type}`);
+  } else {
+    ret += ` * (no ontology metadata)
+`;
   }
+  ret += ` */
+`;
+  return ret;
 }
-function aggregationKeyToTypescriptType(keyType) {
-  switch (keyType.type) {
-    case "boolean":
-      return "boolean";
-    case "double":
-    case "integer":
-      return "number";
-    case "string":
-      return "string";
-    case "date":
-      return "LocalDate";
-    case "timestamp":
-      return "Timestamp";
-    case "range":
-      return `Range<${aggregationRangeToTypescriptType(keyType.subType)}>`;
-    default:
-      throw new Error(`Unknown TwoDimensionalAggregation keyType ${keyType.type}`);
+function getObjectImports2(enhancedOntology, objectTypes, filePath) {
+  let ret = "";
+  for (const fqObjectApiName of objectTypes) {
+    const obj = enhancedOntology.requireObjectType(fqObjectApiName);
+    ret += `import type { ${obj.getDefinitionIdentifier(true)} as ${obj.getImportedDefinitionIdentifier(true)} } from "${obj.getImportPathRelTo(filePath)}";
+`;
   }
+  return ret;
 }
-function aggregationRangeToTypescriptType(subType) {
-  switch (subType.type) {
+function getQueryParamType(enhancedOntology, input, type) {
+  let inner = `unknown /* ${input.type} */`;
+  switch (input.type) {
     case "date":
-      return "LocalDate";
+      inner = `Query${type}.PrimitiveType<${JSON.stringify("datetime")}>`;
+      break;
+    case "attachment":
+    case "boolean":
     case "double":
+    case "float":
     case "integer":
-      return "number";
+    case "long":
+    case "string":
+    case "struct":
+    case "threeDimensionalAggregation":
     case "timestamp":
-      return "Timestamp";
-    default:
-      throw new Error(`Unsupported QueryAggregationRangeSubType ${subType.type}`);
+    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;
   }
-}
-function aggregationValueToTypescriptType(valueType) {
-  switch (valueType.type) {
-    case "date":
-      return "LocalDate";
-    case "double":
-      return "number";
-    case "timestamp":
-      return "Timestamp";
-    default:
-      throw new Error(`Unsupported QueryAggregationValueType ${valueType.type}`);
+  if (input.multiplicity && type === "Param") {
+    return `ReadonlyArray<${inner}>`;
+  } else if (input.multiplicity) {
+    return `Array<${inner}>`;
   }
-}
-function sanitizeDocTypeName(type) {
-  return type.replace(/\s/g, "");
-}
-
-// src/v1.1/generateClientSdkVersionOneDotOne.ts
-async function generateClientSdkVersionOneDotOne(ontology, userAgent, fs2, outDir, packageType = "commonjs") {
-  const importExt = packageType === "module" ? ".js" : "";
-  const objectsDir = path16.join(outDir, "ontology", "objects");
-  const actionsDir = path16.join(outDir, "ontology", "actions");
-  const queriesDir = path16.join(outDir, "ontology", "queries");
-  await verifyOutDir(outDir, fs2);
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  const sanitizedOntology = sanitizeMetadata(ontology);
-  await generateFoundryClientFile(fs2, outDir, importExt);
-  await generateMetadataFile(sanitizedOntology, userAgent, fs2, outDir, importExt);
-  await generateOntologyIndexFile(fs2, path16.join(outDir, "ontology"));
-  await generateObjectsInterfaceFile(sanitizedOntology, fs2, objectsDir, importExt);
-  await generateObjectsInterfaceSupportFiles(sanitizedOntology, fs2, path16.join(objectsDir, "objects-api"), importExt);
-  await generatePerObjectInterfaceAndDataFiles(sanitizedOntology, fs2, objectsDir, importExt);
-  await generateActions(sanitizedOntology, fs2, actionsDir, importExt);
-  await generateBatchActions(sanitizedOntology, fs2, actionsDir, importExt);
-  await generateBulkActions(sanitizedOntology, fs2, actionsDir, importExt);
-  await generatePerActionDataFiles(sanitizedOntology, fs2, actionsDir, importExt, false);
-  await generateQueries(sanitizedOntology, fs2, queriesDir, importExt);
-  await generatePerQueryDataFiles(sanitizedOntology, fs2, queriesDir, importExt);
-  await generateIndexFile(fs2, outDir, importExt);
-  await generateBackCompatDeprecatedExports(fs2, outDir, importExt);
+  return inner;
 }
 function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, ontology, v2 = false) {
-  const definition = deleteUndefineds(__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(interfaceDef, v2));
-  const objectDefIdentifier = getObjectDefIdentifier(interfaceDef.apiName, v2);
+  const definition = deleteUndefineds(__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(interfaceDef.og, 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.interfaceTypes[p], v2));
+    const it = deleteUndefineds(__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(ontology.requireInterfaceType(p, true).og, v2));
     return it;
   }) ?? [];
   const mergedProperties = {
@@ -1706,215 +2543,230 @@ function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, ontology,
       mergedProperties[apiName] = parent.properties[apiName];
     }
   }
-  const ogProperties = definition.properties;
+  definition.properties;
   definition.properties = mergedProperties;
-  function localPropertyJsdoc(apiName) {
-    const property = definition.properties[apiName];
-    const isInherited = ogProperties[apiName] == null;
-    return propertyJsdoc(property, {
-      isInherited,
-      apiName
-    });
+  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 `
-  export interface ${objectDefIdentifier} extends InterfaceDefinition<"${interfaceDef.apiName}", ${interfaceDef.apiName}>, VersionBound<$ExpectedClientVersion> {
-    osdkMetadata: typeof $osdkMetadata;
-    ${stringify(definition, {
-      osdkMetadata: () => void 0,
-      type: () => void 0,
-      apiName: () => void 0,
-      links: (_value) => `{
-      ${stringify(definition.links, {
-        "*": (definition2) => `ObjectTypeLinkDefinition<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
-      })}
-    }`,
-      properties: (properties) => `{
-      ${stringify(properties, {
-        "*": (propertyDefinition, _, key) => [`${localPropertyJsdoc(key)}${key}`, `PropertyDef<"${propertyDefinition.type}", "${propertyDefinition.nullable ? "nullable" : "non-nullable"}", "${propertyDefinition.multiplicity ? "array" : "single"}">`]
-      })}
-    }`
+    return `import type {
+      AggregateOpts as $AggregateOpts,
+      AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy as $AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy,
+      AggregationsResults as $AggregationsResults, 
+      Augments as $Augments,
+      ConvertProps as $ConvertProps,
+      DefaultToFalse as $DefaultToFalse,
+      FetchPageArgs as $FetchPageArgs,
+      FetchPageResult as $FetchPageResult,
+      LinkedType as $LinkedType,
+      LinkNames as $LinkNames,
+      NullabilityAdherence as $NullabilityAdherence,
+      NullabilityAdherenceDefault as $NullabilityAdherenceDefault,
+      ObjectSet as $ObjectSet, 
+      Osdk as $Osdk,
+      OsdkObject as $OsdkObject,
+      OsdkObjectLinksEntry as $OsdkObjectLinksEntry,
+      OsdkObjectLinksObject as $OsdkObjectLinksObject,
+      OsdkObjectPropertyType as $OsdkObjectPropertyType,
+      PageResult as $PageResult,
+      PropertyValueClientToWire as $PropertyValueClientToWire,
+      PropertyValueWireToClient as $PropType,
+      Result as $Result,
+      SelectArg as $SelectArg, 
+      SingleLinkAccessor  as $SingleLinkAccessor,
+      SingleOsdkResult as $SingleOsdkResult,
+      ValidToFrom as $ValidToFrom,
+      WhereClause as $WhereClause,
+    } from "@osdk/client.api";
+    import type * as $clientApi from "@osdk/client.api";
+    import type {
+      ObjectOrInterfacePropertyKeysFrom2 as $ObjectOrInterfacePropertyKeysFrom2, 
+      ObjectTypeLinkDefinition as $ObjectTypeLinkDefinition,
+      ObjectTypeDefinition as $ObjectTypeDefinition,
+      InterfaceDefinition as $InterfaceDefinition,
+    } from "@osdk/api";
+
+    
+
+        ${Object.keys(definition.links).length === 0 ? `export type ${osdkObjectLinksIdentifier} = never;` : `
+        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 ${definition.apiName}: ${objectDefIdentifier} = {
+    export const ${interfaceDef.shortApiName}: ${interfaceDef.shortApiName}.Definition = {
       osdkMetadata: $osdkMetadata,
+      objectSet: undefined as any,
+      props: undefined as any,
+      strictProps: undefined as any,
       ${stringify(definition, {
-    osdkMetadata: () => void 0
+    osdkMetadata: () => void 0,
+    properties: (properties) => `{
+        ${stringify(properties, {
+      "*": (propertyDefinition, _, key) => [`"${maybeStripNamespace2(key)}"`, _(propertyDefinition)]
+    })}
+      }`
   })}
       
     };`;
 }
-var ExpectedOsdkVersion = "0.21.0";
-async function generateOntologyMetadataFile(ontology, userAgent, fs2, outDir) {
-  fs2.writeFile(path16__default.join(outDir, "OntologyMetadata.ts"), await formatTs(`
-      import { OntologyMetadata as OM } from "@osdk/api";
-
-      export type $ExpectedClientVersion = "${ExpectedOsdkVersion}";
-      export const $osdkMetadata = { extraUserAgent: "${userAgent}" };
-
-      export interface OntologyMetadata extends OM<$ExpectedClientVersion> {};
-
-      export const OntologyMetadata: OntologyMetadata = {
-        expectsClientVersion: "${ExpectedOsdkVersion}",
-        ontologyRid: "${ontology.ontology.rid}",
-        ontologyApiName: "${ontology.ontology.apiName}",
-        userAgent: "${userAgent}",
-      };
-      `));
-}
 
 // src/v2.0/generateClientSdkVersionTwoPointZero.ts
-async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs2, outDir, packageType = "commonjs") {
-  await verifyOutDir(outDir, fs2);
-  const sanitizedOntology = sanitizeMetadata(ontology);
-  const objectNames = Object.keys(sanitizedOntology.objectTypes).sort((a, b) => a.localeCompare(b));
-  const actionNames = Object.keys(sanitizedOntology.actionTypes).sort((a, b) => a.localeCompare(b));
-  const queryNames = Object.keys(sanitizedOntology.queryTypes).sort((a, b) => a.localeCompare(b));
-  const interfaceNames = Object.keys(sanitizedOntology.interfaceTypes ?? {}).sort((a, b) => a.localeCompare(b));
-  const importExt = packageType === "module" ? ".js" : "";
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  fs2.writeFile(path16__default.join(outDir, "index.ts"), await formatTs(`
-        export { Ontology } from "./Ontology${importExt}";
-        export * from "./ontology/actions/index${importExt}";
+async function generateRootIndexTsFile({
+  fs: fs2,
+  outDir,
+  importExt,
+  ontologyApiNamespace
+}) {
+  fs2.writeFile(path16__default.join(outDir, "index.ts"), await formatTs(`${ontologyApiNamespace == null ? `export { $ontologyRid } from "./OntologyMetadata${importExt}";` : ``}
+        export * from "./ontology/actions${importExt}";
         export * from "./ontology/objects${importExt}";
         export * from "./ontology/interfaces${importExt}";
-        export * from "./ontology/queries/index${importExt}";
-    `));
-  await generateOntologyMetadataFile(sanitizedOntology, userAgent, fs2, outDir);
-  await fs2.writeFile(path16__default.join(outDir, "Ontology.ts"), await formatTs(`
-      import type { OntologyDefinition } from "@osdk/api";
-      import * as Actions from "./ontology/actions/index${importExt}";
-      import * as Objects from "./ontology/objects${importExt}";
-      import * as Interfaces from "./ontology/interfaces${importExt}";
-      import * as Queries from "./ontology/queries/index${importExt}";
-      import { OntologyMetadata } from "./OntologyMetadata${importExt}";
-      
-      export interface Ontology extends OntologyDefinition<${stringUnionFrom2(objectNames)}> {
-        metadata: OntologyMetadata,
-        objects: {
-          ${objectNames.map((objectName) => {
-    return `${objectName}: Objects.${objectName}`;
-  }).join(",\n")}
-        },
-        actions: {
-          ${actionNames.map((actionName) => {
-    return `${actionName}: typeof Actions.${actionName}`;
-  }).join(",\n")}
-        },
-        queries: {
-          ${queryNames.map((queryName) => {
-    return `${queryName}: typeof Queries.${queryName}`;
-  }).join(",\n")}
-        },
-        interfaces: {
-          ${interfaceNames.map((objectName) => {
-    return `${objectName}: Interfaces.${objectName}`;
-  }).join(",\n")}
-      }
-    }
-
-      export const Ontology: Ontology = {
-        metadata: OntologyMetadata,
-        objects: {
-          ${objectNames.map((objectName) => {
-    return `${objectName}: Objects.${objectName}`;
-  }).join(",\n")}
-          
-        },
-        actions: {
-          ${actionNames.map((actionName) => {
-    return `${actionName}: Actions.${actionName}`;
-  }).join(",\n")}
-        },
-        queries: {
-          ${queryNames.map((queryName) => {
-    return `${queryName}: Queries.${queryName}`;
-  }).join(",\n")}
-        },
-        interfaces: {
-          ${interfaceNames.map((objectName) => {
-    return `${objectName}: Interfaces.${objectName}`;
-  }).join(",\n")}
-              
-        }
-      };
-
+        export * from "./ontology/queries${importExt}";
     `));
+}
+async function generateEachObjectFile(ctx) {
+  const {
+    fs: fs2,
+    outDir,
+    ontology,
+    importExt
+  } = ctx;
   await fs2.mkdir(path16__default.join(outDir, "ontology", "objects"), {
     recursive: true
   });
-  for (const name of objectNames) {
-    const obj = ontology.objectTypes[name];
-    await fs2.writeFile(path16__default.join(outDir, "ontology", `objects`, `${name}.ts`), await formatTs(`
-        import type { ObjectTypeDefinition, VersionBound, ObjectTypeLinkDefinition, PropertyDef } from "@osdk/api";
-        import { Osdk } from "@osdk/client.api";
+  for (const obj of Object.values(ontology.objectTypes)) {
+    const relPath = path16__default.join(".", "ontology", `objects`, `${obj.shortApiName}.ts`);
+    const outFilePath = path16__default.join(outDir, relPath);
+    await fs2.writeFile(outFilePath, await formatTs(`
+        import type {  VersionBound as $VersionBound, PropertyDef as $PropertyDef } from "@osdk/api";
+        import type { Osdk } from "@osdk/client.api";
         import { $osdkMetadata } from "../../OntologyMetadata${importExt}";
         import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
-
-        ${wireObjectTypeV2ToSdkObjectConst(obj, importExt, true)}
+        ${wireObjectTypeV2ToSdkObjectConstV2(obj.og, ctx, relPath)}
       `));
   }
-  await generateOntologyInterfaces(fs2, outDir, interfaceNames, ontology, importExt);
+}
+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 = path16__default.join(outDir, "ontology", "actions");
   await fs2.mkdir(actionsDir, {
     recursive: true
   });
-  await generatePerActionDataFiles(sanitizedOntology, fs2, actionsDir, importExt, true);
+  await generatePerActionDataFiles(ctx);
   await fs2.writeFile(path16__default.join(outDir, "ontology", "objects.ts"), await formatTs(`
-    ${Object.keys(ontology.objectTypes).sort((a, b) => a.localeCompare(b)).map((apiName) => `export * from "./objects/${apiName}${importExt}";`).join("\n")}
+    ${Object.values(enhancedOntology.objectTypes).map((objType) => `export * from "./objects/${objType.shortApiName}${importExt}";`).join("\n")}
     ${Object.keys(ontology.objectTypes).length === 0 ? "export {};" : ""}
     `));
-  const queriesDir = path16__default.join(outDir, "ontology", "queries");
-  await fs2.mkdir(queriesDir, {
-    recursive: true
-  });
-  await generatePerQueryDataFiles(sanitizedOntology, fs2, queriesDir, importExt, true);
-}
-function stringUnionFrom2(values) {
-  if (values.length === 0) {
-    return "never";
-  } else {
-    return values.map((v) => `"${v}"`).join("|");
-  }
+  await generatePerQueryDataFilesV2(ctx);
 }
-async function generateOntologyInterfaces(fs2, outDir, interfaceNames, ontology, importExt) {
+async function generateOntologyInterfaces({
+  fs: fs2,
+  outDir,
+  ontology,
+  importExt
+}) {
   const interfacesDir = path16__default.join(outDir, "ontology", "interfaces");
   await fs2.mkdir(interfacesDir, {
     recursive: true
   });
-  for (const name of interfaceNames) {
-    const obj = ontology.interfaceTypes[name];
-    await fs2.writeFile(path16__default.join(interfacesDir, `${name}.ts`), await formatTs(`
+  for (const obj of Object.values(ontology.interfaceTypes)) {
+    await fs2.writeFile(path16__default.join(interfacesDir, `${obj.shortApiName}.ts`), await formatTs(`
     
-      import type { InterfaceDefinition, PropertyDef, VersionBound } from "@osdk/api";
+      import type { PropertyDef as $PropertyDef, VersionBound as $VersionBound } from "@osdk/api";
       import { $osdkMetadata, $expectedClientVersion } from "../../OntologyMetadata${importExt}";
       import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
-
       ${__UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(obj, ontology, true)}
     `));
   }
   await fs2.writeFile(interfacesDir + ".ts", await formatTs(`
-    ${Object.keys(ontology.interfaceTypes ?? {}).map((apiName) => `export * from "./interfaces/${apiName}${importExt}";`).join("\n")}
-    ${Object.keys(ontology.interfaceTypes ?? {}).length === 0 ? "export {}" : ""}
+    ${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) {
+async function generateClientSdkPackage(packageName, packageVersion, sdkVersion, baseOutDir, ontology, minimalFs, dependencyVersions, cliVersion, ontologyApiNamespace, apiNamespacePackageMap) {
   if (!packageName) throw new Error("Package name is require");
   for (const packageType of ["module", "commonjs"]) {
     const outDir = path16.join(baseOutDir, "dist", packageType);
-    await (sdkVersion === "1.1" ? generateClientSdkVersionOneDotOne : sdkVersion === "2.0" ? generateClientSdkVersionTwoPointZero : void 0)(ontology, `typescript-sdk/${packageVersion} osdk-cli/${cliVersion}`, minimalFs, outDir, packageType);
+    await (sdkVersion === "1.1" ? generateClientSdkVersionOneDotOne : sdkVersion === "2.0" ? generateClientSdkVersionTwoPointZero : void 0)(ontology, `typescript-sdk/${packageVersion} osdk-cli/${cliVersion}`, minimalFs, outDir, packageType, ontologyApiNamespace, apiNamespacePackageMap);
     await fs.promises.mkdir(outDir, {
       recursive: true
     });