@osdk/generator 1.14.0-beta.3 → 2.0.0-beta.10

package/build/browser/index.js

@@ -1,9 +1,8 @@
 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 * as path5 from 'path';
+import path5__default from 'path';
+import { wireQueryTypeV2ToSdkQueryDefinitionNoParams, wireQueryDataTypeToQueryDataTypeDefinition, wireQueryParameterV2ToQueryParameterDefinition, __UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition, wireObjectTypeFullMetadataToSdkObjectTypeDefinition } from '@osdk/generator-converters';
 import { format } from 'prettier';
-import organizeImports from 'prettier-plugin-organize-imports';
 import fastDeepEqual from 'fast-deep-equal';
 import invariant from 'tiny-invariant';
 
@@ -29,7 +28,7 @@ var AbstractImportable = class {
   }
   getImportPathRelTo = (filePath) => {
     if (this.importPath.startsWith(".")) {
-      const result = path16.relative(path16.dirname(filePath), this.importPath);
+      const result = path5.relative(path5.dirname(filePath), this.importPath);
       if (result.startsWith(".")) {
         return result;
       } else {
@@ -41,9 +40,9 @@ var AbstractImportable = class {
   };
 };
 var EnhancedBase = class extends AbstractImportable {
-  constructor(common, og, fullApiName, basePath) {
+  constructor(common, raw, fullApiName, basePath) {
     super(common, fullApiName, basePath);
-    this.og = og;
+    this.raw = raw;
     if (!this.isLocal && !this.sourcePackage) {
       throw new Error(`Expected { ns:'${this.apiNamespace}', shortName: '${this.shortApiName}'} to be in namespace '${common.ontologyApiNamespace}' or in a provided package mapping`);
     }
@@ -57,18 +56,18 @@ function extractNamespace(fqApiName) {
 
 // src/GenerateContext/EnhancedAction.ts
 var EnhancedAction = class extends EnhancedBase {
-  constructor(common, og) {
-    super(common, og, og.apiName, "./ontology/actions");
-    this.og = og;
+  constructor(common, raw) {
+    super(common, raw, raw.apiName, "./ontology/actions");
+    this.raw = raw;
   }
   get description() {
-    return this.og.description;
+    return this.raw.description;
   }
   get parameters() {
-    return this.og.parameters;
+    return this.raw.parameters;
   }
   get operations() {
-    return this.og.operations;
+    return this.raw.operations;
   }
   get paramsIdentifier() {
     return `${this.shortApiName}.Params`;
@@ -88,9 +87,9 @@ function deleteUndefineds(obj) {
 
 // src/GenerateContext/EnhancedInterfaceType.ts
 var EnhancedInterfaceType = class extends EnhancedBase {
-  constructor(common, og) {
-    super(common, og, og.apiName, "./ontology/interfaces");
-    this.og = og;
+  constructor(common, raw) {
+    super(common, raw, raw.apiName, "./ontology/interfaces");
+    this.raw = raw;
   }
   getDefinitionIdentifier(v2) {
     return v2 ? this.shortApiName : `${this.shortApiName}Def`;
@@ -99,16 +98,16 @@ var EnhancedInterfaceType = class extends EnhancedBase {
     return this.getDefinitionIdentifier(v2);
   }
   get properties() {
-    return this.og.properties;
+    return this.raw.properties;
   }
   getCleanedUpDefinition(v2) {
-    return deleteUndefineds(__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(this.og, v2));
+    return deleteUndefineds(__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(this.raw, v2));
   }
 };
 var EnhancedObjectType = class extends EnhancedBase {
-  constructor(common, og) {
-    super(common, og, og.objectType.apiName, "./ontology/objects");
-    this.og = og;
+  constructor(common, raw) {
+    super(common, raw, raw.objectType.apiName, "./ontology/objects");
+    this.raw = raw;
   }
   getDefinitionIdentifier(v2) {
     return v2 ? `${this.shortApiName}` : `${this.shortApiName}Def`;
@@ -117,24 +116,24 @@ var EnhancedObjectType = class extends EnhancedBase {
     return this.getDefinitionIdentifier(v2);
   }
   getCleanedUpDefinition(v2) {
-    return deleteUndefineds(wireObjectTypeFullMetadataToSdkObjectTypeDefinition(this.og, v2));
+    return deleteUndefineds(wireObjectTypeFullMetadataToSdkObjectTypeDefinition(this.raw, v2));
   }
 };
 
 // src/GenerateContext/EnhancedQuery.ts
 var EnhancedQuery = class extends EnhancedBase {
-  constructor(common, og) {
-    super(common, og, og.apiName, "./ontology/queries");
-    this.og = og;
+  constructor(common, raw) {
+    super(common, raw, raw.apiName, "./ontology/queries");
+    this.raw = raw;
   }
   get description() {
-    return this.og.description;
+    return this.raw.description;
   }
   get parameters() {
-    return this.og.parameters;
+    return this.raw.parameters;
   }
   get output() {
-    return this.og.output;
+    return this.raw.output;
   }
   get paramsIdentifier() {
     return `${this.shortApiName}.Parameters`;
@@ -149,9 +148,9 @@ var EnhancedQuery = class extends EnhancedBase {
 
 // src/GenerateContext/EnhancedSharedPropertyType.ts
 var EnhancedSharedPropertyType = class extends EnhancedBase {
-  constructor(common, og) {
-    super(common, og, og.apiName, "./ontology/interfaces");
-    this.og = og;
+  constructor(common, raw) {
+    super(common, raw, raw.apiName, "./ontology/interfaces");
+    this.raw = raw;
   }
 };
 
@@ -176,20 +175,21 @@ var ForeignType = class extends AbstractImportable {
 
 // src/GenerateContext/EnhancedOntologyDefinition.ts
 var EnhancedOntologyDefinition = class {
-  constructor(original, ontologyApiNamespace, apiNamespacePackageMap, importExt) {
+  #foreignTypes = {};
+  constructor(raw, 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);
+    this.raw = raw;
+    this.ontology = raw.ontology;
+    this.objectTypes = remap(raw.objectTypes, this.common, EnhancedObjectType);
+    this.actionTypes = remap(raw.actionTypes, this.common, EnhancedAction);
+    this.queryTypes = remap(raw.queryTypes, this.common, EnhancedQuery);
+    this.interfaceTypes = remap(raw.interfaceTypes, this.common, EnhancedInterfaceType);
+    this.sharedPropertyTypes = remap(raw.sharedPropertyTypes, this.common, EnhancedSharedPropertyType);
   }
   #createRequireType = (type) => {
     return (fullApiName, localOnly) => {
@@ -202,7 +202,9 @@ var EnhancedOntologyDefinition = class {
         if (!this.common.apiNamespacePackageMap.has(apiNamespace)) {
           throw new Error(`Unable to find ${type}: Unknown namespace '${apiNamespace}'`);
         }
-        return new ForeignType(this.common, type, apiNamespace, shortApiName);
+        const ret2 = this.#foreignTypes[fullApiName] ?? new ForeignType(this.common, type, apiNamespace, shortApiName);
+        this.#foreignTypes[fullApiName] = ret2;
+        return ret2;
       }
       return ret;
     };
@@ -239,6 +241,21 @@ function sanitizeMetadata(ontology) {
 function camelize(name) {
   return name.replace(/-./g, (segment) => segment[1].toUpperCase());
 }
+function formatTs(contents) {
+  try {
+    return format(contents, {
+      parser: "typescript",
+      singleQuote: true,
+      trailingComma: "all",
+      tabWidth: 2,
+      printWidth: 120
+    });
+  } catch (e) {
+    console.error("Failed to format file", e);
+    console.log(contents);
+    return contents;
+  }
+}
 
 // src/util/verifyOutDir.ts
 async function verifyOutDir(outDir, fs2) {
@@ -253,6 +270,31 @@ async function verifyOutDir(outDir, fs2) {
     }
   }
 }
+var ExpectedOsdkVersion = "2.0.0";
+async function generateOntologyMetadataFile({
+  fs: fs2,
+  outDir,
+  ontology,
+  ontologyApiNamespace
+}, userAgent) {
+  fs2.writeFile(path5__default.join(outDir, "OntologyMetadata.ts"), await formatTs(`
+      export type $ExpectedClientVersion = "${ExpectedOsdkVersion}";
+      export const $osdkMetadata = { extraUserAgent: "${userAgent}" };
+      ${ontologyApiNamespace == null ? `
+        export const $ontologyRid = "${ontology.ontology.rid}";
+        ` : ""}
+      `));
+}
+
+// src/shared/getObjectImports.ts
+function getObjectImports(objects, curApiName, currentFilePath, v2) {
+  return Array.from(objects).filter((obj) => obj.fullApiName !== curApiName).map((obj) => {
+    const defId = obj.getDefinitionIdentifier(v2);
+    const importedId = obj.getImportedDefinitionIdentifier(v2);
+    const nameOrAlias = defId === importedId ? defId : `${defId} as ${importedId}`;
+    return `import type { ${nameOrAlias} } from "${obj.getImportPathRelTo("./" + currentFilePath)}";`;
+  }).join("\n");
+}
 
 // src/shared/getEditedEntities.ts
 function getModifiedEntityTypes(action) {
@@ -273,1558 +315,114 @@ function getModifiedEntityTypes(action) {
     modifiedObjects
   };
 }
-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;
-  }
-}
-
-// src/v1.1/generateActions.ts
-async function generateActions(ontology, fs2, outDir, importExt = "") {
-  const importedObjects = /* @__PURE__ */ new Set();
-  let actionSignatures = [];
-  for (const action of Object.values(ontology.actionTypes)) {
-    const entries = Object.entries(action.parameters);
-    const modifiedEntityTypes = getModifiedEntityTypes(action);
-    const addedObjects = Array.from(modifiedEntityTypes.addedObjects);
-    const modifiedObjects = Array.from(modifiedEntityTypes.modifiedObjects);
-    addedObjects.forEach(importedObjects.add, importedObjects);
-    modifiedObjects.forEach(importedObjects.add, importedObjects);
-    let jsDocBlock = ["/**"];
-    if (action.description) {
-      jsDocBlock.push(`* ${action.description}`);
-    }
-    let parameterBlock = "";
-    if (entries.length > 0) {
-      parameterBlock = `params: { 
-`;
-      for (const [parameterName, parameterData] of entries) {
-        parameterBlock += `"${parameterName}"`;
-        parameterBlock += parameterData.required ? ": " : "?: ";
-        const typeScriptType = getTypeScriptTypeFromDataType(parameterData.dataType, importedObjects);
-        parameterBlock += `${typeScriptType};
-`;
-        jsDocBlock.push(`* @param {${typeScriptType}} params.${parameterName}`);
-      }
-      parameterBlock += "}, ";
-    }
-    jsDocBlock.push(`*/`);
-    actionSignatures.push(`
-      ${jsDocBlock.join("\n")}
-      ${action.apiName}<O extends ActionExecutionOptions>(${parameterBlock}options?: O): 
-        Promise<Result<ActionResponseFromOptions<O, Edits<${addedObjects.length > 0 ? addedObjects.join(" | ") : "void"}, ${modifiedObjects.length > 0 ? modifiedObjects.join(" | ") : "void"}>>, ActionError>>;`);
-  }
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__default.join(outDir, "Actions.ts"), await formatTs(`
-    import type { ObjectSet, LocalDate, Timestamp, Attachment, Edits, ActionExecutionOptions, ActionError, Result, ActionResponseFromOptions } from "@osdk/legacy-client";
-    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
-    export interface Actions {
-    ${actionSignatures.join("\n")}
-    }
-  `));
-}
-function getTypeScriptTypeFromDataType(actionParameter, importedObjects) {
-  switch (actionParameter.type) {
-    case "objectSet": {
-      const objectType = actionParameter.objectTypeApiName;
-      importedObjects.add(objectType);
-      return `ObjectSet<${objectType}>`;
-    }
-    case "object": {
-      const objectType = actionParameter.objectTypeApiName;
-      importedObjects.add(objectType);
-      return `${objectType} | ${objectType}["__primaryKey"]`;
-    }
-    case "array":
-      return `Array<${getTypeScriptTypeFromDataType(actionParameter.subType, importedObjects)}>`;
-    case "string":
-      return `string`;
-    case "boolean":
-      return `boolean`;
-    case "attachment":
-      return `Attachment`;
-    case "date":
-      return `LocalDate`;
-    case "double":
-    case "integer":
-    case "long":
-      return `number`;
-    case "timestamp":
-      return `Timestamp`;
-    case "marking":
-      return "string";
-    default:
-      throw new Error(`Unsupported action parameter type: ${actionParameter}`);
-  }
-}
-
-// src/v1.1/backcompat/util/reexportConsts.ts
-function reexportConsts(typesToExport) {
-  return `
-          import  { ${typesToExport.map((q) => `${q} as OG_${q}`).join(", ")}} from "@osdk/legacy-client";
-      
-          ${typesToExport.map((q) => `
-      /** @deprecated submodule imports aren't public api **/
-              export const ${q} = OG_${q};
-          `).join("\n\n")}
-      `;
-}
-
-// src/v1.1/backcompat/internal-foundry-oauth-dist/generateConfidentialClientDir.ts
-async function generateConfidentialClientDir(fs2, oauthDistDir, importExt = "") {
-  const confidentialClientDistDir = path16__default.join(oauthDistDir, "ConfidentialClient");
-  await fs2.mkdir(confidentialClientDistDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__default.join(confidentialClientDistDir, "index.ts"), await formatTs(`
-    export * from "./ConfidentialClientAuth${importExt}";
-  `));
-  await fs2.writeFile(path16__default.join(confidentialClientDistDir, "ConfidentialClientAuth.ts"), await formatTs(`
-        ${reexportConsts(["ConfidentialClientAuth"])}
-    `));
-}
-async function generatePublicClientDir(fs2, oauthDistDir, importExt = "") {
-  const publicClientDistDir = path16__default.join(oauthDistDir, "PublicClient");
-  await fs2.mkdir(publicClientDistDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__default.join(publicClientDistDir, "index.ts"), await formatTs(`
-    export * from "./PublicClientAuth${importExt}";
-  `));
-  await fs2.writeFile(path16__default.join(publicClientDistDir, "PublicClientAuth.ts"), await formatTs(`
-        ${reexportConsts(["PublicClientAuth"])}
-    `));
-}
-async function generateUserTokenDir(fs2, oauthDistDir, importExt = "") {
-  const userTokenDistDir = path16__default.join(oauthDistDir, "UserToken");
-  await fs2.mkdir(userTokenDistDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__default.join(userTokenDistDir, "index.ts"), await formatTs(`
-    export * from "./UserTokenAuth${importExt}";
-  `));
-  await fs2.writeFile(path16__default.join(userTokenDistDir, "UserTokenAuth.ts"), await formatTs(`
-        ${reexportConsts(["UserTokenAuth"])}
-    `));
-}
-
-// src/v1.1/backcompat/util/reexportTypes.ts
-function reexportTypes(typesToExport, genericArgsLeft = "", genericArgsRight = cleanup(genericArgsLeft)) {
-  return `
-    import type { ${typesToExport.map((q) => `${q} as OG_${q}`).join(", ")}} from "@osdk/legacy-client";
-    
-        ${typesToExport.map((q) => `
-      /** @deprecated submodule imports aren't public api **/
-      export type ${q}${genericArgsLeft} = OG_${q}${genericArgsRight};
-    `).join("\n\n")}
-    `;
-}
-var captureInBracketsRegex = /<(.*?)>/;
-var captureGenericParamNameRegex = /^\s?(.+?)( extends .*?)?( = .*?)?\s?$/;
-function cleanup(s) {
-  if (s.length === 0) return "";
-  const genericParameterNames = captureInBracketsRegex.exec(s)?.[1]?.split(",")?.map((a) => {
-    return captureGenericParamNameRegex.exec(a)?.[1] ?? a;
-  });
-  return `<${genericParameterNames?.join(",")}>`;
-}
-
-// src/v1.1/backcompat/generateOAuthDistDir.ts
-async function generateOAuthClientDistDir(outDir, fs2, importExt = "") {
-  const oauthDistDir = path16.join(outDir, "internal", "@foundry", "oauth-client", "dist");
-  await fs2.mkdir(oauthDistDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16.join(oauthDistDir, "index.ts"), await formatTs(`
-    export * from "./Auth${importExt}";
-    export * from "./ConfidentialClient/index${importExt}";
-    export * from "./OAuthClient${importExt}";
-    export * from "./PublicClient/index${importExt}";
-    export * from "./Token${importExt}";
-    export * from "./UserToken/index${importExt}";
-`));
-  await fs2.writeFile(path16.join(oauthDistDir, "Auth.ts"), await formatTs(reexportTypes(["Auth"])));
-  await fs2.writeFile(path16.join(oauthDistDir, "Token.ts"), await formatTs(reexportTypes(["Token", "TokenValue"])));
-  await fs2.writeFile(path16.join(oauthDistDir, "OAuthClient.ts"), await formatTs(reexportTypes(["AuthSubscription", "UnsubscribeFunction", "SignInResponse", "RefreshResponse", "SignOutResponse"])));
-  await fs2.writeFile(path16.join(oauthDistDir, "OAuthToken.ts"), await formatTs(reexportConsts(["OAuthToken"])));
-  await fs2.writeFile(path16.join(oauthDistDir, "Auth.ts"), await formatTs(reexportTypes(["Auth"])));
-  await generateConfidentialClientDir(fs2, oauthDistDir, importExt);
-  await generatePublicClientDir(fs2, oauthDistDir, importExt);
-  await generateUserTokenDir(fs2, oauthDistDir, importExt);
-}
-async function generateAggregationsAggregations(fs2, aggregationsDir) {
-  await fs2.writeFile(path16.join(aggregationsDir, "Aggregations.ts"), await formatTs(`
-      import { LocalDate, Timestamp } from "@osdk/legacy-client";
-      ` + reexportTypes(["Double", "Rangeable", "MetricValue", "Date", "BucketKey", "BucketValue", "TimeUnit", "BucketGroup", "Metrics", "AggregatableProperties", "AggregationClause"]) + reexportTypes(["Range"], "<T extends Rangeable>", "<T>") + reexportTypes(["BaseGroupBy"], "<_T extends BucketValue = BucketValue>") + reexportTypes(["Duration"], "<_T extends Timestamp | LocalDate = Timestamp | LocalDate>") + reexportTypes(["AggregatableProperty", "MultipleAggregationsOperations"], "<_T extends MetricValue = MetricValue>") + reexportTypes(["AggregationGroup"], "<TMetrics extends Metrics | MetricValue, TBucketGroup extends BucketGroup>") + reexportTypes(["Bucketing"], "<_T extends string , _X extends BucketValue>") + reexportTypes(["AggregationResult"], "<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue>") + reexportTypes(["BaseBucketing"], "<TBucketKey extends BucketKey, TBucketValue extends BucketValue, Kind extends string>") + reexportTypes(["ExactValueBucketing", "InternalBucketing"], `<TBucketKey extends BucketKey, TBucketValue extends BucketValue>`) + reexportTypes(["RangeBucketing", "FixedWidthBucketing"], `<TBucketKey extends BucketKey, TBucketValue extends Range<Rangeable>>`) + reexportTypes(["DurationBucketing"], `<TBucketKey extends BucketKey, TBucketValue extends Date>`) + reexportTypes(["InternalBucketingVisitor"], "<TBucketKey extends BucketKey, T extends BucketValue, R>") + reexportTypes(["AggregationBuilderResult"], "<T, TMultipleAggregationProperties>") + reexportTypes(["AggregatablePropertiesForResult", "AggregatablePropertyNamesForResult"], "<TAggregatableProperties, TResult extends MetricValue>") + reexportConsts(["assertBucketingInternal", "visitInternalBucketing"]) + reexportTypes(["AggregatableObjectSetStep"], "<TAggregatableProperties, TMultipleAggregationProperties, TBucketableProperties, TBucketGroup extends BucketGroup = {}>") + reexportTypes(["GroupedTerminalAggregationOperations"], "<TAggregatableProperties, TMultipleAggregationProperties, TBucketGroup extends BucketGroup = {}>")));
-}
-async function generateGroupBy(fs2, aggregationsDir, importExt = "") {
-  await fs2.mkdir(path16.join(aggregationsDir, "groupBy"), {
-    recursive: true
-  });
-  const groupBys = ["BooleanGroupBy", "LocalDateGroupBy", "NumericGroupBy", "StringGroupBy", "TimestampGroupBy"];
-  const reexportFiles = [...groupBys, "GroupKeyType"];
-  for (const key of reexportFiles) {
-    await fs2.writeFile(path16.join(aggregationsDir, "groupBy", `${key}.ts`), await formatTs(`export {${key}} from "./index${importExt}";`));
-  }
-  await fs2.writeFile(path16.join(aggregationsDir, "groupBy", "index.ts"), await formatTs(`import { Bucketing, BucketKey, Duration, Range, Rangeable } from "../Aggregations${importExt}";` + reexportConsts(groupBys) + reexportTypes(groupBys, "<T extends BucketKey>") + `export {GroupKeyType} from "@osdk/legacy-client";
-          `));
-}
-async function generateMetrics(fs2, aggregationsDir, importExt = "") {
-  const metricsDir = path16.join(aggregationsDir, "metrics");
-  await fs2.mkdir(metricsDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16.join(metricsDir, "metrics.ts"), await formatTs(`export {MetricValueType} from "@osdk/legacy-client";`));
-  await fs2.writeFile(path16.join(metricsDir, "ApproximateDistinctCountAggregatableProperty.ts"), await formatTs(reexportConsts(["ApproximateDistinctCountAggregatableProperty"]) + reexportTypes(["ApproximateDistinctCountAggregatableProperty"])));
-  await fs2.writeFile(path16.join(metricsDir, "MultipleAggregatableProperty.ts"), await formatTs(`
-        import { Double, MetricValue, MultipleAggregationsOperations } from "../Aggregations${importExt}";
-        import { MetricValueType } from "./metrics/index${importExt}";
-      ` + reexportConsts(["MultipleAggregatableProperty"]) + reexportTypes(["MultipleAggregatableProperty"], "<TResult extends MetricValue = Double>")));
-  for (const typeName of ["DefaultAggregatableProperty", "LocalDatePropertyMetric", "NumericPropertyMetric", "TimestampPropertyMetric"]) {
-    await fs2.writeFile(path16.join(metricsDir, `${typeName}.ts`), await formatTs(`
-          import { MultipleAggregatableProperty } from "./MultipleAggregatableProperty${importExt}";
-        ` + reexportConsts([typeName])));
-  }
-  await fs2.writeFile(path16.join(metricsDir, "index.ts"), await formatTs(`
-      export * from "./ApproximateDistinctCountAggregatableProperty${importExt}";
-      export * from "./DefaultAggregatableProperty${importExt}";
-      export * from "./LocalDatePropertyMetric${importExt}";
-      export * from "./metrics${importExt}";
-      export * from "./MultipleAggregatableProperty${importExt}";
-      export * from "./NumericPropertyMetric${importExt}";
-      export * from "./TimestampPropertyMetric${importExt}";
-      `));
-}
-
-// src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateAggregationsDir.ts
-async function generateAggregationsDir(fs2, runtimeDistDir, importExt = "") {
-  const aggregationsDir = path16.join(runtimeDistDir, "aggregations");
-  await fs2.mkdir(aggregationsDir, {
-    recursive: true
-  });
-  await generateGroupBy(fs2, aggregationsDir, importExt);
-  await generateAggregationsAggregations(fs2, aggregationsDir);
-  await generateMetrics(fs2, aggregationsDir, importExt);
-  await fs2.writeFile(path16.join(aggregationsDir, "index.ts"), await formatTs(`
-    ${""}
-    ${""}
-    
-    export * from "./Aggregations${importExt}";
-    export * from "./ComputeStep${importExt}";
-    export * from "./CountOperation${importExt}";
-    export * from "./groupBy/index${importExt}";
-    export * from "./internalAggregationRequest${importExt}";
-    export * from "./metrics/index${importExt}";
-  `));
-  await fs2.writeFile(path16.join(aggregationsDir, "ComputeStep.ts"), await formatTs(`
-      import { ObjectSetDefinition } from "../baseTypes/index${importExt}";
-      import { FoundryClientOptions } from "../client/${importExt}";
-      import { AggregateObjectsError, OntologyMetadata, Result } from "../ontologyProvider/index${importExt}";
-      import { AggregationClause, AggregationResult, BucketGroup, BucketValue, InternalBucketing, Metrics, MetricValue } from "./Aggregations${importExt}";
-      ` + reexportConsts(["ComputeStep"]) + reexportTypes(["ComputeStep"], "<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue> ") + reexportTypes(["AggregationComputeStep"], "<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue>") + `
-    
-    `));
-  await fs2.writeFile(path16.join(aggregationsDir, "CountOperation.ts"), await formatTs(`` + reexportConsts(["CountOperation", "isCountOperation"]) + reexportTypes(["CountOperation"])));
-  await fs2.writeFile(path16.join(aggregationsDir, "internalAggregationRequest.ts"), await formatTs(reexportTypes(["InternalAggregationRequest"])));
-}
-async function generateAttachmentsDir(attachmentsDir, fs2, importExt = "") {
-  await fs2.mkdir(attachmentsDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__default.join(attachmentsDir, "index.ts"), await formatTs(`export * from "./Attachment${importExt}";
-       export * from "./Attachments${importExt}";
-    `));
-  await fs2.writeFile(path16__default.join(attachmentsDir, "Attachment.ts"), await formatTs(reexportTypes(["Attachment", "AttachmentMetadata"])));
-  await fs2.writeFile(path16__default.join(attachmentsDir, "Attachments.ts"), await formatTs(reexportTypes(["Attachments"])));
-}
-async function generateGeoshapesDir(runtimeDistDir, fs2, importExt = "") {
-  await fs2.mkdir(runtimeDistDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16.join(runtimeDistDir, "index.ts"), await formatTs(`export * from "./Distance${importExt}";
-       export * from "./GeoJson${importExt}";
-       export * from "./GeometryCollection${importExt}";
-       export * from "./GeoPoint${importExt}";
-       export * from "./GeoShape${importExt}";
-       export * from "./LineString${importExt}";
-       export * from "./MultiGeoPoint${importExt}";
-       export * from "./MultiLineString${importExt}";
-       export * from "./MultiPolygon${importExt}";
-       export * from "./Polygon${importExt}";`));
-  await fs2.writeFile(path16.join(runtimeDistDir, "Distance.ts"), await formatTs(`` + reexportConsts(["Distance", "DistanceUnit"]) + reexportTypes(["Distance", "DistanceUnit"])));
-  await fs2.writeFile(path16.join(runtimeDistDir, "GeoJson.ts"), await formatTs(reexportTypes(["GeoJsonPoint", "GeoJsonPolygon", "GeoJsonLineString", "GeoJsonMultiPoint", "GeoJsonMultiPolygon", "GeoJsonMultiLineString", "GeoJsonGeometryCollection", "GeoJsonGeometry", "GeoJson"])));
-  await fs2.writeFile(path16.join(runtimeDistDir, "GeometryCollection.ts"), await formatTs(reexportConsts(["GeometryCollection"])));
-  await fs2.writeFile(path16.join(runtimeDistDir, "GeoPoint.ts"), await formatTs(`` + reexportConsts(["isGeoPoint", "GeoPoint", "mapCoordinatesToGeoPoint"]) + reexportTypes(["GeoHash", "Coordinates", "GeoPoint"])));
-  await fs2.writeFile(path16.join(runtimeDistDir, "GeoShape.ts"), await formatTs(reexportConsts(["GeoShape"]) + reexportTypes(["GeoShape"])));
-  await fs2.writeFile(path16.join(runtimeDistDir, "LineString.ts"), await formatTs(reexportConsts(["LineString"]) + reexportTypes(["LineString"])));
-  await fs2.writeFile(path16.join(runtimeDistDir, "MultiGeoPoint.ts"), await formatTs(reexportConsts(["MultiGeoPoint"]) + reexportTypes(["MultiGeoPoint"])));
-  await fs2.writeFile(path16.join(runtimeDistDir, "MultiLineString.ts"), await formatTs(reexportConsts(["MultiLineString"]) + reexportTypes(["MultiLineString"])));
-  await fs2.writeFile(path16.join(runtimeDistDir, "MultiPolygon.ts"), await formatTs(reexportConsts(["MultiPolygon"]) + reexportTypes(["MultiPolygon"])));
-  await fs2.writeFile(path16.join(runtimeDistDir, "Polygon.ts"), await formatTs(reexportConsts(["Polygon"]) + reexportTypes(["LinearRing", "Polygon"])));
-}
-async function generateObjectSetDir(objectSetDir, fs2, importExt = "") {
-  await fs2.mkdir(objectSetDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__default.join(objectSetDir, "index.ts"), await formatTs(`
-    export * from "./ObjectSetDefinition${importExt}";
-    export * from "./OntologyObjectSet${importExt}";
-    `));
-  await fs2.writeFile(path16__default.join(objectSetDir, "ObjectSetDefinition.ts"), await formatTs(reexportTypes(["BaseObjectSetDefinition", "ReferenceObjectSetDefinition", "StaticObjectSetDefinition", "IntersectObjectSetDefinition", "SubtractObjectSetDefinition", "SearchAroundObjectSetDefinition", "FilterObjectSetDefinition", "ObjectSetDefinition"])));
-  await fs2.writeFile(path16__default.join(objectSetDir, "OntologyObjectSet.ts"), await formatTs(reexportTypes(["OntologyObjectSet"])));
-}
-async function generateSharedObjectCodeDir(sharedObjectCodeDir, fs2, importExt = "") {
-  await fs2.mkdir(sharedObjectCodeDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__default.join(sharedObjectCodeDir, "index.ts"), await formatTs(`
-    export * from "./FilteredPropertiesTerminalOperations${importExt}";
-    `));
-  await fs2.writeFile(path16__default.join(sharedObjectCodeDir, "FilteredPropertiesTerminalOperations.ts"), await formatTs(`import { OntologyObject } from "../OntologyObject${importExt}` + reexportTypes(["FilteredPropertiesTerminalOperations", "FilteredPropertiesTerminalOperationsWithGet"], "<T extends OntologyObject, V extends Array<keyof T>>")));
-}
-async function generateTimeSeriesDir(timeseriesDir, fs2, importExt = "") {
-  await fs2.mkdir(timeseriesDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16.join(timeseriesDir, "index.ts"), await formatTs(`
-    export * from "./TimeSeries${importExt}";
-    export * from "./TimeSeriesDuration${importExt}";
-    export * from "./TimeSeriesPoint${importExt}";
-    ${""}
-    export * from "./TimeSeriesQuery${importExt}";
-    export * from "./TimeSeriesTerminalOperations${importExt}";
-  `));
-  await fs2.writeFile(path16.join(timeseriesDir, "TimeSeries.ts"), await formatTs(reexportTypes(["TimeSeries"], `<T extends number | string>`)));
-  await fs2.writeFile(path16.join(timeseriesDir, "TimeSeriesDuration.ts"), await formatTs(reexportTypes([`WhenUnit`, `DurationUnit`, `TimeSeriesDuration`])));
-  await fs2.writeFile(path16.join(timeseriesDir, "TimeSeriesPoint.ts"), await formatTs(reexportTypes(["TimeSeriesPoint"], `<T extends number | string>`)));
-  await fs2.writeFile(path16.join(timeseriesDir, "TimeSeriesQuery.ts"), await formatTs(reexportTypes(["TimeSeriesQuery"], `<T extends number | string>`)));
-  await fs2.writeFile(path16.join(timeseriesDir, "TimeSeriesTerminalOperations.ts"), await formatTs(reexportTypes(["TimeSeriesTerminalOperations", "TimeSeriesIterator"], `<T extends number | string>`)));
-}
-
-// src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateBaseTypesDir.ts
-async function generateBaseTypesDir(runtimeDistDir, fs2, importExt = "") {
-  const baseTypesDir = path16.join(runtimeDistDir, "baseTypes");
-  await fs2.mkdir(baseTypesDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16.join(baseTypesDir, "index.ts"), await formatTs(`export * from "./ActionType${importExt}";
-      export * from "./attachments/index${importExt}";
-      export * from "./geoshapes/index${importExt}";
-      export * from "./links${importExt}";
-      export * from "./localDate${importExt}";
-      export * from "./objectset/index${importExt}";
-      export * from "./ObjectType${importExt}";
-      export * from "./OntologyObject${importExt}";
-      export * from "./Queries${importExt}";
-      export * from "./timeseries/index${importExt}";
-      export * from "./timestamp${importExt}";`));
-  const geoshapesDir = path16.join(baseTypesDir, "geoshapes");
-  await generateGeoshapesDir(geoshapesDir, fs2, importExt);
-  const timeseriesDir = path16.join(baseTypesDir, "timeseries");
-  await generateTimeSeriesDir(timeseriesDir, fs2, importExt);
-  const attachmentsDir = path16.join(baseTypesDir, "attachments");
-  await generateAttachmentsDir(attachmentsDir, fs2, importExt);
-  const objectSetDir = path16.join(baseTypesDir, "objectset");
-  await generateObjectSetDir(objectSetDir, fs2, importExt);
-  const sharedObjectCodeDir = path16.join(baseTypesDir, "sharedObjectCode");
-  await generateSharedObjectCodeDir(sharedObjectCodeDir, fs2, importExt);
-  await fs2.writeFile(path16.join(baseTypesDir, "ActionType.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject${importExt}";
-      ` + reexportConsts(["ActionExecutionMode", "ReturnEditsMode", "ActionValidationResult"]) + reexportTypes(["ActionExecutionOptions", "ValidationResponse", "BulkEdits"]) + reexportTypes(["CreatedObjectEdits", "ModifiedObjectEdits"], "<T extends OntologyObject>") + reexportTypes(["Edits"], "<TAddedObjects extends OntologyObject | void, TModifiedObjects extends OntologyObject | void>") + reexportTypes(["ActionResponse"], "<TEdits extends Edits<any, any> | undefined = undefined>", "<TEdits>") + reexportTypes(["ActionResponseFromOptions"], "<TOptions extends ActionExecutionOptions | undefined = undefined, TEdits extends Edits<any, any> | undefined = undefined>", "<TOptions, TEdits>")));
-  await fs2.writeFile(path16.join(baseTypesDir, "OntologyObject.ts"), await formatTs(reexportTypes(["OntologyObject"]) + reexportConsts(["isOntologyObject"])));
-  await fs2.writeFile(path16.join(baseTypesDir, "links.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject${importExt}` + reexportTypes(["SingleLink", "MultiLink"], "<T extends OntologyObject = OntologyObject>")));
-  await fs2.writeFile(path16.join(baseTypesDir, "localDate.ts"), await formatTs(reexportConsts(["LocalDate"]) + reexportTypes(["LocalDate"])));
-  await fs2.writeFile(path16.join(baseTypesDir, "timestamp.ts"), await formatTs(reexportConsts(["Timestamp"]) + reexportTypes(["Timestamp"])));
-  await fs2.writeFile(path16.join(baseTypesDir, "Queries.ts"), await formatTs(`import { BucketValue, Range, Rangeable } from "../aggregations/index${importExt}";
-      ` + reexportTypes(["QueryResponse"], "<T>") + reexportTypes(["BaseBucket"], "<K, V>") + reexportTypes(["NestedBucket"], "<TGroupKey, TSegmentKey, TValue extends BucketValue>") + reexportTypes(["TwoDimensionalAggregation"], "<TGroupKey extends QueryBucketKey, TValue extends BucketValue = number>") + reexportTypes(["ThreeDimensionalAggregation"], "<TGroupKey extends QueryBucketKey, TSegmentKey extends QueryBucketKey, TValue extends BucketValue = number>") + reexportTypes(["QueryBucketKey"])));
-  await fs2.writeFile(path16.join(baseTypesDir, "ObjectType.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject${importExt}";` + reexportTypes(["BaseType", "StringType", "IntegerType", "DateType", "BooleanType", "ByteType", "DecimalType", "FloatType", "TimestampType", "ShortType", "LongType", "DoubleType", "GeoPointType", "GeoShapeType", "AttachmentType", "ObjectType", "StructField", "QueryBucketRangeableType", "QueryBucketKeyType", "QueryBucketValueType", "AllValueTypes", "OntologyType", "ObjectTypeProperties", "StructType"]) + reexportTypes(["TimeSeriesType", "ArrayType", "SetType"], "<T extends BaseType>") + reexportTypes(["Property"], "<TType extends OntologyType = OntologyType>") + reexportTypes(["BaseObjectType"], "<TOntologyObject extends OntologyObject = OntologyObject>") + reexportTypes(["ObjectSetType"], "<T extends ObjectType>") + reexportTypes(["RangeType"], "<T extends QueryBucketRangeableType>") + reexportTypes(["TwoDimensionalAggregationType"], "<TGroupKey extends QueryBucketKeyType, TValue extends QueryBucketValueType>") + reexportTypes(["ThreeDimensionalAggregationType"], "<TGroupKey extends QueryBucketKeyType, TSegmentKey extends QueryBucketKeyType, TValue extends QueryBucketValueType>")));
-}
-async function generateClientDir(runtimeDistDir, fs2, importExt = "") {
-  const pagingDir = path16__default.join(runtimeDistDir, "client");
-  await fs2.mkdir(pagingDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__default.join(pagingDir, "index.ts"), await formatTs(`export * from "./clientOptions${importExt}";`));
-  await fs2.writeFile(path16__default.join(pagingDir, "clientOptions.ts"), await formatTs(`import {Auth} from "@osdk/legacy-client";` + reexportTypes(["FoundryClientOptions"], "<TAuth extends Auth = Auth>")));
-}
-async function generateFiltersDir(runtimeDistDir, fs2, importExt = "") {
-  const pagingDir = path16__default.join(runtimeDistDir, "filters");
-  await fs2.mkdir(pagingDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__default.join(pagingDir, "index.ts"), await formatTs(`export * from "./ArrayFilter${importExt}";
-      export * from "./AttachmentFilter${importExt}";
-      export * from "./BooleanFilter${importExt}";
-      export * from "./DateTimeFilters${importExt}";
-      export * from "./Filters${importExt}";
-      export * from "./GeoPointFilter${importExt}";
-      export * from "./GeoShapeFilter${importExt}";
-      export * from "./NumericFilter${importExt}";
-      export * from "./Op${importExt}";
-      export * from "./OrderByOption${importExt}";
-      export * from "./StringFilter${importExt}";`));
-  await fs2.writeFile(path16__default.join(pagingDir, "ArrayFilter.ts"), await formatTs(`import { Attachment, GeoPoint, GeoShape, LocalDate, Timestamp } from "../baseTypes/index${importExt}";` + reexportConsts(["ArrayFilter"]) + reexportTypes(["ArrayFilter"], "<T extends string | number | Timestamp | LocalDate | boolean | GeoShape | GeoPoint | Attachment>")));
-  await fs2.writeFile(path16__default.join(pagingDir, "AttachmentFilter.ts"), await formatTs(reexportConsts(["AttachmentFilter"]) + reexportTypes(["AttachmentFilter"])));
-  await fs2.writeFile(path16__default.join(pagingDir, "BooleanFilter.ts"), await formatTs(reexportConsts(["BooleanFilter"]) + reexportTypes(["BooleanFilter"])));
-  await fs2.writeFile(path16__default.join(pagingDir, "GeoPointFilter.ts"), await formatTs(reexportConsts(["GeoPointFilter"]) + reexportTypes(["GeoPointFilter", "BoundingBox"])));
-  await fs2.writeFile(path16__default.join(pagingDir, "DateTimeFilters.ts"), await formatTs(reexportConsts(["TimestampFilter", "LocalDateFilter"]) + reexportTypes(["TimestampFilter", "LocalDateFilter"])));
-  await fs2.writeFile(path16__default.join(pagingDir, "GeoShapeFilter.ts"), await formatTs(reexportConsts(["GeoShapeFilter"]) + reexportTypes(["GeoShapeFilter"])));
-  await fs2.writeFile(path16__default.join(pagingDir, "NumericFilter.ts"), await formatTs(reexportConsts(["NumericFilter"]) + reexportTypes(["NumericFilter"])));
-  await fs2.writeFile(path16__default.join(pagingDir, "Op.ts"), await formatTs(reexportConsts(["Op"])));
-  await fs2.writeFile(path16__default.join(pagingDir, "OrderByOption.ts"), await formatTs(reexportConsts(["OrderByOption"]) + reexportTypes(["OrderByOption"])));
-  await fs2.writeFile(path16__default.join(pagingDir, "StringFilter.ts"), await formatTs(reexportConsts(["StringFilter"]) + reexportTypes(["StringFilter"])));
-  await fs2.writeFile(path16__default.join(pagingDir, "Filters.ts"), await formatTs(`import { OntologyObject } from "@osdk/legacy-client";` + reexportTypes(["ObjectTypeFilterFunction", "ObjectTypeOrderByFunction"], "<T extends OntologyObject>") + reexportTypes(["BoundingBoxFilter", "DistanceOf", "SearchClause", "LtWhereClause", "GtWhereClause", "LteWhereClause", "GteWhereClause", "EqWhereClause", "IsNullWhereClause", "ContainsWhereClause", "StartsWithWhereClause", "ContainsAllTermsInOrderWhereClause", "ContainsAnyTermWhereClause", "ContainsAllTermsWhereClause", "WithinDistanceOfWhereClause", "WithinBoundingBoxWhereClause", "IntersectsBoundingBoxWhereClause", "DoesNotIntersectBoundingBoxWhereClause", "WithinPolygonWhereClause", "IntersectsPolygonWhereClause", "DoesNotIntersectPolygonWhereClause", "AndWhereClause", "OrWhereClause", "NotWhereClause", "WhereClause", "OrderByClause"]) + reexportTypes(["FilterType"], "<T extends string | number>")));
-}
-async function generateErrors(fs2, ontologyProviderDir) {
-  await fs2.writeFile(path16.join(ontologyProviderDir, "Errors.ts"), await formatTs(reexportTypes(["PermissionDenied", "Unauthorized", "InvalidAggregationRangeValue", "MalformedPropertyFilters", "PropertiesNotFilterable", "ParametersNotFound", "ApplyActionFailed", "PropertyTypesSearchNotSupported", "InvalidParameterValue", "QueryTimeExceededLimit", "CompositePrimaryKeyNotSupported", "PropertyBaseTypeNotSupported", "PropertiesNotSearchable", "AttachmentNotFound", "ObjectTypeNotFound", "InvalidGroupId", "OntologySyncing", "ActionNotFound", "ParameterObjectSetRidNotFound", "LinkTypeNotFound", "InvalidRangeQuery", "ActionParameterObjectNotFound", "InvalidPropertyValue", "PropertiesNotSortable", "FunctionExecutionTimedOut", "InvalidFields", "ActionTypeNotFound", "ObjectTypeNotSynced", "OntologyEditsExceededLimit", "AggregationGroupCountExceededLimit", "InvalidContentType", "PropertiesNotFound", "FunctionInvalidInput", "InvalidSortOrder", "QueryDepthExceededLimit", "InvalidPropertyFiltersCombination", "ObjectsExceededLimit", "DuplicateOrderBy", "FunctionEncounteredUserFacingError", "InvalidUserId", "QueryNotFound", "InvalidAggregationRange", "ParameterObjectNotFound", "QueryMemoryExceededLimit", "InvalidContentLength", "OntologyNotFound", "ActionParameterObjectTypeNotFound", "UnknownParameter", "InvalidSortType", "PropertyFiltersNotSupported", "ActionValidationFailed", "MultipleGroupByOnFieldNotSupported", "LinkedObjectNotFound", "ActionEditedPropertiesNotFound", "InvalidPropertyFilterValue", "QueryEncounteredUserFacingError", "AttachmentSizeExceededLimit", "ObjectNotFound", "PropertyApiNameNotFound", "ParameterTypeNotSupported", "InvalidAggregationRangePropertyType", "MissingParameter"])));
-}
-async function generateOntologyMetadata(fs2, ontologyProviderDir) {
-  await fs2.writeFile(path16.join(ontologyProviderDir, "OntologyMetadata.ts"), await formatTs(reexportTypes(["OntologyMetadata"])));
-}
-async function generateResult(fs2, ontologyProviderDir) {
-  await fs2.writeFile(path16.join(ontologyProviderDir, "Result.ts"), await formatTs(`import {FoundryApiError} from "@osdk/legacy-client";
-        ` + reexportTypes(["Ok", "Err"], "<T>") + reexportTypes(["Result"], "<V, E = FoundryApiError>", "<V,E>") + reexportConsts(["isOk", "isErr", "visitError"]) + reexportTypes(["ErrorVisitor"], "<E extends FoundryApiError, R>", "<E,R>") + reexportTypes(["ExtractKeysWithType"], "<T, K extends keyof T>", "<T,K>")));
-}
-
-// src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateOntologyProviderDir.ts
-async function generateOntologyProviderDir(fs2, runtimeDistDir, importExt = "") {
-  const ontologyProviderDir = path16.join(runtimeDistDir, "ontologyProvider");
-  await fs2.mkdir(ontologyProviderDir, {
-    recursive: true
-  });
-  await generateErrors(fs2, ontologyProviderDir);
-  await generateOntologyMetadata(fs2, ontologyProviderDir);
-  await generateResult(fs2, ontologyProviderDir);
-  await fs2.writeFile(path16.join(ontologyProviderDir, "index.ts"), await formatTs(`
-    ${""}
-      export * from "./Errors${importExt}";
-      export * from "./OntologyMetadata${importExt}";
-      ${""}
-    ${""}
-      // export * from "./Result${importExt}";
-  `));
-}
-async function generatePagingDir(runtimeDistDir, fs2, importExt = "") {
-  const pagingDir = path16.join(runtimeDistDir, "paging");
-  await fs2.mkdir(pagingDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16.join(pagingDir, "index.ts"), await formatTs(`export * from "./Page${importExt}";`));
-  await fs2.writeFile(path16.join(pagingDir, "Page.ts"), await formatTs(reexportTypes(["Page"], "<T>")));
-}
-
-// src/v1.1/backcompat/generateOntologyRuntimeDistDir.ts
-async function generateOntologyRuntimeDistDir(outDir, fs2, importExt = "") {
-  const runtimeDistDir = path16.join(outDir, "internal", "@foundry", "ontology-runtime", "dist");
-  await fs2.mkdir(runtimeDistDir, {
-    recursive: true
-  });
-  await generateOntologyProviderDir(fs2, runtimeDistDir, importExt);
-  await generateAggregationsDir(fs2, runtimeDistDir, importExt);
-  await generatePagingDir(runtimeDistDir, fs2, importExt);
-  await generateBaseTypesDir(runtimeDistDir, fs2, importExt);
-  await generateClientDir(runtimeDistDir, fs2, importExt);
-  await generateFiltersDir(runtimeDistDir, fs2, importExt);
-  await fs2.writeFile(path16.join(runtimeDistDir, "index.ts"), await formatTs(`
-      export * from "./aggregations/index${importExt}";
-      export * from "./baseTypes/index${importExt}";
-      ${""}
-      // export * from "./filters/index${importExt}";
-      ${""}
-      ${""}
-    
-      export * from "./ontologyProvider/index${importExt}";
-      export * from "./paging/index${importExt}";
-`));
-}
-
-// src/v1.1/generateBackCompatDeprecatedExports.ts
-async function generateBackCompatDeprecatedExports(fs2, outDir, importExt = "") {
-  await generateOntologyRuntimeDistDir(outDir, fs2, importExt);
-  await generateOAuthClientDistDir(outDir, fs2, importExt);
-}
-async function generateBatchActions(ontology, fs2, outDir, importExt = "") {
-  const importedObjects = /* @__PURE__ */ new Set();
-  let actionSignatures = [];
-  for (const action of Object.values(ontology.actionTypes)) {
-    const entries = Object.entries(action.parameters);
-    const modifiedEntityTypes = getModifiedEntityTypes(action);
-    const addedObjects = Array.from(modifiedEntityTypes.addedObjects);
-    const modifiedObjects = Array.from(modifiedEntityTypes.modifiedObjects);
-    addedObjects.forEach(importedObjects.add, importedObjects);
-    modifiedObjects.forEach(importedObjects.add, importedObjects);
-    let jsDocBlock = ["/**"];
-    if (action.description) {
-      jsDocBlock.push(`* ${action.description}`);
-    }
-    let parameterBlock = "";
-    if (entries.length > 0) {
-      parameterBlock = `params: { 
-`;
-      for (const [parameterName, parameterData] of entries) {
-        parameterBlock += `"${parameterName}"`;
-        parameterBlock += parameterData.required ? ": " : "?: ";
-        const typeScriptType = getTypeScriptTypeFromDataType(parameterData.dataType, importedObjects);
-        parameterBlock += `${typeScriptType};
-`;
-        jsDocBlock.push(`* @param {${typeScriptType}} params.${parameterName}`);
-      }
-      parameterBlock += "}[], ";
-    } else {
-      parameterBlock = `params: Record<string,never>[], `;
-    }
-    jsDocBlock.push(`*/`);
-    actionSignatures.push(`
-      ${jsDocBlock.join("\n")}
-      ${action.apiName}<O extends BatchActionExecutionOptions>(${parameterBlock}options?: O): 
-        Promise<Result<BatchActionResponseFromOptions<O, Edits<${addedObjects.length > 0 ? addedObjects.join(" | ") : "void"}, ${modifiedObjects.length > 0 ? modifiedObjects.join(" | ") : "void"}>>, ActionError>>;
-      `);
-  }
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__default.join(outDir, "BatchActions.ts"), await formatTs(`
-    import type { ObjectSet, LocalDate, Timestamp, Attachment, Edits, ActionExecutionOptions, BatchActionExecutionOptions, ActionError, Result, ActionResponseFromOptions, BatchActionResponseFromOptions } from "@osdk/legacy-client";
-    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
-    export interface BatchActions {
-    ${actionSignatures.join("\n")}
-    }
-  `));
-}
-async function generateBulkActions(ontology, fs2, outDir, importExt = "") {
-  const importedObjects = /* @__PURE__ */ new Set();
-  let actionSignatures = [];
-  for (const action of Object.values(ontology.actionTypes)) {
-    const entries = Object.entries(action.parameters);
-    const modifiedEntityTypes = getModifiedEntityTypes(action);
-    const addedObjects = Array.from(modifiedEntityTypes.addedObjects);
-    const modifiedObjects = Array.from(modifiedEntityTypes.modifiedObjects);
-    addedObjects.forEach(importedObjects.add, importedObjects);
-    modifiedObjects.forEach(importedObjects.add, importedObjects);
-    let jsDocBlock = ["/**"];
-    if (action.description) {
-      jsDocBlock.push(`* ${action.description}`);
-    }
-    let parameterBlock = "";
-    if (entries.length > 0) {
-      parameterBlock = `params: { 
-`;
-      for (const [parameterName, parameterData] of entries) {
-        parameterBlock += `"${parameterName}"`;
-        parameterBlock += parameterData.required ? ": " : "?: ";
-        const typeScriptType = getTypeScriptTypeFromDataType(parameterData.dataType, importedObjects);
-        parameterBlock += `${typeScriptType};
-`;
-        jsDocBlock.push(`* @param {${typeScriptType}} params.${parameterName}`);
-      }
-      parameterBlock += "}[], ";
-    } else {
-      parameterBlock = `params: Record<string,never>[], `;
-    }
-    jsDocBlock.push(`*/`);
-    actionSignatures.push(`
-      ${jsDocBlock.join("\n")}
-      ${action.apiName}<O extends BulkActionExecutionOptions>(${parameterBlock}options?: O): 
-        Promise<Result<BulkActionResponseFromOptions<O, Edits<${addedObjects.length > 0 ? addedObjects.join(" | ") : "void"}, ${modifiedObjects.length > 0 ? modifiedObjects.join(" | ") : "void"}>>, ActionError>>;
-      `);
-  }
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__default.join(outDir, "BulkActions.ts"), await formatTs(`
-    import type { ObjectSet, LocalDate, Timestamp, Attachment, Edits, ActionExecutionOptions, BulkActionExecutionOptions, ActionError, Result, ActionResponseFromOptions, BulkActionResponseFromOptions } from "@osdk/legacy-client";
-    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
-    export interface BulkActions {
-    ${actionSignatures.join("\n")}
-    }
-  `));
-}
-async function generateFoundryClientFile(fs2, outDir, importExt = "") {
-  await fs2.writeFile(path16__default.join(outDir, "FoundryClient.ts"), await formatTs(`
-    import { BaseFoundryClient } from "@osdk/legacy-client";
-    import type { Auth, FoundryClientOptions } from "@osdk/legacy-client";
-    import { Ontology } from "./Ontology${importExt}";
-
-    export class FoundryClient<TAuth extends Auth = Auth> extends BaseFoundryClient<typeof Ontology, TAuth> {
-        constructor(options: FoundryClientOptions<TAuth>) {
-          super(options, Ontology);
-        }
-
-        get ontology(): Ontology {
-          return super.ontology;
-        }
-    }`));
-}
-async function generateIndexFile(fs2, outDir, importExt) {
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16.join(outDir, "index.ts"), await formatTs(`
-    export * from "@osdk/legacy-client";
-    export type { Ontology } from "./Ontology${importExt}";
-    export { FoundryClient } from "./FoundryClient${importExt}";
-    `));
-}
-
-// src/util/commaSeparatedIdentifiers.ts
-function commaSeparatedIdentifiers(identifiers, alternateNames) {
-  return identifiers.map((i) => {
-    const alt = alternateNames?.get(i);
-    if (alt) {
-      return `${i}: ${alt}`;
-    }
-    return i;
-  }).join(",");
-}
-
-// src/util/commaSeparatedTypeIdentifiers.ts
-function commaSeparatedTypeIdentifiers(identifiers, altNames) {
-  return identifiers.map((i) => `${i}: typeof ${altNames?.get(i) ?? i}`).join(",");
-}
-
-// src/v1.1/generateMetadataFile.ts
-async function generateMetadataFile(ontology, userAgent, fs2, outDir, importExt = "") {
-  const objectNames = Object.keys(ontology.objectTypes);
-  const actionNames = Object.keys(ontology.actionTypes);
-  const queryNames = Object.keys(ontology.queryTypes);
-  const actionAltNames = /* @__PURE__ */ new Map();
-  const queryAltNames = /* @__PURE__ */ new Map();
-  const seenIdentifiers = new Set(objectNames);
-  for (const actionName of actionNames) {
-    if (seenIdentifiers.has(actionName)) {
-      actionAltNames.set(actionName, `${actionName}Action`);
-    } else {
-      seenIdentifiers.add(actionName);
-    }
-  }
-  for (const queryName of queryNames) {
-    if (seenIdentifiers.has(queryName)) {
-      queryAltNames.set(queryName, `${queryName}Query`);
-    }
-  }
-  const getImportClause = (name, altNames) => {
-    const alt = altNames.get(name);
-    if (alt) {
-      return `${name} as ${alt}`;
-    } else {
-      return name;
-    }
-  };
-  await fs2.writeFile(path16__default.join(outDir, "Ontology.ts"), await formatTs(`
-  import type { OntologyDefinition } from "@osdk/api";
-  import type { Ontology as ClientOntology } from "@osdk/legacy-client";
-  import type { Objects } from "./ontology/objects/Objects${importExt}";
-  import type { Actions } from "./ontology/actions/Actions${importExt}";
-  import type { Queries } from "./ontology/queries/Queries${importExt}";
-  import type { BatchActions } from "./ontology/actions/BatchActions${importExt}";
-  import type { BulkActions } from "./ontology/actions/BulkActions${importExt}";
-  ${objectNames.map((name) => `import {${name}} from "./ontology/objects/${name}${importExt}";`).join("\n")}
-  ${actionNames.map((name) => `import {${getImportClause(name, actionAltNames)}} from "./ontology/actions/${name}${importExt}";`).join("\n")}
-  ${queryNames.map((name) => `import {${getImportClause(name, queryAltNames)}} from "./ontology/queries/${name}${importExt}";`).join("\n")}
-
-  export const Ontology : {
-    metadata: {
-      ontologyRid: "${ontology.ontology.rid}",
-      ontologyApiName: "${ontology.ontology.apiName}",
-      userAgent: "${userAgent}",
-    },
-    objects: {
-      ${commaSeparatedTypeIdentifiers(objectNames)}
-    },
-    actions: {
-      ${commaSeparatedTypeIdentifiers(actionNames, actionAltNames)}
-    },
-    queries: {
-      ${commaSeparatedTypeIdentifiers(queryNames, queryAltNames)}
-    },
-  } = {
-    metadata: {
-        ontologyRid: "${ontology.ontology.rid}" as const,
-        ontologyApiName: "${ontology.ontology.apiName}" as const,
-        userAgent: "${userAgent}" as const,
-    },
-    objects: {
-        ${commaSeparatedIdentifiers(objectNames)}
-    },
-    actions: {
-        ${commaSeparatedIdentifiers(actionNames, actionAltNames)}
-    },
-    queries: {
-        ${commaSeparatedIdentifiers(queryNames, queryAltNames)}
-    }
-  } satisfies OntologyDefinition<
-      ${stringUnionFrom(objectNames)},
-      ${stringUnionFrom(Object.values(ontology.actionTypes).map((actionType) => actionType.apiName))},
-      ${stringUnionFrom(Object.values(ontology.queryTypes).map((queryType) => queryType.apiName))}>;
-    
-export interface Ontology extends ClientOntology<typeof Ontology> {
-    objects: Objects;
-    actions: Actions;
-    /** @deprecated use batchActions */
-    bulkActions: BulkActions;
-    batchActions: BatchActions;
-    queries: Queries;
-}`));
-}
-function stringUnionFrom(values) {
-  if (values.length === 0) {
-    return "never";
-  }
-  return values.map((n) => `"${n}"`).join("|");
-}
-async function generateObjectsInterfaceFile(ontology, fs2, outDir, importExt = "") {
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__default.join(outDir, "Objects.ts"), await formatTs(`
-    import { BaseObjectSet } from "@osdk/legacy-client";
-    ${Array.from(Object.keys(ontology.objectTypes)).map((importedObject) => `import type { ${importedObject} } from "./${importedObject}${importExt}";`).join("\n")}
-    
-    export interface Objects {
-      ${Object.keys(ontology.objectTypes).map((apiName) => `${apiName} : BaseObjectSet<${apiName}>;`).join("\n")}
-    }
-    ;`));
-}
-async function generateObjectsInterfaceSupportFiles(ontology, fs2, outDir, importExt = "") {
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  for (const {
-    objectType: {
-      apiName
-    }
-  } of Object.values(ontology.objectTypes)) {
-    const fileName = join(outDir, `${apiName}.ts`);
-    const localApiName = `OG_${apiName}`;
-    const contents = [];
-    contents.push(`import { ObjectSetAggregateArg, ObjectSetFilterArg, ObjectSetGroupByArg, ObjectSetMultipleAggregateArg, ObjectSetOrderByArg } from "@osdk/legacy-client";`);
-    contents.push(`import { ${apiName} as ${localApiName} } from "../${apiName}${importExt}";`);
-    contents.push("");
-    contents.push(`/** @deprecated Use ${apiName} from ontology/objects instead */`, `export type ${apiName} = ${localApiName};`);
-    contents.push(`/** @deprecated Use ObjectSetFilterArg<${apiName}> instead */`, `export type ${apiName}Filter = ObjectSetFilterArg<${localApiName}>;`);
-    contents.push(`/** @deprecated Use ObjectSetOrderByArg<${apiName}> instead */`, `export type ${apiName}OrderBy = ObjectSetOrderByArg<${localApiName}>;`);
-    contents.push(`/** @deprecated Use ObjectSetGroupByArg<${apiName}> instead */`, `export type ${apiName}GroupByProperties = ObjectSetGroupByArg<${localApiName}>;`);
-    contents.push(`
-      /**
-        * Aggregation properties for ${apiName}
-        * @deprecated Use ObjectSetAggregateArg<${apiName}> instead
-        */`, `export type ${apiName}AggregationProperties = ObjectSetAggregateArg<${localApiName}>;`);
-    contents.push(`
-      /**
-        * Multiple aggregation properties for ${apiName}.
-        * @deprecated Use ObjectSetMultipleAggregateArg<${apiName}> instead
-        */`, `export type ${apiName}MultipleAggregationProperties = ObjectSetMultipleAggregateArg<${localApiName}>;`);
-    await fs2.writeFile(fileName, contents.join("\n"));
-  }
-}
-async function generateOntologyIndexFile(fs2, outDir) {
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16.join(outDir, "index.ts"), await formatTs(`
-        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/wireActionTypeV2ToSdkActionDefinition.ts
 function wireActionTypeV2ToSdkActionDefinition(input) {
   const modifiedEntityTypes = getModifiedEntityTypes(input);
   return {
     type: "action",
-    apiName: input.apiName,
-    parameters: Object.fromEntries(Object.entries(input.parameters).map(([key, value]) => [key, wireActionParameterV2ToSdkParameterDefinition(value)])),
-    displayName: input.displayName,
-    description: input.description,
-    modifiedEntities: createModifiedEntities(modifiedEntityTypes.addedObjects, modifiedEntityTypes.modifiedObjects)
-  };
-}
-function wireActionParameterV2ToSdkParameterDefinition(value) {
-  return {
-    multiplicity: value.dataType.type === "array",
-    type: actionPropertyToSdkPropertyDefinition(value.dataType.type === "array" ? value.dataType.subType : value.dataType),
-    nullable: !value.required,
-    description: value.description
-  };
-}
-function actionPropertyToSdkPropertyDefinition(parameterType) {
-  switch (parameterType.type) {
-    case "string":
-    case "boolean":
-    case "attachment":
-    case "double":
-    case "integer":
-    case "long":
-    case "timestamp":
-    case "marking":
-      return parameterType.type;
-    case "date":
-      return "datetime";
-    case "objectSet":
-      return {
-        type: "objectSet",
-        objectSet: parameterType.objectTypeApiName
-      };
-    case "object":
-      return {
-        type: "object",
-        object: parameterType.objectTypeApiName
-      };
-    case "array":
-      return actionPropertyToSdkPropertyDefinition(parameterType.subType);
-  }
-}
-function createModifiedEntities(addedObjects, modifiedObjects) {
-  let entities = {};
-  for (const key of addedObjects) {
-    entities[key] = {
-      created: true,
-      modified: false
-    };
-  }
-  for (const key of modifiedObjects) {
-    if (entities[key]) {
-      entities[key].modified = true;
-    } else {
-      entities[key] = {
-        created: false,
-        modified: true
-      };
-    }
-  }
-  return entities;
-}
-
-// src/util/stringUnionFrom.ts
-function stringUnionFrom2(values) {
-  if (values.length === 0) {
-    return "never";
-  } else {
-    return values.map((v) => `"${v}"`).join("|");
-  }
-}
-
-// 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(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()}
-        `));
-  }));
-  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 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/util/stringify.ts
-var defaultCustomizer = (value, defaultValueFormatter, key, defaultKeyFormatter) => {
-  return [defaultKeyFormatter(key), defaultValueFormatter(value)];
-};
-function stringify(obj, customizer = {}, separator = ",\n") {
-  const defaultKeyFormatter = (key) => `${JSON.stringify(key)}`;
-  const entries = [];
-  const sortedKeys = Object.keys(obj).sort((a, b) => a.localeCompare(b));
-  for (const key of sortedKeys) {
-    const value = obj[key];
-    const res = (customizer[key] ?? customizer["*"] ?? defaultCustomizer)(value, (value2) => JSON.stringify(value2, null, 2), key, defaultKeyFormatter);
-    if (res) {
-      if (typeof res === "string") {
-        entries.push(`${defaultKeyFormatter(key)}: ${res}`);
-      } else {
-        entries.push(`${res[0]}: ${res[1]}`);
-      }
-    }
-  }
-  return entries.join(separator);
-}
-
-// src/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
-  })}
-    
-    };`;
-}
-
-// 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`);
-    }
-    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 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)}
-
-        ${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";
-
-    `));
-}
-
-// src/shared/getObjectTypesFromQueryDataType.ts
-function getObjectTypesFromQueryDataType(dataType, types) {
-  switch (dataType.type) {
-    case "array":
-    case "set":
-      getObjectTypesFromQueryDataType(dataType.subType, types);
-      return;
-    case "object":
-      types.add(dataType.objectTypeApiName);
-      return;
-    case "objectSet":
-      types.add(dataType.objectTypeApiName);
-      return;
-    case "struct":
-      for (const prop of Object.values(dataType.fields)) {
-        getObjectTypesFromQueryDataType(prop.fieldType, types);
-      }
-      return;
-    case "union":
-      for (const type of dataType.unionTypes) {
-        getObjectTypesFromQueryDataType(type, types);
-      }
-      return;
-    case "attachment":
-    case "boolean":
-    case "date":
-    case "double":
-    case "float":
-    case "integer":
-    case "long":
-    case "null":
-    case "string":
-    case "threeDimensionalAggregation":
-    case "timestamp":
-    case "twoDimensionalAggregation":
-    case "unsupported":
-      return;
-    default:
-      throw new Error(`Cannot find object types from unsupported QueryDataType ${dataType.type}`);
-  }
-}
-
-// src/shared/getObjectTypeApiNamesFromQuery.ts
-function getObjectTypeApiNamesFromQuery(query) {
-  const types = /* @__PURE__ */ new Set();
-  for (const {
-    dataType
-  } of Object.values(query.parameters)) {
-    getObjectTypesFromQueryDataType(dataType, types);
-  }
-  getObjectTypesFromQueryDataType(query.output, types);
-  return Array.from(types);
-}
-
-// src/shared/isNullableQueryDataType.ts
-function isNullableQueryDataType(input) {
-  if (input.type === "null") {
-    return true;
-  }
-  if (input.type === "union") {
-    return input.unionTypes.some((t) => isNullableQueryDataType(t));
-  }
-  return false;
-}
-
-// src/shared/wireQueryDataTypeToQueryDataTypeDefinition.ts
-function wireQueryDataTypeToQueryDataTypeDefinition(input) {
-  switch (input.type) {
-    case "double":
-    case "float":
-    case "integer":
-    case "long":
-    case "attachment":
-    case "boolean":
-    case "date":
-    case "string":
-    case "timestamp":
-      return {
-        type: input.type,
-        nullable: false
-      };
-    case "object":
-      return {
-        type: "object",
-        object: input.objectTypeApiName,
-        nullable: false
-      };
-    case "objectSet":
-      return {
-        type: "objectSet",
-        objectSet: input.objectTypeApiName,
-        nullable: false
-      };
-    case "array":
-      return {
-        ...wireQueryDataTypeToQueryDataTypeDefinition(input.subType),
-        multiplicity: true
-      };
-    case "set":
-      return {
-        type: "set",
-        set: wireQueryDataTypeToQueryDataTypeDefinition(input.subType),
-        nullable: false
-      };
-    case "union":
-      const allowNulls = isNullableQueryDataType(input);
-      if (allowNulls && input.unionTypes.length === 2) {
-        const nonNull = input.unionTypes.find((t) => t.type != null);
-        if (nonNull) {
-          return {
-            ...wireQueryDataTypeToQueryDataTypeDefinition(nonNull),
-            nullable: true
-          };
-        }
-      }
-      return {
-        type: "union",
-        union: input.unionTypes.reduce((acc, t) => {
-          if (t.type === "null") {
-            return acc;
-          }
-          acc.push(wireQueryDataTypeToQueryDataTypeDefinition(t));
-          return acc;
-        }, []),
-        nullable: allowNulls
-      };
-    case "struct":
-      return {
-        type: "struct",
-        struct: Object.fromEntries(input.fields.map((f) => [f.name, wireQueryDataTypeToQueryDataTypeDefinition(f.fieldType)])),
-        nullable: false
-      };
-    case "twoDimensionalAggregation":
-      return {
-        type: "twoDimensionalAggregation",
-        twoDimensionalAggregation: get2DQueryAggregationProps(input),
-        nullable: false
-      };
-    case "threeDimensionalAggregation":
-      return {
-        type: "threeDimensionalAggregation",
-        threeDimensionalAggregation: get3DQueryAggregationProps(input),
-        nullable: false
-      };
-    case "null":
-    case "unsupported":
-      throw new Error(`Accidentally tried to handle QueryDataType.type ${input.type}`);
-    default:
-      throw new Error(`Unsupported QueryDataType.type ${input.type}`);
-  }
-}
-function get2DQueryAggregationProps(input) {
-  if (input.keyType.type === "range") {
-    return {
-      keyType: input.keyType.type,
-      keySubtype: input.keyType.subType.type,
-      valueType: input.valueType.type
-    };
-  } else {
-    if (guardInvalidKeyTypes(input.keyType)) {
-      return {
-        keyType: input.keyType.type,
-        valueType: input.valueType.type
-      };
-    }
-    throw new Error(`Cannot create 2D aggregation with ${input.keyType.type} as its type`);
-  }
-}
-function get3DQueryAggregationProps(input) {
-  if (input.keyType.type === "range") {
-    return {
-      keyType: input.keyType.type,
-      keySubtype: input.keyType.subType.type,
-      valueType: get2DQueryAggregationProps(input.valueType)
-    };
-  } else {
-    if (guardInvalidKeyTypes(input.keyType)) {
-      return {
-        keyType: input.keyType.type,
-        valueType: get2DQueryAggregationProps(input.valueType)
-      };
-    }
-    throw new Error(`Cannot create 3D aggregation with ${input.keyType.type} as its type`);
-  }
-}
-function guardInvalidKeyTypes(key) {
-  return key.type === "string" || key.type === "boolean";
-}
-
-// src/shared/wireQueryTypeV2ToSdkQueryDefinition.ts
-function 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")}
-    }
-  `));
+    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 handleQueryDataType(dataType, importedObjects, isReturnValue) {
-  switch (dataType.type) {
-    case "boolean":
-      return "boolean";
+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":
-      return "string";
+    case "boolean":
+    case "attachment":
     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 "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 `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}`);
+      return actionPropertyToSdkPropertyDefinition(parameterType.subType);
   }
 }
-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 createModifiedEntities(addedObjects, modifiedObjects) {
+  let entities = {};
+  for (const key of addedObjects) {
+    entities[key] = {
+      created: true,
+      modified: false
+    };
   }
-}
-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}`);
+  for (const key of modifiedObjects) {
+    if (entities[key]) {
+      entities[key].modified = true;
+    } else {
+      entities[key] = {
+        created: false,
+        modified: true
+      };
+    }
   }
+  return entities;
 }
-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}`);
+
+// 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]}`);
+      }
+    }
   }
-}
-function sanitizeDocTypeName(type) {
-  return type.replace(/\s/g, "");
+  return entries.join(separator);
 }
 
-// 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);
+// src/util/stringUnionFrom.ts
+function stringUnionFrom(values) {
+  if (values.length === 0) {
+    return "never";
+  } else {
+    return values.map((v) => `"${v}"`).join("|");
+  }
 }
-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/v2.0/getDescriptionIfPresent.ts
+function getDescriptionIfPresent(description, includeNewline) {
+  if (description) {
+    return `/**
+ * ${description}
+ */${""}`;
+  }
+  return "";
 }
 
 // src/shared/propertyJsdoc.ts
@@ -1866,7 +464,7 @@ function wireObjectTypeV2ToSdkObjectConstV2(wireObject, {
 }, 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 definition = deleteUndefineds(wireObjectTypeFullMetadataToSdkObjectTypeDefinition(object.raw, true));
   const objectDefIdentifier = object.getDefinitionIdentifier(true);
   const objectSetIdentifier = `${object.shortApiName}.ObjectSet`;
   const propertyKeysIdentifier = `${object.shortApiName}.PropertyKeys`;
@@ -1875,7 +473,7 @@ function wireObjectTypeV2ToSdkObjectConstV2(wireObject, {
   const osdkObjectLinksIdentifier = `${object.shortApiName}.Links`;
   const osdkObjectIdentifier = `${object.shortApiName}.OsdkObject`;
   const identifiers = {
-    objectDefIdentifier: `${object.shortApiName}.Definition`,
+    objectDefIdentifier: `${object.shortApiName}`,
     osdkObjectLinksIdentifier,
     osdkObjectPropsIdentifier,
     osdkObjectStrictPropsIdentifier,
@@ -1885,41 +483,18 @@ function wireObjectTypeV2ToSdkObjectConstV2(wireObject, {
   };
   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,
+      ObjectOrInterfacePropertyKeysFrom2 as $ObjectOrInterfacePropertyKeysFrom2,  
+      MinObjectDef as $ObjectTypeDefinition,
+      ObjectTypeLinkDefinition as $ObjectTypeLinkDefinition,
+    } from "@osdk/api";
+     import type {
       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} {
 
@@ -1932,33 +507,23 @@ function wireObjectTypeV2ToSdkObjectConstV2(wireObject, {
       ${createProps(object, "StrictProps", true)}
 
       ${createObjectSet(object, identifiers)}
-
-      ${createDefinition(object, ontology, "Definition", identifiers)}
+      
       ${createOsdkObject(object, "OsdkObject", identifiers)}
     }    
 
 
 
-
-  
-  export type ${objectDefIdentifier} = ${object.shortApiName}.Definition;
-
-
+    ${createDefinition(object, ontology, object.shortApiName, identifiers)}
     `;
   }
   const imports = getObjectImports(uniqueLinkTargetTypes, definition.apiName, currentFilePath, true);
   return `${imports}${getV2Types()}
 
-    export const ${object.shortApiName}: ${objectDefIdentifier}  & $VersionBound<$ExpectedClientVersion>
+    export const ${object.shortApiName}: ${objectDefIdentifier}
     = {
-      osdkMetadata: $osdkMetadata,
-      objectSet: undefined as any,
-      props: undefined as any,
-      strictProps: undefined as any,
-      ${stringify(definition, {
-    osdkMetadata: (value) => void 0
-  })}
-    
+      type: "${object instanceof EnhancedObjectType ? "object" : "interface"}",
+      apiName: "${object.fullApiName}",
+      osdkMetadata: $osdkMetadata,  
     };`;
 }
 function createOsdkObject(object, identifier, {
@@ -1967,7 +532,7 @@ function createOsdkObject(object, identifier, {
   osdkObjectStrictPropsIdentifier,
   osdkObjectLinksIdentifier
 }) {
-  const definition = object.getCleanedUpDefinition(true);
+  object.getCleanedUpDefinition(true);
   return `
   export type ${identifier}<
       OPTIONS extends never | "$notStrict" | "$rid" = never,
@@ -1977,23 +542,10 @@ function createOsdkObject(object, identifier, {
     = $Osdk<
         ${objectDefIdentifier}, 
         K | OPTIONS
-      > & Pick<
-       [OPTIONS] extends [never]
-        ? ${osdkObjectStrictPropsIdentifier} :
-        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,
@@ -2008,73 +560,7 @@ $ObjectSet<${objectDefIdentifier},
 ${objectSetIdentifier}
 >
 {
-readonly aggregate: <const AO extends $AggregateOpts<${objectDefIdentifier}>>(
-  req: $AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy<${objectDefIdentifier}, AO>,
-) => Promise<$AggregationsResults<${objectDefIdentifier}, AO>>;
-
-
-readonly pivotTo: <const L extends $LinkNames<${objectDefIdentifier}>>(type: L) => $LinkedType<${objectDefIdentifier}, L>["objectSet"];
- ${object instanceof EnhancedObjectType ? ` 
-readonly fetchOne: <
-    const L extends ${propertyKeysIdentifier},
-    const R extends boolean,
-    const S extends false | "throw" = $NullabilityAdherenceDefault,
-  >(
-    primaryKey: $PropertyValueClientToWire[${objectDefIdentifier}["primaryKeyType"]],
-    options?: $SelectArg<${objectDefIdentifier}, L, R, S>,
-  ) => Promise<
-   ${osdkObjectIdentifier}<
-    (S extends false ? "$notStrict" : never) | ($DefaultToFalse<R> extends false? never:  "$rid" ),
-    L
-   >>
-  ;
 
-readonly fetchOneWithErrors: <
-    const L extends ${propertyKeysIdentifier},
-    const R extends boolean,
-    const S extends false | "throw" = $NullabilityAdherenceDefault,
-  >(
-    primaryKey: $PropertyValueClientToWire[${objectDefIdentifier}["primaryKeyType"]],
-    options?: $SelectArg<${objectDefIdentifier}, L, R, S>,
-  ) => Promise<$Result<
-        ${osdkObjectIdentifier}<
-        (S extends false ? "$notStrict" : never) | ($DefaultToFalse<R> extends false?never: "$rid"),
-        L
-      >
-   >> 
-  
-;
-
-` : ""}
-
-readonly fetchPage: <
-  const L extends ${propertyKeysIdentifier},
-  const R extends boolean,
-  const const A extends $Augments,
-  const S extends $NullabilityAdherence = $NullabilityAdherenceDefault,
->(
-  args?: $FetchPageArgs<${objectDefIdentifier}, L, R, A, S>,
-) => Promise<
-  $PageResult<${osdkObjectIdentifier}<
-    (S extends false ? "$notStrict" : never) | ($DefaultToFalse<R> extends false? never: "$rid"),
-    L
-  >>
->;
-
-readonly fetchPageWithErrors: <
-  const L extends ${propertyKeysIdentifier},
-  const R extends boolean,
-  const A extends $Augments,
-  const S extends $NullabilityAdherence = $NullabilityAdherenceDefault,
->(
-  args?: $FetchPageArgs<${objectDefIdentifier}, L, R, A, S>,
-) => Promise<$Result<
- $PageResult<${osdkObjectIdentifier}<
- (S extends false ? "$notStrict" : never) | ($DefaultToFalse<R> extends false? never : "$rid"),
- L>>
- >>;
-
-readonly asyncIter: () => AsyncIterableIterator<${osdkObjectIdentifier}>;
 }
 `;
 }
@@ -2101,20 +587,23 @@ function createDefinition(object, ontology, identifier, {
   objectDefIdentifier,
   objectSetIdentifier,
   osdkObjectPropsIdentifier,
-  osdkObjectStrictPropsIdentifier
+  osdkObjectStrictPropsIdentifier,
+  osdkObjectLinksIdentifier
 }) {
   const definition = object.getCleanedUpDefinition(true);
   return `
-    export interface ${identifier} extends ${object instanceof EnhancedObjectType ? `$ObjectTypeDefinition` : `$InterfaceDefinition`}<"${object.fullApiName}", ${objectDefIdentifier}>, $VersionBound<$ExpectedClientVersion> {
+    export interface ${identifier} extends ${object instanceof EnhancedObjectType ? `$ObjectTypeDefinition` : `$InterfaceDefinition`}<"${object.fullApiName}", ${objectDefIdentifier}> {
       osdkMetadata: typeof $osdkMetadata;
+      type: "${object instanceof EnhancedObjectType ? "object" : "interface"}";
+      apiName: "${object.fullApiName}";
+      __DefinitionMetadata?: {
       objectSet: ${objectSetIdentifier};
       props: ${osdkObjectPropsIdentifier};
+      linksType: ${osdkObjectLinksIdentifier};
       strictProps: ${osdkObjectStrictPropsIdentifier};
       ${stringify(definition, {
     osdkMetadata: () => void 0,
     // we are going to reference another object instead
-    type: () => void 0,
-    apiName: () => void 0,
     links: (_value) => `{
         ${stringify(definition.links, {
       "*": (definition2) => `$ObjectTypeLinkDefinition<${ontology.requireObjectType(definition2.targetType).getImportedDefinitionIdentifier(true)}, ${definition2.multiplicity}>`
@@ -2128,18 +617,19 @@ function createDefinition(object, ontology, identifier, {
     })}
       }`
   })}
+  } 
 }
   `;
 }
 function createLinks(ontology, object, identifier) {
   const definition = object.getCleanedUpDefinition(true);
   return `
-    ${Object.keys(definition.links).length === 0 ? `export type ${identifier} = never;` : `
+    ${Object.keys(definition.links).length === 0 ? `export type ${identifier} = {};` : `
         export interface ${identifier}  {
 ${stringify(definition.links, {
     "*": (definition2, _, key) => {
       const linkTarget = ontology.requireObjectType(definition2.targetType).getImportedDefinitionIdentifier(true);
-      return [`readonly ${key}`, `${definition2.multiplicity ? `${linkTarget}.ObjectSet` : `$SingleLinkAccessor<${linkTarget}.Definition>`}
+      return [`readonly ${key}`, `${definition2.multiplicity ? `${linkTarget}.ObjectSet` : `$SingleLinkAccessor<${linkTarget}>`}
           `];
     }
   })}
@@ -2158,22 +648,18 @@ async function generatePerActionDataFiles({
   importExt = "",
   ontology: enhancedOntology
 }) {
-  const outDir = path16__default.join(rootOutDir, "ontology", "actions");
+  const outDir = path5__default.join(rootOutDir, "ontology", "actions");
   await fs2.mkdir(outDir, {
     recursive: true
   });
   await Promise.all(Object.values(enhancedOntology.actionTypes).map(async (action) => {
-    const currentFilePath = `${path16__default.join("ontology", "actions", `${action.shortApiName}.ts`)}`;
-    const uniqueApiNamesArray = extractReferencedObjectsFromAction2(action.og);
+    const currentFilePath = `${path5__default.join("ontology", "actions", `${action.shortApiName}.ts`)}`;
+    const uniqueApiNamesArray = extractReferencedObjectsFromAction(action.raw);
     const uniqueApiNames = new Set(uniqueApiNamesArray);
-    const uniqueApiNamesString = stringUnionFrom2([...uniqueApiNames]);
-    const fullActionDef = deleteUndefineds(wireActionTypeV2ToSdkActionDefinition(action.og));
-    const {
-      parameters,
-      ...actionDefSansParameters
-    } = fullActionDef;
+    const uniqueApiNamesString = stringUnionFrom([...uniqueApiNames]);
+    const fullActionDef = deleteUndefineds(wireActionTypeV2ToSdkActionDefinition(action.raw));
     function createParamsDef() {
-      const entries = Object.entries(parameters);
+      const entries = Object.entries(fullActionDef.parameters ?? {});
       entries.sort((a, b) => a[0].localeCompare(b[0]));
       if (entries.length === 0) {
         return `// Represents the definition of the parameters for the action
@@ -2191,9 +677,9 @@ async function generatePerActionDataFiles({
               return JSON.stringify(type);
             } else if (type.type === "object") {
               const obj = enhancedOntology.requireObjectType(type.object);
-              return `ObjectActionDataType<"${obj.fullApiName}", ${obj.getImportedDefinitionIdentifier(true)}.Definition>`;
+              return `ObjectActionDataType<"${obj.fullApiName}", ${obj.getImportedDefinitionIdentifier(true)}>`;
             } else if (type.type === "objectSet") {
-              return `ObjectSetActionDataType<"${type.objectSet}", ${getObjectDefIdentifier(type.objectSet, true)}.Definition>`;
+              return `ObjectSetActionDataType<"${type.objectSet}", ${getObjectDefIdentifier(type.objectSet, true)}>`;
             }
             return void 0;
           }
@@ -2206,13 +692,17 @@ async function generatePerActionDataFiles({
       if (typeof input === "string") {
         return `ActionParam.PrimitiveType<${JSON.stringify(input)}>`;
       } else if (input.type === "object") {
-        return `ActionParam.ObjectType<${enhancedOntology.requireObjectType(input.object).getImportedDefinitionIdentifier(true)}.Definition>`;
+        return `ActionParam.ObjectType<${enhancedOntology.requireObjectType(input.object).getImportedDefinitionIdentifier(true)}>`;
       } else if (input.type === "objectSet") {
-        return `ActionParam.ObjectSetType<${enhancedOntology.requireObjectType(input.objectSet).getImportedDefinitionIdentifier(true)}.Definition>`;
+        return `ActionParam.ObjectSetType<${enhancedOntology.requireObjectType(input.objectSet).getImportedDefinitionIdentifier(true)}>`;
       }
     }
     function createV2Types() {
-      const oldParamsIdentifier = `${action.shortApiName}$Params`;
+      `${action.shortApiName}$Params`;
+      let jsDocBlock = ["/**"];
+      if (action.description != null) {
+        jsDocBlock.push(`* ${action.description}`);
+      }
       return `
         
           export namespace ${action.shortApiName}{
@@ -2220,27 +710,16 @@ async function generatePerActionDataFiles({
 
             ${getDescriptionIfPresent(action.description)}
             export interface Params {
-              ${stringify(parameters, {
+              ${stringify(fullActionDef.parameters, {
         "*": (ogValue, _, ogKey) => {
           const key = `${getDescriptionIfPresent(ogValue.description)}
                   readonly "${ogKey}"${ogValue.nullable ? "?" : ""}`;
           const value = ogValue.multiplicity ? `ReadonlyArray<${getActionParamType(ogValue.type)}>` : `${getActionParamType(ogValue.type)}`;
+          jsDocBlock.push(`* @param {${getActionParamType(ogValue.type)}} ${ogValue.nullable ? `[${ogKey}]` : `${ogKey}`} ${ogValue.description ?? ""} `);
           return [key, value];
         }
       })}
             }
-            /** @deprecated **/
-            export type Parameters = Params;
-
-
-              // Represents the definition of the action
-              export interface Definition extends ActionDefinition<"${action.shortApiName}", ${uniqueApiNamesString}, ${action.shortApiName}.Signatures>, 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 Signatures {
@@ -2252,19 +731,36 @@ async function generatePerActionDataFiles({
   
           }
 
-          /**
-           * @deprecated Use \`${action.paramsIdentifier}\`
-           */
-          export type ${oldParamsIdentifier} = ${action.paramsIdentifier} | ReadonlyArray<${action.paramsIdentifier}>;
-
-          /** @deprecated Use \`${action.definitionIdentifier}\` **/
-          export type ${action.shortApiName} = ${action.shortApiName}.Signatures;
+          
+          ${jsDocBlock.join("\n")}
+          */
+          export interface ${action.shortApiName} extends MinActionDef<"${action.shortApiName}", ${uniqueApiNamesString}, ${action.shortApiName}.Signatures> {
+            __DefinitionMetadata?: {
+              ${stringify(fullActionDef, {
+        "parameters": () => action.definitionParamsIdentifier
+      })}
+              
+              signatures: ${action.shortApiName}.Signatures;
+            },
+            ${stringify(fullActionDef, {
+        "description": () => void 0,
+        "displayName": () => void 0,
+        "modifiedEntities": () => void 0,
+        "parameters": () => void 0
+      })}
+            osdkMetadata: typeof $osdkMetadata;
+            }
           `;
     }
     function createV2Object() {
-      return `  export const ${action.shortApiName}: ${action.definitionIdentifier} = 
+      return `  export const ${action.shortApiName}: ${action.shortApiName} = 
         {
-          ${stringify(fullActionDef)},
+          ${stringify(fullActionDef, {
+        "description": () => void 0,
+        "displayName": () => void 0,
+        "modifiedEntities": () => void 0,
+        "parameters": () => void 0
+      })},
           osdkMetadata: $osdkMetadata
         }
         `;
@@ -2289,11 +785,10 @@ async function generatePerActionDataFiles({
       }
     }
     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';
+    await fs2.writeFile(path5__default.join(rootOutDir, currentFilePath), await formatTs(`
+          import type { MinActionDef, ObjectActionDataType, ObjectSetActionDataType } from "@osdk/api";
+          import type { ActionParam, ActionReturnTypeForOptions, ApplyActionOptions, ApplyBatchActionOptions,  } from '@osdk/client.api';
           import { $osdkMetadata} from "../../OntologyMetadata${importExt}";
-          import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
           ${imports}
 
         
@@ -2302,8 +797,8 @@ async function generatePerActionDataFiles({
           ${createV2Object()}
         `));
   }));
-  const indexFileRelPath = path16__default.join("ontology", "actions.ts");
-  await fs2.writeFile(path16__default.join(rootOutDir, indexFileRelPath), await formatTs(`
+  const indexFileRelPath = path5__default.join("ontology", "actions.ts");
+  await fs2.writeFile(path5__default.join(rootOutDir, indexFileRelPath), await formatTs(`
       ${Object.values(enhancedOntology.actionTypes).map((action) => {
     const exportConstLine = `export {${action.shortApiName} } from "${action.getImportPathRelTo(indexFileRelPath)}";`;
     return exportConstLine;
@@ -2311,11 +806,11 @@ async function generatePerActionDataFiles({
     ${Object.keys(ontology.actionTypes).length === 0 ? "export {};" : ""}
       `));
 }
-function extractReferencedObjectsFromAction2(actionType) {
+function extractReferencedObjectsFromAction(actionType) {
   const referencedObjectsInParameters = Object.values(actionType.parameters).flatMap(({
     dataType
   }) => {
-    const objectTypeReference = extractReferencedObjectsFromActionParameter2(dataType);
+    const objectTypeReference = extractReferencedObjectsFromActionParameter(dataType);
     return objectTypeReference ? [objectTypeReference] : [];
   });
   const referenceObjectsInEdits = actionType.operations.flatMap((value) => {
@@ -2327,18 +822,19 @@ function extractReferencedObjectsFromAction2(actionType) {
       case "deleteObject":
       case "createLink":
       case "deleteLink":
+      default:
         return [];
     }
   });
   return [...referenceObjectsInEdits, ...referencedObjectsInParameters];
 }
-function extractReferencedObjectsFromActionParameter2(actionParameter) {
+function extractReferencedObjectsFromActionParameter(actionParameter) {
   switch (actionParameter.type) {
     case "objectSet":
     case "object":
       return actionParameter.objectTypeApiName;
     case "array":
-      return extractReferencedObjectsFromActionParameter2(actionParameter.subType);
+      return extractReferencedObjectsFromActionParameter(actionParameter.subType);
     case "string":
     case "boolean":
     case "attachment":
@@ -2350,14 +846,70 @@ function extractReferencedObjectsFromActionParameter2(actionParameter) {
       return void 0;
   }
 }
+
+// src/shared/getObjectTypesFromQueryDataType.ts
+function getObjectTypesFromQueryDataType(dataType, types) {
+  switch (dataType.type) {
+    case "array":
+    case "set":
+      getObjectTypesFromQueryDataType(dataType.subType, types);
+      return;
+    case "object":
+      types.add(dataType.objectTypeApiName);
+      return;
+    case "objectSet":
+      types.add(dataType.objectTypeApiName);
+      return;
+    case "struct":
+      for (const prop of Object.values(dataType.fields)) {
+        getObjectTypesFromQueryDataType(prop.fieldType, types);
+      }
+      return;
+    case "union":
+      for (const type of dataType.unionTypes) {
+        getObjectTypesFromQueryDataType(type, types);
+      }
+      return;
+    case "attachment":
+    case "boolean":
+    case "date":
+    case "double":
+    case "float":
+    case "integer":
+    case "long":
+    case "null":
+    case "string":
+    case "threeDimensionalAggregation":
+    case "timestamp":
+    case "twoDimensionalAggregation":
+    case "unsupported":
+      return;
+    default:
+      throw new Error(`Cannot find object types from unsupported QueryDataType ${dataType.type}`);
+  }
+}
+
+// src/shared/getObjectTypeApiNamesFromQuery.ts
+function getObjectTypeApiNamesFromQuery(query) {
+  const types = /* @__PURE__ */ new Set();
+  for (const {
+    dataType
+  } of Object.values(query.parameters)) {
+    getObjectTypesFromQueryDataType(dataType, types);
+  }
+  getObjectTypesFromQueryDataType(query.output, types);
+  return Array.from(types);
+}
+
+// src/v2.0/generatePerQueryDataFiles.ts
 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");
+  const relOutDir = path5__default.join(".", "ontology", "queries");
+  const outDir = path5__default.join(rootOutDir, "ontology", "queries");
   await fs2.mkdir(outDir, {
     recursive: true
   });
@@ -2371,14 +923,15 @@ async function generatePerQueryDataFilesV2({
     `));
 }
 async function generateV2QueryFile(fs2, outDir, relOutDir, query, importExt, ontology) {
-  const relFilePath = path16__default.join(relOutDir, `${query.shortApiName}.ts`);
+  const relFilePath = path5__default.join(relOutDir, `${query.shortApiName}.ts`);
   const objectTypes = getObjectTypeApiNamesFromQuery(query);
-  const importObjects = getObjectImports2(ontology, objectTypes, relFilePath);
-  const baseProps = deleteUndefineds(wireQueryTypeV2ToSdkQueryDefinitionNoParams(query.og));
+  const objectTypeObjects = new Set(objectTypes.map((o) => ontology.requireObjectType(o)));
+  const importObjects = getObjectImports(objectTypeObjects, "", relFilePath, true);
+  const baseProps = deleteUndefineds(wireQueryTypeV2ToSdkQueryDefinitionNoParams(query.raw));
   const outputBase = deleteUndefineds(wireQueryDataTypeToQueryDataTypeDefinition(query.output));
   const referencedObjectTypes = objectTypes.length > 0 ? objectTypes.map((apiNameObj) => `"${apiNameObj}"`).join("|") : "never";
-  await fs2.writeFile(path16__default.join(outDir, `${query.shortApiName}.ts`), await formatTs(`
-        import type { QueryDefinition , VersionBound} from "@osdk/api";
+  await fs2.writeFile(path5__default.join(outDir, `${query.shortApiName}.ts`), await formatTs(`
+        import type { MinQueryDef , VersionBound} from "@osdk/api";
         import type { QueryParam, QueryResult } from "@osdk/client.api";
         import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
         ${importObjects}
@@ -2406,7 +959,7 @@ async function generateV2QueryFile(fs2, outDir, relOutDir, query, importExt, ont
     
             ` : ""}
 
-        export interface Definition extends QueryDefinition<
+        export interface Definition extends MinQueryDef<
           "${query.fullApiName}", 
           ${referencedObjectTypes},
           ${query.shortApiName}.Signature
@@ -2480,15 +1033,6 @@ function queryParamJsDoc(param, {
 `;
   return ret;
 }
-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 getQueryParamType(enhancedOntology, input, type) {
   let inner = `unknown /* ${input.type} */`;
   switch (input.type) {
@@ -2529,11 +1073,11 @@ function getQueryParamType(enhancedOntology, input, type) {
   return inner;
 }
 function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, ontology, v2 = false) {
-  const definition = deleteUndefineds(__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(interfaceDef.og, v2));
+  const definition = deleteUndefineds(__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(interfaceDef.raw, v2));
   const objectDefIdentifier = interfaceDef.getDefinitionIdentifier(v2);
   const parents = definition.implements?.map((p) => {
     !(ontology.interfaceTypes[p] != null) ? process.env.NODE_ENV !== "production" ? invariant(false, `Expected to find a parent interface named ${p} in the ontology and did not.`) : invariant(false) : void 0;
-    const it = deleteUndefineds(__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(ontology.requireInterfaceType(p, true).og, v2));
+    const it = deleteUndefineds(__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(ontology.requireInterfaceType(p, true).raw, v2));
     return it;
   }) ?? [];
   const mergedProperties = {
@@ -2574,46 +1118,19 @@ function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, ontology,
     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,
+    return `    import type {
+    InterfaceDefinition as $InterfaceDefinition,
+    } from "@osdk/api";
+     import type {
       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";
+      PropertyValueWireToClient as $PropType,    } from "@osdk/client.api";
+    
+
 
     
 
-        ${Object.keys(definition.links).length === 0 ? `export type ${osdkObjectLinksIdentifier} = never;` : `
+        ${Object.keys(definition.links).length === 0 ? `export type ${osdkObjectLinksIdentifier} = {};` : `
         export interface ${osdkObjectLinksIdentifier}  {
 ${stringify(definition.links, {
       "*": (definition2) => {
@@ -2661,6 +1178,7 @@ ${stringify(definition.links, {
       osdkMetadata: $osdkMetadata,
       objectSet: undefined as any,
       props: undefined as any,
+      linksType: undefined as any,
       strictProps: undefined as any,
       ${stringify(definition, {
     osdkMetadata: () => void 0,
@@ -2681,11 +1199,15 @@ async function generateRootIndexTsFile({
   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}";
+  fs2.writeFile(path5__default.join(outDir, "index.ts"), await formatTs(`export * from "./ontology/actions${importExt}";
+        export * as $Actions from "./ontology/actions${importExt}";
         export * from "./ontology/interfaces${importExt}";
+        export * as $Interfaces from "./ontology/interfaces${importExt}";
+        export * from "./ontology/objects${importExt}";
+        export * as $Objects from "./ontology/objects${importExt}";
         export * from "./ontology/queries${importExt}";
+        export * as $Queries from "./ontology/queries${importExt}";
+        ${ontologyApiNamespace == null ? `export { $ontologyRid } from "./OntologyMetadata${importExt}";` : ``}
     `));
 }
 async function generateEachObjectFile(ctx) {
@@ -2695,18 +1217,17 @@ async function generateEachObjectFile(ctx) {
     ontology,
     importExt
   } = ctx;
-  await fs2.mkdir(path16__default.join(outDir, "ontology", "objects"), {
+  await fs2.mkdir(path5__default.join(outDir, "ontology", "objects"), {
     recursive: true
   });
   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);
+    const relPath = path5__default.join(".", "ontology", `objects`, `${obj.shortApiName}.ts`);
+    const outFilePath = path5__default.join(outDir, relPath);
     await fs2.writeFile(outFilePath, await formatTs(`
-        import type {  VersionBound as $VersionBound, PropertyDef as $PropertyDef } from "@osdk/api";
-        import type { Osdk } from "@osdk/client.api";
+        import type { PropertyDef as $PropertyDef } from "@osdk/api";
         import { $osdkMetadata } from "../../OntologyMetadata${importExt}";
         import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
-        ${wireObjectTypeV2ToSdkObjectConstV2(obj.og, ctx, relPath)}
+        ${wireObjectTypeV2ToSdkObjectConstV2(obj.raw, ctx, relPath)}
       `));
   }
 }
@@ -2731,12 +1252,12 @@ async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs2, ou
   await generateOntologyMetadataFile(ctx, userAgent);
   await generateEachObjectFile(ctx);
   await generateOntologyInterfaces(ctx);
-  const actionsDir = path16__default.join(outDir, "ontology", "actions");
+  const actionsDir = path5__default.join(outDir, "ontology", "actions");
   await fs2.mkdir(actionsDir, {
     recursive: true
   });
   await generatePerActionDataFiles(ctx);
-  await fs2.writeFile(path16__default.join(outDir, "ontology", "objects.ts"), await formatTs(`
+  await fs2.writeFile(path5__default.join(outDir, "ontology", "objects.ts"), await formatTs(`
     ${Object.values(enhancedOntology.objectTypes).map((objType) => `export * from "./objects/${objType.shortApiName}${importExt}";`).join("\n")}
     ${Object.keys(ontology.objectTypes).length === 0 ? "export {};" : ""}
     `));
@@ -2748,16 +1269,14 @@ async function generateOntologyInterfaces({
   ontology,
   importExt
 }) {
-  const interfacesDir = path16__default.join(outDir, "ontology", "interfaces");
+  const interfacesDir = path5__default.join(outDir, "ontology", "interfaces");
   await fs2.mkdir(interfacesDir, {
     recursive: true
   });
   for (const obj of Object.values(ontology.interfaceTypes)) {
-    await fs2.writeFile(path16__default.join(interfacesDir, `${obj.shortApiName}.ts`), await formatTs(`
-    
-      import type { PropertyDef as $PropertyDef, VersionBound as $VersionBound } from "@osdk/api";
-      import { $osdkMetadata, $expectedClientVersion } from "../../OntologyMetadata${importExt}";
-      import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
+    await fs2.writeFile(path5__default.join(interfacesDir, `${obj.shortApiName}.ts`), await formatTs(`
+        import type { PropertyDef as $PropertyDef } from "@osdk/api";
+        import { $osdkMetadata } from "../../OntologyMetadata${importExt}";
       ${__UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(obj, ontology, true)}
     `));
   }
@@ -2769,26 +1288,29 @@ async function generateOntologyInterfaces({
 
 // src/generateClientSdkPackage.ts
 async function generateClientSdkPackage(packageName, packageVersion, sdkVersion, baseOutDir, ontology, minimalFs, dependencyVersions, cliVersion, ontologyApiNamespace, apiNamespacePackageMap) {
-  if (!packageName) throw new Error("Package name is require");
+  if (!packageName) throw new Error("Package name is required");
+  if (sdkVersion === "1.1") {
+    throw new Error("This generator version does not support generating v1 sdks");
+  }
   for (const packageType of ["module", "commonjs"]) {
-    const outDir = 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, ontologyApiNamespace, apiNamespacePackageMap);
+    const outDir = path5.join(baseOutDir, "dist", packageType);
+    generateClientSdkVersionTwoPointZero(ontology, `typescript-sdk/${packageVersion} osdk-cli/${cliVersion}`, minimalFs, outDir, packageType, ontologyApiNamespace, apiNamespacePackageMap);
     await fs.promises.mkdir(outDir, {
       recursive: true
     });
-    await writeJson(minimalFs, path16.join(outDir, "package.json"), {
+    await writeJson(minimalFs, path5.join(outDir, "package.json"), {
       type: packageType
     });
-    await writeJson(minimalFs, path16.join(outDir, `tsconfig.json`), {
+    await writeJson(minimalFs, path5.join(outDir, `tsconfig.json`), {
       compilerOptions: getTsCompilerOptions(packageType)
     });
   }
-  await writeJson(minimalFs, path16.join(baseOutDir, "package.json"), await getPackageJsonContents(packageName, packageVersion, sdkVersion, dependencyVersions));
-  await minimalFs.mkdir(path16.join(baseOutDir, "ontology"), {
+  await writeJson(minimalFs, path5.join(baseOutDir, "package.json"), await getPackageJsonContents(packageName, packageVersion, dependencyVersions));
+  await minimalFs.mkdir(path5.join(baseOutDir, "ontology"), {
     recursive: true
   });
-  await minimalFs.writeFile(path16.join(baseOutDir, "ontology", "objects.js"), `module.exports = require("../../dist/module/ontology/objects")`);
-  await minimalFs.writeFile(path16.join(baseOutDir, "ontology", "objects.d.ts"), `export * from "../dist/module/ontology/objects"`);
+  await minimalFs.writeFile(path5.join(baseOutDir, "ontology", "objects.js"), `module.exports = require("../../dist/module/ontology/objects")`);
+  await minimalFs.writeFile(path5.join(baseOutDir, "ontology", "objects.d.ts"), `export * from "../dist/module/ontology/objects"`);
 }
 function getTsCompilerOptions(packageType) {
   const commonTsconfig = {
@@ -2811,39 +1333,30 @@ function getTsCompilerOptions(packageType) {
   };
   return compilerOptions;
 }
-function getExpectedDependencies(sdkVersion, {
+function getExpectedDependencies({
   osdkApiVersion,
   osdkClientVersion,
-  osdkClientApiVersion,
-  osdkLegacyClientVersion
+  osdkClientApiVersion
 }) {
   return {
     devDependencies: {
       "@osdk/api": osdkApiVersion,
-      ...sdkVersion === "2.0" ? {
-        "@osdk/client.api": osdkClientApiVersion
-      } : {
-        "@osdk/legacy-client": osdkLegacyClientVersion
-      }
+      "@osdk/client.api": osdkClientApiVersion
     },
     peerDependencies: {
       "@osdk/api": osdkApiVersion,
-      ...sdkVersion === "2.0" ? {
-        "@osdk/client.api": osdkClientApiVersion,
-        "@osdk/client": osdkClientVersion
-      } : {
-        "@osdk/legacy-client": osdkLegacyClientVersion
-      }
+      "@osdk/client.api": osdkClientApiVersion,
+      "@osdk/client": osdkClientVersion
     }
   };
 }
-function getExpectedDependenciesFull(sdkVersion, dependencyVersions) {
+function getExpectedDependenciesFull(dependencyVersions) {
   const {
     typescriptVersion,
     tslibVersion,
     areTheTypesWrongVersion
   } = dependencyVersions;
-  const base = getExpectedDependencies(sdkVersion, dependencyVersions);
+  const base = getExpectedDependencies(dependencyVersions);
   return {
     devDependencies: {
       ...base.devDependencies,
@@ -2856,7 +1369,7 @@ function getExpectedDependenciesFull(sdkVersion, dependencyVersions) {
     }
   };
 }
-function getPackageJsonContents(name, version, sdkVersion, dependencyVersions) {
+function getPackageJsonContents(name, version, dependencyVersions) {
   const esmPrefix = "./dist/module";
   const commonjsPrefix = "./dist/commonjs";
   return {
@@ -2868,17 +1381,13 @@ function getPackageJsonContents(name, version, sdkVersion, dependencyVersions) {
       ".": {
         import: `${esmPrefix}/index.js`,
         require: `${commonjsPrefix}/index.js`
-      },
-      "./ontology/objects": {
-        import: `${esmPrefix}/ontology/objects${sdkVersion === "2.0" ? "" : "/index"}.js`,
-        require: `${commonjsPrefix}/ontology/objects${sdkVersion === "2.0" ? "" : "/index"}.js`
       }
     },
     scripts: {
       prepack: `tsc -p ${esmPrefix}/tsconfig.json && tsc -p ${commonjsPrefix}/tsconfig.json`,
       check: "npm exec attw $(npm pack)"
     },
-    ...getExpectedDependenciesFull(sdkVersion, dependencyVersions),
+    ...getExpectedDependenciesFull(dependencyVersions),
     files: ["**/*.js", "**/*.d.ts", "dist/**/package.json"]
   };
 }
@@ -2886,6 +1395,6 @@ async function writeJson(minimalFs, filePath, body) {
   return await minimalFs.writeFile(filePath, JSON.stringify(body, void 0, 2) + "\n");
 }
 
-export { generateClientSdkPackage as __UNSTABLE_generateClientSdkPackage, generateClientSdkVersionOneDotOne, generateClientSdkVersionTwoPointZero, getExpectedDependencies };
+export { generateClientSdkPackage as __UNSTABLE_generateClientSdkPackage, generateClientSdkVersionTwoPointZero, getExpectedDependencies };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map