@osdk/generator 1.8.0 → 1.9.1-main-20240411211601

package/build/js/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
-var path15 = require('path');
+var fs = require('fs');
+var path16 = require('path');
 var prettier = require('prettier');
 var organizeImports = require('prettier-plugin-organize-imports');
 var generatorConverters = require('@osdk/generator-converters');
@@ -25,39 +26,132 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var path15__namespace = /*#__PURE__*/_interopNamespace(path15);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path16__namespace = /*#__PURE__*/_interopNamespace(path16);
 var organizeImports__default = /*#__PURE__*/_interopDefault(organizeImports);
 
-// src/v1.1/generateClientSdkVersionOneDotOne.ts
+// src/generateClientSdkPackage.ts
 
-// src/shared/sanitizeMetadata.ts
-function sanitizeMetadata(ontology) {
-  return {
-    ...ontology,
-    actionTypes: Object.fromEntries(Object.values(ontology.actionTypes).map((actionType) => {
-      return [camelize(actionType.apiName), {
-        ...actionType,
-        apiName: camelize(actionType.apiName)
-      }];
-    }))
-  };
-}
-function camelize(name) {
-  return name.replace(/-./g, (segment) => segment[1].toUpperCase());
+// src/util/deleteUndefineds.ts
+function deleteUndefineds(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== void 0));
 }
 
-// src/util/verifyOutdir.ts
-async function verifyOutdir(outDir, fs) {
-  try {
-    const contents = await fs.readdir(outDir);
-    if (contents.length !== 0) {
-      throw new Error(`outDir ${outDir} is not empty, please delete its contents and try again`);
+// 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]}`);
+      }
     }
-  } catch (e) {
-    if (e.code === "ENOENT") ; else {
-      throw e;
+  }
+  return entries.join(separator);
+}
+function formatTs(contents) {
+  return prettier.format(contents, {
+    parser: "typescript",
+    singleQuote: true,
+    trailingComma: "all",
+    plugins: [organizeImports__default.default],
+    tabWidth: 2,
+    printWidth: 120
+  });
+}
+
+// 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 } 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}";
+  /** @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 "string";
+    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/shared/getEditedEntities.ts
@@ -79,488 +173,316 @@ function getModifiedEntityTypes(action) {
     modifiedObjects
   };
 }
-function formatTs(contents) {
-  return prettier.format(contents, {
-    parser: "typescript",
-    singleQuote: true,
-    trailingComma: "all",
-    plugins: [organizeImports__default.default],
-    tabWidth: 2,
-    printWidth: 120
-  });
-}
 
-// src/v1.1/generateActions.ts
-async function generateActions(ontology, fs, 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 fs.mkdir(outDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.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")}
-    }
-  `));
+// 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 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)}>`;
+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":
-      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}`);
+      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);
   }
 }
-
-// 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 arent public api **/
-              export const ${q} = OG_${q};
-          `).join("\n\n")}
-      `;
-}
-
-// src/v1.1/backcompat/internal-foundry-oauth-dist/generateConfidentialClientDir.ts
-async function generateConfidentialClientDir(fs, oauthDistDir, importExt = "") {
-  const confidentialClientDistDir = path15__namespace.default.join(oauthDistDir, "ConfidentialClient");
-  await fs.mkdir(confidentialClientDistDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.default.join(confidentialClientDistDir, "index.ts"), await formatTs(`
-    export * from "./ConfidentialClientAuth${importExt}";
-  `));
-  await fs.writeFile(path15__namespace.default.join(confidentialClientDistDir, "ConfidentialClientAuth.ts"), await formatTs(`
-        ${reexportConsts(["ConfidentialClientAuth"])}
-    `));
-}
-async function generatePublicClientDir(fs, oauthDistDir, importExt = "") {
-  const publicClientDistDir = path15__namespace.default.join(oauthDistDir, "PublicClient");
-  await fs.mkdir(publicClientDistDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.default.join(publicClientDistDir, "index.ts"), await formatTs(`
-    export * from "./PublicClientAuth${importExt}";
-  `));
-  await fs.writeFile(path15__namespace.default.join(publicClientDistDir, "PublicClientAuth.ts"), await formatTs(`
-        ${reexportConsts(["PublicClientAuth"])}
-    `));
+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;
 }
-async function generateUserTokenDir(fs, oauthDistDir, importExt = "") {
-  const userTokenDistDir = path15__namespace.default.join(oauthDistDir, "UserToken");
-  await fs.mkdir(userTokenDistDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.default.join(userTokenDistDir, "index.ts"), await formatTs(`
-    export * from "./UserTokenAuth${importExt}";
-  `));
-  await fs.writeFile(path15__namespace.default.join(userTokenDistDir, "UserTokenAuth.ts"), await formatTs(`
-        ${reexportConsts(["UserTokenAuth"])}
-    `));
+function getObjectDefIdentifier(name, v2) {
+  return v2 ? name : `${name}Def`;
 }
-
-// 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 arent public api **/
-      export type ${q}${genericArgsLeft} = OG_${q}${genericArgsRight};
-    `).join("\n\n")}
+function wireObjectTypeV2ToSdkObjectConst(object, importExt, v2 = false) {
+  const uniqueLinkTargetTypes = new Set(object.linkTypes.map((a) => a.objectTypeApiName));
+  const definition = deleteUndefineds(generatorConverters.wireObjectTypeFullMetadataToSdkObjectTypeDefinition(object, v2));
+  const objectDefIdentifier = getObjectDefIdentifier(object.objectType.apiName, v2);
+  function getV1Types() {
+    return `
+      export interface ${objectDefIdentifier} extends ObjectTypeDefinition<"${object.objectType.apiName}", ${object.objectType.apiName}> {
+        ${stringify(definition, {
+      osdkMetadata: () => void 0,
+      // not used in v1
+      links: (_value) => `{
+          ${stringify(definition.links, {
+        "*": (definition2) => `ObjectTypeLinkDefinition<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
+      })}
+        }`
+    })}
+      }
     `;
-}
-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, fs, importExt = "") {
-  const oauthDistDir = path15__namespace.join(outDir, "internal", "@foundry", "oauth-client", "dist");
-  await fs.mkdir(oauthDistDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.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 fs.writeFile(path15__namespace.join(oauthDistDir, "Auth.ts"), await formatTs(reexportTypes(["Auth"])));
-  await fs.writeFile(path15__namespace.join(oauthDistDir, "Token.ts"), await formatTs(reexportTypes(["Token", "TokenValue"])));
-  await fs.writeFile(path15__namespace.join(oauthDistDir, "OAuthClient.ts"), await formatTs(reexportTypes(["AuthSubscription", "UnsubscribeFunction", "SignInResponse", "RefreshResponse", "SignOutResponse"])));
-  await fs.writeFile(path15__namespace.join(oauthDistDir, "OAuthToken.ts"), await formatTs(reexportConsts(["OAuthToken"])));
-  await fs.writeFile(path15__namespace.join(oauthDistDir, "Auth.ts"), await formatTs(reexportTypes(["Auth"])));
-  await generateConfidentialClientDir(fs, oauthDistDir, importExt);
-  await generatePublicClientDir(fs, oauthDistDir, importExt);
-  await generateUserTokenDir(fs, oauthDistDir, importExt);
-}
-async function generateAggregationsAggregations(fs, aggregationsDir) {
-  await fs.writeFile(path15__namespace.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(fs, aggregationsDir, importExt = "") {
-  await fs.mkdir(path15__namespace.join(aggregationsDir, "groupBy"), {
-    recursive: true
-  });
-  const groupBys = ["BooleanGroupBy", "LocalDateGroupBy", "NumericGroupBy", "StringGroupBy", "TimestampGroupBy"];
-  const reexportFiles = [...groupBys, "GroupKeyType"];
-  for (const key of reexportFiles) {
-    await fs.writeFile(path15__namespace.join(aggregationsDir, "groupBy", `${key}.ts`), await formatTs(`export {${key}} from "./index${importExt}";`));
   }
-  await fs.writeFile(path15__namespace.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(fs, aggregationsDir, importExt = "") {
-  const metricsDir = path15__namespace.join(aggregationsDir, "metrics");
-  await fs.mkdir(metricsDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.join(metricsDir, "metrics.ts"), await formatTs(`export {MetricValueType} from "@osdk/legacy-client";`));
-  await fs.writeFile(path15__namespace.join(metricsDir, "ApproximateDistinctCountAggregatableProperty.ts"), await formatTs(reexportConsts(["ApproximateDistinctCountAggregatableProperty"]) + reexportTypes(["ApproximateDistinctCountAggregatableProperty"])));
-  await fs.writeFile(path15__namespace.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 fs.writeFile(path15__namespace.join(metricsDir, `${typeName}.ts`), await formatTs(`
-          import { MultipleAggregatableProperty } from "./MultipleAggregatableProperty${importExt}";
-        ` + reexportConsts([typeName])));
+  function getV2Types() {
+    return `
+      export interface ${objectDefIdentifier} extends ObjectTypeDefinition<"${object.objectType.apiName}", ${object.objectType.apiName}>, VersionBound<$ExpectedClientVersion> {
+        osdkMetadata: typeof $osdkMetadata;
+        ${stringify(definition, {
+      osdkMetadata: () => void 0,
+      // we are going to reference another object instead
+      type: () => void 0,
+      apiName: () => void 0,
+      links: (_value) => `{
+          ${stringify(definition.links, {
+        "*": (definition2) => `ObjectTypeLinkDefinition<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
+      })}
+        }`,
+      properties: (_value) => `{
+          ${stringify(definition.properties, {
+        "*": (propertyDefinition) => `PropertyDef<"${propertyDefinition.type}", "${propertyDefinition.nullable ? "nullable" : "non-nullable"}", "${propertyDefinition.multiplicity ? "array" : "single"}">`
+      })}
+        }`
+    })}
+    
+      }
+
+    `;
   }
-  await fs.writeFile(path15__namespace.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}";
-      `));
-}
+  const imports = Array.from(uniqueLinkTargetTypes).filter((type) => type !== definition.apiName).map((type) => `import type { ${getObjectDefIdentifier(type, v2)} } from "./${type}${importExt}";`);
+  return `${imports.join("\n")}
 
-// src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateAggregationsDir.ts
-async function generateAggregationsDir(fs, runtimeDistDir, importExt = "") {
-  const aggregationsDir = path15__namespace.join(runtimeDistDir, "aggregations");
-  await fs.mkdir(aggregationsDir, {
-    recursive: true
-  });
-  await generateGroupBy(fs, aggregationsDir, importExt);
-  await generateAggregationsAggregations(fs, aggregationsDir);
-  await generateMetrics(fs, aggregationsDir, importExt);
-  await fs.writeFile(path15__namespace.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 fs.writeFile(path15__namespace.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>") + `
+    ${v2 ? getV2Types() : getV1Types()}
+
+    export const ${object.objectType.apiName}: ${objectDefIdentifier} = {
+      ${v2 ? `osdkMetadata: $osdkMetadata,` : ""}
+      ${stringify(definition, {
+    osdkMetadata: (value) => void 0
+  })}
     
-    `));
-  await fs.writeFile(path15__namespace.join(aggregationsDir, "CountOperation.ts"), await formatTs(`` + reexportConsts(["CountOperation", "isCountOperation"]) + reexportTypes(["CountOperation"])));
-  await fs.writeFile(path15__namespace.join(aggregationsDir, "internalAggregationRequest.ts"), await formatTs(reexportTypes(["InternalAggregationRequest"])));
-}
-async function generateAttachmentsDir(attachmentsDir, fs, importExt = "") {
-  await fs.mkdir(attachmentsDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.default.join(attachmentsDir, "index.ts"), await formatTs(`export * from "./Attachment${importExt}";
-       export * from "./Attachments${importExt}";
-    `));
-  await fs.writeFile(path15__namespace.default.join(attachmentsDir, "Attachment.ts"), await formatTs(reexportTypes(["Attachment", "AttachmentMetadata"])));
-  await fs.writeFile(path15__namespace.default.join(attachmentsDir, "Attachments.ts"), await formatTs(reexportTypes(["Attachments"])));
-}
-async function generateGeoshapesDir(runtimeDistDir, fs, importExt = "") {
-  await fs.mkdir(runtimeDistDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.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 fs.writeFile(path15__namespace.join(runtimeDistDir, "Distance.ts"), await formatTs(`` + reexportConsts(["Distance", "DistanceUnit"]) + reexportTypes(["Distance", "DistanceUnit"])));
-  await fs.writeFile(path15__namespace.join(runtimeDistDir, "GeoJson.ts"), await formatTs(reexportTypes(["GeoJsonPoint", "GeoJsonPolygon", "GeoJsonLineString", "GeoJsonMultiPoint", "GeoJsonMultiPolygon", "GeoJsonMultiLineString", "GeoJsonGeometryCollection", "GeoJsonGeometry", "GeoJson"])));
-  await fs.writeFile(path15__namespace.join(runtimeDistDir, "GeometryCollection.ts"), await formatTs(reexportConsts(["GeometryCollection"])));
-  await fs.writeFile(path15__namespace.join(runtimeDistDir, "GeoPoint.ts"), await formatTs(`` + reexportConsts(["isGeoPoint", "GeoPoint", "mapCoordinatesToGeoPoint"]) + reexportTypes(["GeoHash", "Coordinates", "GeoPoint"])));
-  await fs.writeFile(path15__namespace.join(runtimeDistDir, "GeoShape.ts"), await formatTs(reexportConsts(["GeoShape"]) + reexportTypes(["GeoShape"])));
-  await fs.writeFile(path15__namespace.join(runtimeDistDir, "LineString.ts"), await formatTs(reexportConsts(["LineString"]) + reexportTypes(["LineString"])));
-  await fs.writeFile(path15__namespace.join(runtimeDistDir, "MultiGeoPoint.ts"), await formatTs(reexportConsts(["MultiGeoPoint"]) + reexportTypes(["MultiGeoPoint"])));
-  await fs.writeFile(path15__namespace.join(runtimeDistDir, "MultiLineString.ts"), await formatTs(reexportConsts(["MultiLineString"]) + reexportTypes(["MultiLineString"])));
-  await fs.writeFile(path15__namespace.join(runtimeDistDir, "MultiPolygon.ts"), await formatTs(reexportConsts(["MultiPolygon"]) + reexportTypes(["MultiPolygon"])));
-  await fs.writeFile(path15__namespace.join(runtimeDistDir, "Polygon.ts"), await formatTs(reexportConsts(["Polygon"]) + reexportTypes(["LinearRing", "Polygon"])));
-}
-async function generateObjectSetDir(objectSetDir, fs, importExt = "") {
-  await fs.mkdir(objectSetDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.default.join(objectSetDir, "index.ts"), await formatTs(`
-    export * from "./ObjectSetDefinition${importExt}";
-    export * from "./OntologyObjectSet${importExt}";
-    `));
-  await fs.writeFile(path15__namespace.default.join(objectSetDir, "ObjectSetDefinition.ts"), await formatTs(reexportTypes(["BaseObjectSetDefinition", "ReferenceObjectSetDefinition", "StaticObjectSetDefinition", "IntersectObjectSetDefinition", "SubtractObjectSetDefinition", "SearchAroundObjectSetDefinition", "FilterObjectSetDefinition", "ObjectSetDefinition"])));
-  await fs.writeFile(path15__namespace.default.join(objectSetDir, "OntologyObjectSet.ts"), await formatTs(reexportTypes(["OntologyObjectSet"])));
-}
-async function generateSharedObjectCodeDir(sharedObjectCodeDir, fs, importExt = "") {
-  await fs.mkdir(sharedObjectCodeDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.default.join(sharedObjectCodeDir, "index.ts"), await formatTs(`
-    export * from "./FilteredPropertiesTerminalOperations${importExt}";
-    `));
-  await fs.writeFile(path15__namespace.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, fs, importExt = "") {
-  await fs.mkdir(timeseriesDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.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 fs.writeFile(path15__namespace.join(timeseriesDir, "TimeSeries.ts"), await formatTs(reexportTypes(["TimeSeries"], `<T extends number | string>`)));
-  await fs.writeFile(path15__namespace.join(timeseriesDir, "TimeSeriesDuration.ts"), await formatTs(reexportTypes([`WhenUnit`, `DurationUnit`, `TimeSeriesDuration`])));
-  await fs.writeFile(path15__namespace.join(timeseriesDir, "TimeSeriesPoint.ts"), await formatTs(reexportTypes(["TimeSeriesPoint"], `<T extends number | string>`)));
-  await fs.writeFile(path15__namespace.join(timeseriesDir, "TimeSeriesQuery.ts"), await formatTs(reexportTypes(["TimeSeriesQuery"], `<T extends number | string>`)));
-  await fs.writeFile(path15__namespace.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, fs, importExt = "") {
-  const baseTypesDir = path15__namespace.join(runtimeDistDir, "baseTypes");
-  await fs.mkdir(baseTypesDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.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 = path15__namespace.join(baseTypesDir, "geoshapes");
-  await generateGeoshapesDir(geoshapesDir, fs, importExt);
-  const timeseriesDir = path15__namespace.join(baseTypesDir, "timeseries");
-  await generateTimeSeriesDir(timeseriesDir, fs, importExt);
-  const attachmentsDir = path15__namespace.join(baseTypesDir, "attachments");
-  await generateAttachmentsDir(attachmentsDir, fs, importExt);
-  const objectSetDir = path15__namespace.join(baseTypesDir, "objectset");
-  await generateObjectSetDir(objectSetDir, fs, importExt);
-  const sharedObjectCodeDir = path15__namespace.join(baseTypesDir, "sharedObjectCode");
-  await generateSharedObjectCodeDir(sharedObjectCodeDir, fs, importExt);
-  await fs.writeFile(path15__namespace.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 fs.writeFile(path15__namespace.join(baseTypesDir, "OntologyObject.ts"), await formatTs(reexportTypes(["OntologyObject"]) + reexportConsts(["isOntologyObject"])));
-  await fs.writeFile(path15__namespace.join(baseTypesDir, "links.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject${importExt}` + reexportTypes(["SingleLink", "MultiLink"], "<T extends OntologyObject = OntologyObject>")));
-  await fs.writeFile(path15__namespace.join(baseTypesDir, "localDate.ts"), await formatTs(reexportConsts(["LocalDate"]) + reexportTypes(["LocalDate"])));
-  await fs.writeFile(path15__namespace.join(baseTypesDir, "timestamp.ts"), await formatTs(reexportConsts(["Timestamp"]) + reexportTypes(["Timestamp"])));
-  await fs.writeFile(path15__namespace.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 fs.writeFile(path15__namespace.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, fs, importExt = "") {
-  const pagingDir = path15__namespace.default.join(runtimeDistDir, "client");
-  await fs.mkdir(pagingDir, {
+// src/shared/generatePerActionDataFiles.ts
+async function generatePerActionDataFiles(ontology, fs2, outDir, importExt, v2) {
+  await fs2.mkdir(outDir, {
     recursive: true
   });
-  await fs.writeFile(path15__namespace.default.join(pagingDir, "index.ts"), await formatTs(`export * from "./clientOptions${importExt}";`));
-  await fs.writeFile(path15__namespace.default.join(pagingDir, "clientOptions.ts"), await formatTs(`import {Auth} from "@osdk/legacy-client";` + reexportTypes(["FoundryClientOptions"], "<TAuth extends Auth = Auth>")));
+  await Promise.all(Object.values(ontology.actionTypes).map(async (action) => {
+    const uniqueApiNames = new Set(extractReferencedObjectsFromAction(action));
+    const uniqueApiNamesString = uniqueApiNames.size > 0 ? [...uniqueApiNames].map((apiName) => `"${apiName}"`).join("|") : "never";
+    const fullActionDef = deleteUndefineds(wireActionTypeV2ToSdkActionDefinition(action));
+    const {
+      parameters,
+      ...actionDefSansParameters
+    } = fullActionDef;
+    const actionDefIdentifier = `ActionDef$${action.apiName}`;
+    const paramsDefIdentifier = `${actionDefIdentifier}$Params`;
+    const paramsIdentifier = `${action.apiName}$Params`;
+    function createParamsDef() {
+      const entries = Object.entries(parameters);
+      entries.sort((a, b) => a[0].localeCompare(b[0]));
+      if (entries.length === 0) {
+        return `// Represents the definition of the parameters for the action
+          export type ${paramsDefIdentifier} = Record<string, never>;`;
+      }
+      return `// Represents the definition of the parameters for the action
+        export type ${paramsDefIdentifier} = {
+          ${entries.map(([key, value]) => {
+        return `"${key}": {
+                ${stringify(value, {
+          description: (value2, d) => value2 ? d(value2) : void 0,
+          // trick to remove undefineds
+          type: (type) => {
+            if (typeof type === "string") {
+              return JSON.stringify(type);
+            } else if (type.type === "object") {
+              return `ObjectActionDataType<"${type.object}", ${getObjectDefIdentifier(type.object, v2)}>`;
+            } else if (type.type === "objectSet") {
+              return `ObjectSetActionDataType<"${type.objectSet}", ${getObjectDefIdentifier(type.objectSet, v2)}>`;
+            }
+            return void 0;
+          }
+        })}
+            }`;
+      }).join(";\n")}
+        }`;
+    }
+    function createV2Types() {
+      return `
+        
+          ${createParamsDef()}
+          
+
+          // Represents the runtime arguments for the action
+          export type ${paramsIdentifier} = NOOP<OsdkActionParameters<${paramsDefIdentifier}>>;
+
+          
+          // Represents a fqn of the action
+          export interface ${action.apiName} {
+            ${getDescriptionIfPresent(action.description)}
+             <OP extends ApplyActionOptions>(args: ${paramsIdentifier}, options?: OP): Promise<ActionReturnTypeForOptions<OP>>;
+          }
+
+          
+          // Represents the definition of the action
+          export interface ${actionDefIdentifier} extends ActionDefinition<"${action.apiName}", ${uniqueApiNamesString}, ${action.apiName}>{
+          ${Object.entries(actionDefSansParameters).sort((a, b) => a[0].localeCompare(b[0])).map(([key, value]) => {
+        return `${key}: ${JSON.stringify(value)};`;
+      }).join("\n")}
+          parameters: ${paramsDefIdentifier};
+          osdkMetadata: typeof $osdkMetadata;
+        }`;
+    }
+    function createV2Object() {
+      return `  export const ${action.apiName}: ${actionDefIdentifier} = 
+        {
+          ${stringify(fullActionDef)},
+          osdkMetadata: $osdkMetadata
+        }
+        `;
+    }
+    function createV1Object() {
+      return `  export const ${action.apiName} = ${JSON.stringify(fullActionDef, null, 2)} satisfies ActionDefinition<"${action.apiName}", ${uniqueApiNamesString}>;`;
+    }
+    const referencedObjectDefs = /* @__PURE__ */ new Set();
+    for (const p of Object.values(action.parameters)) {
+      if (p.dataType.type === "object" || p.dataType.type === "objectSet") {
+        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.objectApiName, v2));
+        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.objectTypeApiName, v2));
+      }
+      if (p.dataType.type === "array" && (p.dataType.subType.type === "object" || p.dataType.subType.type === "objectSet")) {
+        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.subType.objectApiName, v2));
+        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.subType.objectTypeApiName, v2));
+      }
+    }
+    const importObjects = referencedObjectDefs.size > 0 ? `import type {${[...referencedObjectDefs].join(",")}} from "../objects${importExt}";` : "";
+    await fs2.writeFile(path16__namespace.default.join(outDir, `${action.apiName}.ts`), await formatTs(`
+          import type { ActionDefinition, ObjectActionDataType, ObjectSetActionDataType } from "@osdk/api";
+          import type { ActionSignature, ApplyActionOptions, OsdkActionParameters,ActionReturnTypeForOptions, NOOP } from '@osdk/client';
+          import { $osdkMetadata} from "../../OntologyMetadata${importExt}";
+          ${importObjects}
+
+        
+          ${v2 ? createV2Types() : ""}
+
+          ${v2 ? createV2Object() : createV1Object()}
+        `));
+  }));
+  await fs2.writeFile(path16__namespace.default.join(outDir, `index.ts`), await formatTs(`
+      ${Object.values(ontology.actionTypes).map((action) => `export {${action.apiName}} from "./${action.apiName}${importExt}";`).join("\n")}
+    ${Object.keys(ontology.actionTypes).length === 0 ? "export {};" : ""}
+      `));
 }
-async function generateFiltersDir(runtimeDistDir, fs, importExt = "") {
-  const pagingDir = path15__namespace.default.join(runtimeDistDir, "filters");
-  await fs.mkdir(pagingDir, {
-    recursive: true
+function extractReferencedObjectsFromAction(actionType) {
+  const referencedObjectsInParameters = Object.values(actionType.parameters).flatMap(({
+    dataType
+  }) => {
+    const objectTypeReference = extractReferencedObjectsFromActionParameter(dataType);
+    return objectTypeReference ? [objectTypeReference] : [];
   });
-  await fs.writeFile(path15__namespace.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 fs.writeFile(path15__namespace.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 fs.writeFile(path15__namespace.default.join(pagingDir, "AttachmentFilter.ts"), await formatTs(reexportConsts(["AttachmentFilter"]) + reexportTypes(["AttachmentFilter"])));
-  await fs.writeFile(path15__namespace.default.join(pagingDir, "BooleanFilter.ts"), await formatTs(reexportConsts(["BooleanFilter"]) + reexportTypes(["BooleanFilter"])));
-  await fs.writeFile(path15__namespace.default.join(pagingDir, "GeoPointFilter.ts"), await formatTs(reexportConsts(["GeoPointFilter"]) + reexportTypes(["GeoPointFilter", "BoundingBox"])));
-  await fs.writeFile(path15__namespace.default.join(pagingDir, "DateTimeFilters.ts"), await formatTs(reexportConsts(["TimestampFilter", "LocalDateFilter"]) + reexportTypes(["TimestampFilter", "LocalDateFilter"])));
-  await fs.writeFile(path15__namespace.default.join(pagingDir, "GeoShapeFilter.ts"), await formatTs(reexportConsts(["GeoShapeFilter"]) + reexportTypes(["GeoShapeFilter"])));
-  await fs.writeFile(path15__namespace.default.join(pagingDir, "NumericFilter.ts"), await formatTs(reexportConsts(["NumericFilter"]) + reexportTypes(["NumericFilter"])));
-  await fs.writeFile(path15__namespace.default.join(pagingDir, "Op.ts"), await formatTs(reexportConsts(["Op"])));
-  await fs.writeFile(path15__namespace.default.join(pagingDir, "OrderByOption.ts"), await formatTs(reexportConsts(["OrderByOption"]) + reexportTypes(["OrderByOption"])));
-  await fs.writeFile(path15__namespace.default.join(pagingDir, "StringFilter.ts"), await formatTs(reexportConsts(["StringFilter"]) + reexportTypes(["StringFilter"])));
-  await fs.writeFile(path15__namespace.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(fs, ontologyProviderDir) {
-  await fs.writeFile(path15__namespace.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(fs, ontologyProviderDir) {
-  await fs.writeFile(path15__namespace.join(ontologyProviderDir, "OntologyMetadata.ts"), await formatTs(reexportTypes(["OntologyMetadata"])));
-}
-async function generateResult(fs, ontologyProviderDir) {
-  await fs.writeFile(path15__namespace.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(fs, runtimeDistDir, importExt = "") {
-  const ontologyProviderDir = path15__namespace.join(runtimeDistDir, "ontologyProvider");
-  await fs.mkdir(ontologyProviderDir, {
-    recursive: true
+  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 [];
+    }
   });
-  await generateErrors(fs, ontologyProviderDir);
-  await generateOntologyMetadata(fs, ontologyProviderDir);
-  await generateResult(fs, ontologyProviderDir);
-  await fs.writeFile(path15__namespace.join(ontologyProviderDir, "index.ts"), await formatTs(`
-    ${""}
-      export * from "./Errors${importExt}";
-      export * from "./OntologyMetadata${importExt}";
-      ${""}
-    ${""}
-      // export * from "./Result${importExt}";
-  `));
+  return [...referenceObjectsInEdits, ...referencedObjectsInParameters];
 }
-async function generatePagingDir(runtimeDistDir, fs, importExt = "") {
-  const pagingDir = path15__namespace.join(runtimeDistDir, "paging");
-  await fs.mkdir(pagingDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.join(pagingDir, "index.ts"), await formatTs(`export * from "./Page${importExt}";`));
-  await fs.writeFile(path15__namespace.join(pagingDir, "Page.ts"), await formatTs(reexportTypes(["Page"], "<T>")));
+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/v1.1/backcompat/generateOntologyRuntimeDistDir.ts
-async function generateOntologyRuntimeDistDir(outDir, fs, importExt = "") {
-  const runtimeDistDir = path15__namespace.join(outDir, "internal", "@foundry", "ontology-runtime", "dist");
-  await fs.mkdir(runtimeDistDir, {
-    recursive: true
-  });
-  await generateOntologyProviderDir(fs, runtimeDistDir, importExt);
-  await generateAggregationsDir(fs, runtimeDistDir, importExt);
-  await generatePagingDir(runtimeDistDir, fs, importExt);
-  await generateBaseTypesDir(runtimeDistDir, fs, importExt);
-  await generateClientDir(runtimeDistDir, fs, importExt);
-  await generateFiltersDir(runtimeDistDir, fs, importExt);
-  await fs.writeFile(
-    path15__namespace.join(runtimeDistDir, "index.ts"),
-    // TRASHFIXME
-    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/shared/sanitizeMetadata.ts
+function sanitizeMetadata(ontology) {
+  return {
+    ...ontology,
+    actionTypes: Object.fromEntries(Object.values(ontology.actionTypes).map((actionType) => {
+      return [camelize(actionType.apiName), {
+        ...actionType,
+        apiName: camelize(actionType.apiName)
+      }];
+    }))
+  };
+}
+function camelize(name) {
+  return name.replace(/-./g, (segment) => segment[1].toUpperCase());
 }
 
-// src/v1.1/generateBackCompatDeprecatedExports.ts
-async function generateBackCompatDeprecatedExports(fs, outDir, importExt = "") {
-  await generateOntologyRuntimeDistDir(outDir, fs, importExt);
-  await generateOAuthClientDistDir(outDir, fs, importExt);
+// src/util/verifyOutdir.ts
+async function verifyOutdir(outDir, fs2) {
+  try {
+    const contents = await fs2.readdir(outDir);
+    if (contents.length !== 0) {
+      throw new Error(`outDir ${outDir} is not empty, please delete its contents and try again`);
+    }
+  } catch (e) {
+    if (e.code === "ENOENT") ; else {
+      throw e;
+    }
+  }
 }
-async function generateBulkActions(ontology, fs, outDir, importExt = "") {
+async function generateActions(ontology, fs2, outDir, importExt = "") {
   const importedObjects = /* @__PURE__ */ new Set();
   let actionSignatures = [];
   for (const action of Object.values(ontology.actionTypes)) {
@@ -586,601 +508,694 @@ async function generateBulkActions(ontology, fs, outDir, importExt = "") {
 `;
         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 fs.mkdir(outDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.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(fs, outDir, importExt = "") {
-  await fs.writeFile(path15__namespace.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(fs, outDir, importExt) {
-  await fs.mkdir(outDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.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, fs, 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 fs.writeFile(path15__namespace.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 { 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;
-    bulkActions: BulkActions;
-    queries: Queries;
-}`));
-}
-function stringUnionFrom(values) {
-  if (values.length === 0) {
-    return "never";
-  }
-  return values.map((n) => `"${n}"`).join("|");
-}
-async function generateObjectsInterfaceFile(ontology, fs, outDir, importExt = "") {
-  await fs.mkdir(outDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.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, fs, outDir, importExt = "") {
-  await fs.mkdir(outDir, {
-    recursive: true
-  });
-  for (const {
-    objectType: {
-      apiName
-    }
-  } of Object.values(ontology.objectTypes)) {
-    const fileName = path15.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 fs.writeFile(fileName, contents.join("\n"));
-  }
-}
-async function generateOntologyIndexFile(fs, outDir) {
-  await fs.mkdir(outDir, {
-    recursive: true
-  });
-  await fs.writeFile(path15__namespace.join(outDir, "index.ts"), await formatTs(`
-        export type { ObjectSet } from "@osdk/legacy-client";
-    `));
-}
-
-// 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
-  };
+      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__namespace.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 actionPropertyToSdkPropertyDefinition(parameterType) {
-  switch (parameterType.type) {
+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 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);
+      return "string";
+    default:
+      throw new Error(`Unsupported action parameter type: ${actionParameter}`);
   }
 }
-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/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 arent public api **/
+              export const ${q} = OG_${q};
+          `).join("\n\n")}
+      `;
 }
 
-// src/util/deleteUndefineds.ts
-function deleteUndefineds(obj) {
-  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== void 0));
+// src/v1.1/backcompat/internal-foundry-oauth-dist/generateConfidentialClientDir.ts
+async function generateConfidentialClientDir(fs2, oauthDistDir, importExt = "") {
+  const confidentialClientDistDir = path16__namespace.default.join(oauthDistDir, "ConfidentialClient");
+  await fs2.mkdir(confidentialClientDistDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__namespace.default.join(confidentialClientDistDir, "index.ts"), await formatTs(`
+    export * from "./ConfidentialClientAuth${importExt}";
+  `));
+  await fs2.writeFile(path16__namespace.default.join(confidentialClientDistDir, "ConfidentialClientAuth.ts"), await formatTs(`
+        ${reexportConsts(["ConfidentialClientAuth"])}
+    `));
+}
+async function generatePublicClientDir(fs2, oauthDistDir, importExt = "") {
+  const publicClientDistDir = path16__namespace.default.join(oauthDistDir, "PublicClient");
+  await fs2.mkdir(publicClientDistDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__namespace.default.join(publicClientDistDir, "index.ts"), await formatTs(`
+    export * from "./PublicClientAuth${importExt}";
+  `));
+  await fs2.writeFile(path16__namespace.default.join(publicClientDistDir, "PublicClientAuth.ts"), await formatTs(`
+        ${reexportConsts(["PublicClientAuth"])}
+    `));
+}
+async function generateUserTokenDir(fs2, oauthDistDir, importExt = "") {
+  const userTokenDistDir = path16__namespace.default.join(oauthDistDir, "UserToken");
+  await fs2.mkdir(userTokenDistDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__namespace.default.join(userTokenDistDir, "index.ts"), await formatTs(`
+    export * from "./UserTokenAuth${importExt}";
+  `));
+  await fs2.writeFile(path16__namespace.default.join(userTokenDistDir, "UserTokenAuth.ts"), await formatTs(`
+        ${reexportConsts(["UserTokenAuth"])}
+    `));
 }
 
-// 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/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 arent 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/shared/wireObjectTypeV2ToSdkObjectConst.ts
-function getObjectDefIdentifier(name, v2) {
-  return v2 ? name : `${name}Def`;
+// src/v1.1/backcompat/generateOAuthDistDir.ts
+async function generateOAuthClientDistDir(outDir, fs2, importExt = "") {
+  const oauthDistDir = path16__namespace.join(outDir, "internal", "@foundry", "oauth-client", "dist");
+  await fs2.mkdir(oauthDistDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__namespace.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__namespace.join(oauthDistDir, "Auth.ts"), await formatTs(reexportTypes(["Auth"])));
+  await fs2.writeFile(path16__namespace.join(oauthDistDir, "Token.ts"), await formatTs(reexportTypes(["Token", "TokenValue"])));
+  await fs2.writeFile(path16__namespace.join(oauthDistDir, "OAuthClient.ts"), await formatTs(reexportTypes(["AuthSubscription", "UnsubscribeFunction", "SignInResponse", "RefreshResponse", "SignOutResponse"])));
+  await fs2.writeFile(path16__namespace.join(oauthDistDir, "OAuthToken.ts"), await formatTs(reexportConsts(["OAuthToken"])));
+  await fs2.writeFile(path16__namespace.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__namespace.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 = {}>")));
 }
-function wireObjectTypeV2ToSdkObjectConst(object, importExt, v2 = false) {
-  const uniqueLinkTargetTypes = new Set(object.linkTypes.map((a) => a.objectTypeApiName));
-  const definition = deleteUndefineds(generatorConverters.wireObjectTypeFullMetadataToSdkObjectTypeDefinition(object, v2));
-  const objectDefIdentifier = getObjectDefIdentifier(object.objectType.apiName, v2);
-  function getV1Types() {
-    return `
-      export interface ${objectDefIdentifier} extends ObjectTypeDefinition<"${object.objectType.apiName}", ${object.objectType.apiName}> {
-        ${stringify(definition, {
-      links: (_value) => `{
-          ${stringify(definition.links, {
-        "*": (definition2) => `ObjectTypeLinkDefinition<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
-      })}
-        }`
-    })}
-      }
-    `;
+async function generateGroupBy(fs2, aggregationsDir, importExt = "") {
+  await fs2.mkdir(path16__namespace.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__namespace.join(aggregationsDir, "groupBy", `${key}.ts`), await formatTs(`export {${key}} from "./index${importExt}";`));
   }
-  function getV2Types() {
-    return `
-      export interface ${objectDefIdentifier} extends ObjectTypeDefinition<"${object.objectType.apiName}", ${object.objectType.apiName}> {
-        ${stringify(definition, {
-      type: () => void 0,
-      apiName: () => void 0,
-      links: (_value) => `{
-          ${stringify(definition.links, {
-        "*": (definition2) => `ObjectTypeLinkDefinition<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
-      })}
-        }`,
-      properties: (_value) => `{
-          ${stringify(definition.properties, {
-        "*": (propertyDefinition) => `PropertyDef<"${propertyDefinition.type}", "${propertyDefinition.nullable ? "nullable" : "non-nullable"}", "${propertyDefinition.multiplicity ? "array" : "single"}">`
-      })}
-        }`
-    })}
-      }
-
-    `;
+  await fs2.writeFile(path16__namespace.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__namespace.join(aggregationsDir, "metrics");
+  await fs2.mkdir(metricsDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__namespace.join(metricsDir, "metrics.ts"), await formatTs(`export {MetricValueType} from "@osdk/legacy-client";`));
+  await fs2.writeFile(path16__namespace.join(metricsDir, "ApproximateDistinctCountAggregatableProperty.ts"), await formatTs(reexportConsts(["ApproximateDistinctCountAggregatableProperty"]) + reexportTypes(["ApproximateDistinctCountAggregatableProperty"])));
+  await fs2.writeFile(path16__namespace.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__namespace.join(metricsDir, `${typeName}.ts`), await formatTs(`
+          import { MultipleAggregatableProperty } from "./MultipleAggregatableProperty${importExt}";
+        ` + reexportConsts([typeName])));
   }
-  const imports = Array.from(uniqueLinkTargetTypes).filter((type) => type !== definition.apiName).map((type) => `import type { ${getObjectDefIdentifier(type, v2)} } from "./${type}${importExt}";`);
-  return `${imports.join("\n")}
-
-    ${v2 ? getV2Types() : getV1Types()}
+  await fs2.writeFile(path16__namespace.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}";
+      `));
+}
 
-    export const ${object.objectType.apiName}: ${objectDefIdentifier} = {
-      ${stringify(definition)}
-    };`;
+// src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateAggregationsDir.ts
+async function generateAggregationsDir(fs2, runtimeDistDir, importExt = "") {
+  const aggregationsDir = path16__namespace.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__namespace.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__namespace.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__namespace.join(aggregationsDir, "CountOperation.ts"), await formatTs(`` + reexportConsts(["CountOperation", "isCountOperation"]) + reexportTypes(["CountOperation"])));
+  await fs2.writeFile(path16__namespace.join(aggregationsDir, "internalAggregationRequest.ts"), await formatTs(reexportTypes(["InternalAggregationRequest"])));
+}
+async function generateAttachmentsDir(attachmentsDir, fs2, importExt = "") {
+  await fs2.mkdir(attachmentsDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__namespace.default.join(attachmentsDir, "index.ts"), await formatTs(`export * from "./Attachment${importExt}";
+       export * from "./Attachments${importExt}";
+    `));
+  await fs2.writeFile(path16__namespace.default.join(attachmentsDir, "Attachment.ts"), await formatTs(reexportTypes(["Attachment", "AttachmentMetadata"])));
+  await fs2.writeFile(path16__namespace.default.join(attachmentsDir, "Attachments.ts"), await formatTs(reexportTypes(["Attachments"])));
 }
-
-// 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);
+async function generateGeoshapesDir(runtimeDistDir, fs2, importExt = "") {
+  await fs2.mkdir(runtimeDistDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__namespace.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__namespace.join(runtimeDistDir, "Distance.ts"), await formatTs(`` + reexportConsts(["Distance", "DistanceUnit"]) + reexportTypes(["Distance", "DistanceUnit"])));
+  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "GeoJson.ts"), await formatTs(reexportTypes(["GeoJsonPoint", "GeoJsonPolygon", "GeoJsonLineString", "GeoJsonMultiPoint", "GeoJsonMultiPolygon", "GeoJsonMultiLineString", "GeoJsonGeometryCollection", "GeoJsonGeometry", "GeoJson"])));
+  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "GeometryCollection.ts"), await formatTs(reexportConsts(["GeometryCollection"])));
+  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "GeoPoint.ts"), await formatTs(`` + reexportConsts(["isGeoPoint", "GeoPoint", "mapCoordinatesToGeoPoint"]) + reexportTypes(["GeoHash", "Coordinates", "GeoPoint"])));
+  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "GeoShape.ts"), await formatTs(reexportConsts(["GeoShape"]) + reexportTypes(["GeoShape"])));
+  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "LineString.ts"), await formatTs(reexportConsts(["LineString"]) + reexportTypes(["LineString"])));
+  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "MultiGeoPoint.ts"), await formatTs(reexportConsts(["MultiGeoPoint"]) + reexportTypes(["MultiGeoPoint"])));
+  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "MultiLineString.ts"), await formatTs(reexportConsts(["MultiLineString"]) + reexportTypes(["MultiLineString"])));
+  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "MultiPolygon.ts"), await formatTs(reexportConsts(["MultiPolygon"]) + reexportTypes(["MultiPolygon"])));
+  await fs2.writeFile(path16__namespace.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__namespace.default.join(objectSetDir, "index.ts"), await formatTs(`
+    export * from "./ObjectSetDefinition${importExt}";
+    export * from "./OntologyObjectSet${importExt}";
+    `));
+  await fs2.writeFile(path16__namespace.default.join(objectSetDir, "ObjectSetDefinition.ts"), await formatTs(reexportTypes(["BaseObjectSetDefinition", "ReferenceObjectSetDefinition", "StaticObjectSetDefinition", "IntersectObjectSetDefinition", "SubtractObjectSetDefinition", "SearchAroundObjectSetDefinition", "FilterObjectSetDefinition", "ObjectSetDefinition"])));
+  await fs2.writeFile(path16__namespace.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__namespace.default.join(sharedObjectCodeDir, "index.ts"), await formatTs(`
+    export * from "./FilteredPropertiesTerminalOperations${importExt}";
+    `));
+  await fs2.writeFile(path16__namespace.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__namespace.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__namespace.join(timeseriesDir, "TimeSeries.ts"), await formatTs(reexportTypes(["TimeSeries"], `<T extends number | string>`)));
+  await fs2.writeFile(path16__namespace.join(timeseriesDir, "TimeSeriesDuration.ts"), await formatTs(reexportTypes([`WhenUnit`, `DurationUnit`, `TimeSeriesDuration`])));
+  await fs2.writeFile(path16__namespace.join(timeseriesDir, "TimeSeriesPoint.ts"), await formatTs(reexportTypes(["TimeSeriesPoint"], `<T extends number | string>`)));
+  await fs2.writeFile(path16__namespace.join(timeseriesDir, "TimeSeriesQuery.ts"), await formatTs(reexportTypes(["TimeSeriesQuery"], `<T extends number | string>`)));
+  await fs2.writeFile(path16__namespace.join(timeseriesDir, "TimeSeriesTerminalOperations.ts"), await formatTs(reexportTypes(["TimeSeriesTerminalOperations", "TimeSeriesIterator"], `<T extends number | string>`)));
 }
 
-// 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 } 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}";
-  /** @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")}
+// src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateBaseTypesDir.ts
+async function generateBaseTypesDir(runtimeDistDir, fs2, importExt = "") {
+  const baseTypesDir = path16__namespace.join(runtimeDistDir, "baseTypes");
+  await fs2.mkdir(baseTypesDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__namespace.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__namespace.join(baseTypesDir, "geoshapes");
+  await generateGeoshapesDir(geoshapesDir, fs2, importExt);
+  const timeseriesDir = path16__namespace.join(baseTypesDir, "timeseries");
+  await generateTimeSeriesDir(timeseriesDir, fs2, importExt);
+  const attachmentsDir = path16__namespace.join(baseTypesDir, "attachments");
+  await generateAttachmentsDir(attachmentsDir, fs2, importExt);
+  const objectSetDir = path16__namespace.join(baseTypesDir, "objectset");
+  await generateObjectSetDir(objectSetDir, fs2, importExt);
+  const sharedObjectCodeDir = path16__namespace.join(baseTypesDir, "sharedObjectCode");
+  await generateSharedObjectCodeDir(sharedObjectCodeDir, fs2, importExt);
+  await fs2.writeFile(path16__namespace.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__namespace.join(baseTypesDir, "OntologyObject.ts"), await formatTs(reexportTypes(["OntologyObject"]) + reexportConsts(["isOntologyObject"])));
+  await fs2.writeFile(path16__namespace.join(baseTypesDir, "links.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject${importExt}` + reexportTypes(["SingleLink", "MultiLink"], "<T extends OntologyObject = OntologyObject>")));
+  await fs2.writeFile(path16__namespace.join(baseTypesDir, "localDate.ts"), await formatTs(reexportConsts(["LocalDate"]) + reexportTypes(["LocalDate"])));
+  await fs2.writeFile(path16__namespace.join(baseTypesDir, "timestamp.ts"), await formatTs(reexportConsts(["Timestamp"]) + reexportTypes(["Timestamp"])));
+  await fs2.writeFile(path16__namespace.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__namespace.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__namespace.default.join(runtimeDistDir, "client");
+  await fs2.mkdir(pagingDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__namespace.default.join(pagingDir, "index.ts"), await formatTs(`export * from "./clientOptions${importExt}";`));
+  await fs2.writeFile(path16__namespace.default.join(pagingDir, "clientOptions.ts"), await formatTs(`import {Auth} from "@osdk/legacy-client";` + reexportTypes(["FoundryClientOptions"], "<TAuth extends Auth = Auth>")));
 }
-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 "string";
-    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}`);
-  }
+async function generateFiltersDir(runtimeDistDir, fs2, importExt = "") {
+  const pagingDir = path16__namespace.default.join(runtimeDistDir, "filters");
+  await fs2.mkdir(pagingDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__namespace.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__namespace.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__namespace.default.join(pagingDir, "AttachmentFilter.ts"), await formatTs(reexportConsts(["AttachmentFilter"]) + reexportTypes(["AttachmentFilter"])));
+  await fs2.writeFile(path16__namespace.default.join(pagingDir, "BooleanFilter.ts"), await formatTs(reexportConsts(["BooleanFilter"]) + reexportTypes(["BooleanFilter"])));
+  await fs2.writeFile(path16__namespace.default.join(pagingDir, "GeoPointFilter.ts"), await formatTs(reexportConsts(["GeoPointFilter"]) + reexportTypes(["GeoPointFilter", "BoundingBox"])));
+  await fs2.writeFile(path16__namespace.default.join(pagingDir, "DateTimeFilters.ts"), await formatTs(reexportConsts(["TimestampFilter", "LocalDateFilter"]) + reexportTypes(["TimestampFilter", "LocalDateFilter"])));
+  await fs2.writeFile(path16__namespace.default.join(pagingDir, "GeoShapeFilter.ts"), await formatTs(reexportConsts(["GeoShapeFilter"]) + reexportTypes(["GeoShapeFilter"])));
+  await fs2.writeFile(path16__namespace.default.join(pagingDir, "NumericFilter.ts"), await formatTs(reexportConsts(["NumericFilter"]) + reexportTypes(["NumericFilter"])));
+  await fs2.writeFile(path16__namespace.default.join(pagingDir, "Op.ts"), await formatTs(reexportConsts(["Op"])));
+  await fs2.writeFile(path16__namespace.default.join(pagingDir, "OrderByOption.ts"), await formatTs(reexportConsts(["OrderByOption"]) + reexportTypes(["OrderByOption"])));
+  await fs2.writeFile(path16__namespace.default.join(pagingDir, "StringFilter.ts"), await formatTs(reexportConsts(["StringFilter"]) + reexportTypes(["StringFilter"])));
+  await fs2.writeFile(path16__namespace.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__namespace.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__namespace.join(ontologyProviderDir, "OntologyMetadata.ts"), await formatTs(reexportTypes(["OntologyMetadata"])));
+}
+async function generateResult(fs2, ontologyProviderDir) {
+  await fs2.writeFile(path16__namespace.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>")));
 }
-function getDescriptionIfPresent(description, includeNewline) {
-  if (description) {
-    return `/**
- * ${description}
- */${includeNewline ? "\n" : ""}`;
-  }
-  return "";
+
+// src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateOntologyProviderDir.ts
+async function generateOntologyProviderDir(fs2, runtimeDistDir, importExt = "") {
+  const ontologyProviderDir = path16__namespace.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__namespace.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__namespace.join(runtimeDistDir, "paging");
+  await fs2.mkdir(pagingDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__namespace.join(pagingDir, "index.ts"), await formatTs(`export * from "./Page${importExt}";`));
+  await fs2.writeFile(path16__namespace.join(pagingDir, "Page.ts"), await formatTs(reexportTypes(["Page"], "<T>")));
 }
 
-// src/v1.1/generatePerActionDataFiles.ts
-async function generatePerActionDataFiles(ontology, fs, outDir, importExt, v2) {
-  await fs.mkdir(outDir, {
+// src/v1.1/backcompat/generateOntologyRuntimeDistDir.ts
+async function generateOntologyRuntimeDistDir(outDir, fs2, importExt = "") {
+  const runtimeDistDir = path16__namespace.join(outDir, "internal", "@foundry", "ontology-runtime", "dist");
+  await fs2.mkdir(runtimeDistDir, {
     recursive: true
   });
-  await Promise.all(Object.values(ontology.actionTypes).map(async (action) => {
-    const uniqueApiNames = new Set(extractReferencedObjectsFromAction(action));
-    const uniqueApiNamesString = uniqueApiNames.size > 0 ? [...uniqueApiNames].map((apiName) => `"${apiName}"`).join("|") : "never";
-    const fullActionDef = deleteUndefineds(wireActionTypeV2ToSdkActionDefinition(action));
-    const {
-      parameters,
-      ...actionDefSansParameters
-    } = fullActionDef;
-    const actionDefIdentifier = `ActionDef$${action.apiName}`;
-    const paramsDefIdentifier = `${actionDefIdentifier}$Params`;
-    const paramsIdentifier = `${action.apiName}$Params`;
-    function createParamsDef() {
-      const entries = Object.entries(parameters);
-      entries.sort((a, b) => a[0].localeCompare(b[0]));
-      if (entries.length === 0) {
-        return `// Represents the definition of the parameters for the action
-          export type ${paramsDefIdentifier} = Record<string, never>;`;
+  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__namespace.join(runtimeDistDir, "index.ts"),
+    // TRASHFIXME
+    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 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}`);
       }
-      return `// Represents the definition of the parameters for the action
-        export type ${paramsDefIdentifier} = {
-          ${entries.map(([key, value]) => {
-        return `"${key}": {
-                ${stringify(value, {
-          description: (value2, d) => value2 ? d(value2) : void 0,
-          // trick to remove undefineds
-          type: (type) => {
-            if (typeof type === "string") {
-              return JSON.stringify(type);
-            } else if (type.type === "object") {
-              return `ObjectActionDataType<"${type.object}", ${getObjectDefIdentifier(type.object, v2)}>`;
-            } else if (type.type === "objectSet") {
-              return `ObjectSetActionDataType<"${type.objectSet}", ${getObjectDefIdentifier(type.objectSet, v2)}>`;
-            }
-            return void 0;
-          }
-        })}
-            }`;
-      }).join(";\n")}
-        }`;
+      parameterBlock += "}[], ";
+    } else {
+      parameterBlock = `params: Record<string,never>[], `;
     }
-    function createV2Types() {
-      return `
-        
-          ${createParamsDef()}
-          
+    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__namespace.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__namespace.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}";
 
-          // Represents the runtime arguments for the action
-          export type ${paramsIdentifier} = NOOP<OsdkActionParameters<${paramsDefIdentifier}>>;
+    export class FoundryClient<TAuth extends Auth = Auth> extends BaseFoundryClient<typeof Ontology, TAuth> {
+        constructor(options: FoundryClientOptions<TAuth>) {
+          super(options, Ontology);
+        }
 
-          
-          // Represents a fqn of the action
-          export interface ${action.apiName} {
-            ${getDescriptionIfPresent(action.description)}
-             <OP extends ApplyActionOptions>(args: ${paramsIdentifier}, options?: OP): Promise<ActionReturnTypeForOptions<OP>>;
-          }
+        get ontology(): Ontology {
+          return super.ontology;
+        }
+    }`));
+}
+async function generateIndexFile(fs2, outDir, importExt) {
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__namespace.join(outDir, "index.ts"), await formatTs(`
+    export * from "@osdk/legacy-client";
+    export type { Ontology } from "./Ontology${importExt}";
+    export { FoundryClient } from "./FoundryClient${importExt}";
+    `));
+}
 
-          
-          // Represents the definition of the action
-          export interface ${actionDefIdentifier} extends ActionDefinition<"${action.apiName}", ${uniqueApiNamesString}, ${action.apiName}>{
-          ${Object.entries(actionDefSansParameters).sort((a, b) => a[0].localeCompare(b[0])).map(([key, value]) => {
-        return `${key}: ${JSON.stringify(value)};`;
-      }).join("\n")}
-          parameters: ${paramsDefIdentifier}
-        }`;
+// src/util/commaSeparatedIdentifiers.ts
+function commaSeparatedIdentifiers(identifiers, alternateNames) {
+  return identifiers.map((i) => {
+    const alt = alternateNames?.get(i);
+    if (alt) {
+      return `${i}: ${alt}`;
     }
-    function createV2Object() {
-      return `  export const ${action.apiName}: ${actionDefIdentifier} = ${JSON.stringify(fullActionDef, null, 2)} `;
+    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);
     }
-    function createV1Object() {
-      return `  export const ${action.apiName} = ${JSON.stringify(fullActionDef, null, 2)} satisfies ActionDefinition<"${action.apiName}", ${uniqueApiNamesString}>;`;
+  }
+  for (const queryName of queryNames) {
+    if (seenIdentifiers.has(queryName)) {
+      queryAltNames.set(queryName, `${queryName}Query`);
     }
-    const referencedObjectDefs = /* @__PURE__ */ new Set();
-    for (const p of Object.values(action.parameters)) {
-      if (p.dataType.type === "object" || p.dataType.type === "objectSet") {
-        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.objectApiName, v2));
-        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.objectTypeApiName, v2));
-      }
-      if (p.dataType.type === "array" && (p.dataType.subType.type === "object" || p.dataType.subType.type === "objectSet")) {
-        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.subType.objectApiName, v2));
-        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.subType.objectTypeApiName, v2));
-      }
+  }
+  const getImportClause = (name, altNames) => {
+    const alt = altNames.get(name);
+    if (alt) {
+      return `${name} as ${alt}`;
+    } else {
+      return name;
     }
-    const importObjects = referencedObjectDefs.size > 0 ? `import type {${[...referencedObjectDefs].join(",")}} from "../objects${importExt}";` : "";
-    await fs.writeFile(path15__namespace.default.join(outDir, `${action.apiName}.ts`), await formatTs(`
-          import type { ActionDefinition, ObjectActionDataType, ObjectSetActionDataType } from "@osdk/api";
-          import type { ActionSignature, ApplyActionOptions, OsdkActionParameters,ActionReturnTypeForOptions, NOOP } from '@osdk/client';
-          ${importObjects}
-
-        
-          ${v2 ? createV2Types() : ""}
+  };
+  await fs2.writeFile(path16__namespace.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 { 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")}
 
-          ${v2 ? createV2Object() : createV1Object()}
-        `));
-  }));
-  await fs.writeFile(path15__namespace.default.join(outDir, `index.ts`), await formatTs(`
-      ${Object.values(ontology.actionTypes).map((action) => `export {${action.apiName}} from "./${action.apiName}${importExt}";`).join("\n")}
-    ${Object.keys(ontology.actionTypes).length === 0 ? "export {};" : ""}
-      `));
+  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;
+    bulkActions: BulkActions;
+    queries: Queries;
+}`));
 }
-function extractReferencedObjectsFromAction(actionType) {
-  const referencedObjectsInParameters = Object.values(actionType.parameters).flatMap(({
-    dataType
-  }) => {
-    const objectTypeReference = extractReferencedObjectsFromActionParameter(dataType);
-    return objectTypeReference ? [objectTypeReference] : [];
+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
   });
-  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 [];
+  await fs2.writeFile(path16__namespace.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")}
     }
-  });
-  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;
+async function generateObjectsInterfaceSupportFiles(ontology, fs2, outDir, importExt = "") {
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  for (const {
+    objectType: {
+      apiName
+    }
+  } of Object.values(ontology.objectTypes)) {
+    const fileName = path16.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 generatePerObjectInterfaceAndDataFiles(ontology, fs, outDir, importExt = "") {
-  await fs.mkdir(outDir, {
+async function generateOntologyIndexFile(fs2, outDir) {
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__namespace.join(outDir, "index.ts"), await formatTs(`
+        export type { ObjectSet } from "@osdk/legacy-client";
+    `));
+}
+async function generatePerObjectInterfaceAndDataFiles(ontology, fs2, outDir, importExt = "") {
+  await fs2.mkdir(outDir, {
     recursive: true
   });
   await Promise.all(Object.values(ontology.objectTypes).map(async (object) => {
     object.linkTypes;
-    await fs.writeFile(path15__namespace.default.join(outDir, `${object.objectType.apiName}.ts`), await formatTs(`
+    await fs2.writeFile(path16__namespace.default.join(outDir, `${object.objectType.apiName}.ts`), await formatTs(`
         import type { ObjectTypeDefinition, ObjectTypeLinkDefinition, PropertyDef } from "@osdk/api";
         ${wireObjectTypeV2ToObjectInterfaceStringV1(object, importExt)}
 
         ${wireObjectTypeV2ToSdkObjectConst(object, importExt)}
         `));
   }));
-  await fs.writeFile(path15__namespace.default.join(outDir, "index.ts"), await formatTs(`
+  await fs2.writeFile(path16__namespace.default.join(outDir, "index.ts"), await formatTs(`
     ${Object.keys(ontology.objectTypes).map((apiName) => `export * from "./${apiName}${importExt}";`).join("\n")}
       export type { ObjectSet } from "@osdk/legacy-client";
 
@@ -1340,18 +1355,18 @@ function wireQueryParameterV2ToQueryParameterDefinition(parameter) {
 }
 
 // src/v1.1/generatePerQueryDataFiles.ts
-async function generatePerQueryDataFiles(ontology, fs, outDir, importExt = "") {
-  await fs.mkdir(outDir, {
+async function generatePerQueryDataFiles(ontology, fs2, outDir, importExt = "") {
+  await fs2.mkdir(outDir, {
     recursive: true
   });
   await Promise.all(Object.values(ontology.queryTypes).map(async (query) => {
     const objectTypes = getObjectTypesFromQuery(query);
-    await fs.writeFile(path15__namespace.default.join(outDir, `${query.apiName}.ts`), await formatTs(`
+    await fs2.writeFile(path16__namespace.default.join(outDir, `${query.apiName}.ts`), await formatTs(`
         import { QueryDefinition } from "@osdk/api";
 
         export const ${query.apiName} = ${JSON.stringify(wireQueryTypeV2ToSdkQueryDefinition(query))} satisfies QueryDefinition<"${query.apiName}", ${objectTypes.length > 0 ? objectTypes.map((apiName) => `"${apiName}"`).join("|") : "never"}>;`));
   }));
-  await fs.writeFile(path15__namespace.default.join(outDir, "index.ts"), await formatTs(`
+  await fs2.writeFile(path16__namespace.default.join(outDir, "index.ts"), await formatTs(`
   ${Object.values(ontology.queryTypes).map((query) => `export * from "./${query.apiName}${importExt}";`).join("\n")}
   `));
 }
@@ -1405,7 +1420,7 @@ function getObjectTypesFromDataType(dataType, types) {
       throw new Error(`Cannot find object types from unsupported QueryDataType ${dataType.type}`);
   }
 }
-async function generateQueries(ontology, fs, outDir, importExt = "") {
+async function generateQueries(ontology, fs2, outDir, importExt = "") {
   const importedObjects = /* @__PURE__ */ new Set();
   const signatures = [];
   for (const query of Object.values(ontology.queryTypes)) {
@@ -1428,10 +1443,10 @@ async function generateQueries(ontology, fs, outDir, importExt = "") {
       ${query.apiName}(${param}): Promise<Result<QueryResponse<${outputType}>, QueryError>>;
       `);
   }
-  await fs.mkdir(outDir, {
+  await fs2.mkdir(outDir, {
     recursive: true
   });
-  await fs.writeFile(path15__namespace.default.join(outDir, "Queries.ts"), await formatTs(`
+  await fs2.writeFile(path16__namespace.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")}
 
@@ -1549,37 +1564,39 @@ function sanitizeDocTypeName(type) {
 }
 
 // src/v1.1/generateClientSdkVersionOneDotOne.ts
-async function generateClientSdkVersionOneDotOne(ontology, userAgent, fs, outDir, packageType = "commonjs") {
+async function generateClientSdkVersionOneDotOne(ontology, userAgent, fs2, outDir, packageType = "commonjs") {
   const importExt = packageType === "module" ? ".js" : "";
-  const objectsDir = path15__namespace.join(outDir, "ontology", "objects");
-  const actionsDir = path15__namespace.join(outDir, "ontology", "actions");
-  const queriesDir = path15__namespace.join(outDir, "ontology", "queries");
-  await verifyOutdir(outDir, fs);
-  await fs.mkdir(outDir, {
+  const objectsDir = path16__namespace.join(outDir, "ontology", "objects");
+  const actionsDir = path16__namespace.join(outDir, "ontology", "actions");
+  const queriesDir = path16__namespace.join(outDir, "ontology", "queries");
+  await verifyOutdir(outDir, fs2);
+  await fs2.mkdir(outDir, {
     recursive: true
   });
   const sanitizedOntology = sanitizeMetadata(ontology);
-  await generateFoundryClientFile(fs, outDir, importExt);
-  await generateMetadataFile(sanitizedOntology, userAgent, fs, outDir, importExt);
-  await generateOntologyIndexFile(fs, path15__namespace.join(outDir, "ontology"));
-  await generateObjectsInterfaceFile(sanitizedOntology, fs, objectsDir, importExt);
-  await generateObjectsInterfaceSupportFiles(sanitizedOntology, fs, path15__namespace.join(objectsDir, "objects-api"), importExt);
-  await generatePerObjectInterfaceAndDataFiles(sanitizedOntology, fs, objectsDir, importExt);
-  await generateActions(sanitizedOntology, fs, actionsDir, importExt);
-  await generateBulkActions(sanitizedOntology, fs, actionsDir, importExt);
-  await generatePerActionDataFiles(sanitizedOntology, fs, actionsDir, importExt, false);
-  await generateQueries(sanitizedOntology, fs, queriesDir, importExt);
-  await generatePerQueryDataFiles(sanitizedOntology, fs, queriesDir, importExt);
-  await generateIndexFile(fs, outDir, importExt);
-  await generateBackCompatDeprecatedExports(fs, outDir, importExt);
+  await generateFoundryClientFile(fs2, outDir, importExt);
+  await generateMetadataFile(sanitizedOntology, userAgent, fs2, outDir, importExt);
+  await generateOntologyIndexFile(fs2, path16__namespace.join(outDir, "ontology"));
+  await generateObjectsInterfaceFile(sanitizedOntology, fs2, objectsDir, importExt);
+  await generateObjectsInterfaceSupportFiles(sanitizedOntology, fs2, path16__namespace.join(objectsDir, "objects-api"), importExt);
+  await generatePerObjectInterfaceAndDataFiles(sanitizedOntology, fs2, objectsDir, importExt);
+  await generateActions(sanitizedOntology, fs2, actionsDir, importExt);
+  await generateBulkActions(sanitizedOntology, fs2, actionsDir, importExt);
+  await generatePerActionDataFiles(sanitizedOntology, fs2, actionsDir, importExt, false);
+  await generateQueries(sanitizedOntology, fs2, queriesDir, importExt);
+  await generatePerQueryDataFiles(sanitizedOntology, fs2, queriesDir, importExt);
+  await generateIndexFile(fs2, outDir, importExt);
+  await generateBackCompatDeprecatedExports(fs2, outDir, importExt);
 }
 function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, v2 = false) {
   const definition = deleteUndefineds(generatorConverters.__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(interfaceDef, v2));
   const objectDefIdentifier = getObjectDefIdentifier(interfaceDef.apiName, v2);
   function getV2Types() {
     return `
-  export interface ${objectDefIdentifier} extends InterfaceDefinition<"${interfaceDef.apiName}", ${interfaceDef.apiName}> {
+  export interface ${objectDefIdentifier} extends InterfaceDefinition<"${interfaceDef.apiName}", ${interfaceDef.apiName}>, VersionBound<$ExpectedClientVersion> {
+    osdkMetadata: typeof $osdkMetadata;
     ${stringify(definition, {
+      osdkMetadata: () => void 0,
       type: () => void 0,
       apiName: () => void 0,
       links: (_value) => `{
@@ -1603,39 +1620,52 @@ function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, v2 = false
     ${v2 ? getV2Types() : ""}
 
     export const ${definition.apiName}: ${objectDefIdentifier} = {
-      ${stringify(definition)}
+      osdkMetadata: $osdkMetadata,
+      ${stringify(definition, {
+    osdkMetadata: () => void 0
+  })}
+      
     };`;
 }
-async function generateOntologyMetadataFile(ontology, userAgent, fs, outDir) {
-  fs.writeFile(path15__namespace.default.join(outDir, "OntologyMetadata.ts"), await formatTs(`
-      export const OntologyMetadata = {
+var ExpectedOsdkVersion = "0.15.1";
+async function generateOntologyMetadataFile(ontology, userAgent, fs2, outDir) {
+  fs2.writeFile(path16__namespace.default.join(outDir, "OntologyMetadata.ts"), await formatTs(`
+      import { OntologyMetadata as OM } from "@osdk/api";
+
+      export type $ExpectedClientVersion = "${ExpectedOsdkVersion}";
+      export const $osdkMetadata = { extraUserAgent: "${userAgent}" };
+
+      export interface OntologyMetadata extends OM<$ExpectedClientVersion> {};
+
+      export const OntologyMetadata: OntologyMetadata = {
+        expectsClientVersion: "${ExpectedOsdkVersion}",
         ontologyRid: "${ontology.ontology.rid}",
         ontologyApiName: "${ontology.ontology.apiName}",
         userAgent: "${userAgent}",
-      }
+      };
       `));
 }
 
 // src/v2.0/generateClientSdkVersionTwoPointZero.ts
-async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs, outDir, packageType = "commonjs") {
-  await verifyOutdir(outDir, fs);
+async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs2, outDir, packageType = "commonjs") {
+  await verifyOutdir(outDir, fs2);
   const sanitizedOntology = sanitizeMetadata(ontology);
   const objectNames = Object.keys(sanitizedOntology.objectTypes).sort((a, b) => a.localeCompare(b));
   const actionNames = Object.keys(sanitizedOntology.actionTypes).sort((a, b) => a.localeCompare(b));
   Object.keys(sanitizedOntology.queryTypes).sort((a, b) => a.localeCompare(b));
   const interfaceNames = Object.keys(sanitizedOntology.interfaceTypes ?? {}).sort((a, b) => a.localeCompare(b));
   const importExt = packageType === "module" ? ".js" : "";
-  await fs.mkdir(outDir, {
+  await fs2.mkdir(outDir, {
     recursive: true
   });
-  fs.writeFile(path15__namespace.default.join(outDir, "index.ts"), await formatTs(`
+  fs2.writeFile(path16__namespace.default.join(outDir, "index.ts"), await formatTs(`
         export { Ontology } from "./Ontology${importExt}";
         export * from "./ontology/actions/index${importExt}";
         export * from "./ontology/objects${importExt}";
         export * from "./ontology/interfaces${importExt}";
     `));
-  await generateOntologyMetadataFile(sanitizedOntology, userAgent, fs, outDir);
-  await fs.writeFile(path15__namespace.default.join(outDir, "Ontology.ts"), await formatTs(`
+  await generateOntologyMetadataFile(sanitizedOntology, userAgent, fs2, outDir);
+  await fs2.writeFile(path16__namespace.default.join(outDir, "Ontology.ts"), await formatTs(`
       import type { OntologyDefinition } from "@osdk/api";
       import * as Actions from "./ontology/actions/index${importExt}";
       import * as Objects from "./ontology/objects${importExt}";
@@ -1670,25 +1700,27 @@ async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs, out
       export interface Ontology extends _Ontology {}
       export const Ontology = _Ontology as Ontology;
     `));
-  await fs.mkdir(path15__namespace.default.join(outDir, "ontology", "objects"), {
+  await fs2.mkdir(path16__namespace.default.join(outDir, "ontology", "objects"), {
     recursive: true
   });
   for (const name of objectNames) {
     const obj = ontology.objectTypes[name];
-    await fs.writeFile(path15__namespace.default.join(outDir, "ontology", `objects`, `${name}.ts`), await formatTs(`
-        import type { ObjectTypeDefinition, ObjectTypeLinkDefinition, PropertyDef } from "@osdk/api";
+    await fs2.writeFile(path16__namespace.default.join(outDir, "ontology", `objects`, `${name}.ts`), await formatTs(`
+        import type { ObjectTypeDefinition, VersionBound, ObjectTypeLinkDefinition, PropertyDef } from "@osdk/api";
         import { Osdk } from "@osdk/client";
+        import { $osdkMetadata } from "../../OntologyMetadata${importExt}";
+        import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
 
         ${wireObjectTypeV2ToSdkObjectConst(obj, importExt, true)}
       `));
   }
-  await generateOntologyInterfaces(fs, outDir, interfaceNames, ontology, importExt);
-  const actionsDir = path15__namespace.default.join(outDir, "ontology", "actions");
-  await fs.mkdir(actionsDir, {
+  await generateOntologyInterfaces(fs2, outDir, interfaceNames, ontology, importExt);
+  const actionsDir = path16__namespace.default.join(outDir, "ontology", "actions");
+  await fs2.mkdir(actionsDir, {
     recursive: true
   });
-  await generatePerActionDataFiles(sanitizedOntology, fs, actionsDir, importExt, true);
-  await fs.writeFile(path15__namespace.default.join(outDir, "ontology", "objects.ts"), await formatTs(`
+  await generatePerActionDataFiles(sanitizedOntology, fs2, actionsDir, importExt, true);
+  await fs2.writeFile(path16__namespace.default.join(outDir, "ontology", "objects.ts"), await formatTs(`
     ${Object.keys(ontology.objectTypes).sort((a, b) => a.localeCompare(b)).map((apiName) => `export * from "./objects/${apiName}${importExt}";`).join("\n")}
     ${Object.keys(ontology.objectTypes).length === 0 ? "export {};" : ""}
     `));
@@ -1700,26 +1732,129 @@ function stringUnionFrom2(values) {
     return values.map((v) => `"${v}"`).join("|");
   }
 }
-async function generateOntologyInterfaces(fs, outDir, interfaceNames, ontology, importExt) {
-  const interfacesDir = path15__namespace.default.join(outDir, "ontology", "interfaces");
-  await fs.mkdir(interfacesDir, {
+async function generateOntologyInterfaces(fs2, outDir, interfaceNames, ontology, importExt) {
+  const interfacesDir = path16__namespace.default.join(outDir, "ontology", "interfaces");
+  await fs2.mkdir(interfacesDir, {
     recursive: true
   });
   for (const name of interfaceNames) {
     const obj = ontology.interfaceTypes[name];
-    await fs.writeFile(path15__namespace.default.join(interfacesDir, `${name}.ts`), await formatTs(`
+    await fs2.writeFile(path16__namespace.default.join(interfacesDir, `${name}.ts`), await formatTs(`
     
-      import type { InterfaceDefinition, PropertyDef } from "@osdk/api";
+      import type { InterfaceDefinition, PropertyDef, VersionBound } from "@osdk/api";
+      import { $osdkMetadata, $expectedClientVersion } from "../../OntologyMetadata${importExt}";
+      import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
 
       ${__UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(obj, true)}
     `));
   }
-  await fs.writeFile(interfacesDir + ".ts", await formatTs(`
+  await fs2.writeFile(interfacesDir + ".ts", await formatTs(`
     ${Object.keys(ontology.interfaceTypes ?? {}).map((apiName) => `export * from "./interfaces/${apiName}${importExt}";`).join("\n")}
     ${Object.keys(ontology.interfaceTypes ?? {}).length === 0 ? "export {}" : ""}
     `));
 }
 
+// src/generateClientSdkPackage.ts
+async function generateClientSdkPackage(packageName, packageVersion, sdkVersion, baseOutDir, ontology, minimalFs, dependencyVersions, cliVersion) {
+  if (!packageName)
+    throw new Error("Package name is require");
+  for (const packageType of ["module", "commonjs"]) {
+    const outDir = path16__namespace.join(baseOutDir, "dist", packageType);
+    await (sdkVersion === "1.1" ? generateClientSdkVersionOneDotOne : sdkVersion === "2.0" ? generateClientSdkVersionTwoPointZero : void 0)(ontology, `typescript-sdk/${packageVersion} osdk-cli/${cliVersion}`, minimalFs, outDir, packageType);
+    await fs__namespace.promises.mkdir(outDir, {
+      recursive: true
+    });
+    await writeJson(minimalFs, path16__namespace.join(outDir, "package.json"), {
+      type: packageType
+    });
+    await writeJson(minimalFs, path16__namespace.join(outDir, `tsconfig.json`), {
+      compilerOptions: getTsCompilerOptions(packageType)
+    });
+  }
+  await writeJson(minimalFs, path16__namespace.join(baseOutDir, "package.json"), await getPackageJsonContents(packageName, packageVersion, sdkVersion, dependencyVersions));
+  await minimalFs.mkdir(path16__namespace.join(baseOutDir, "ontology"), {
+    recursive: true
+  });
+  await minimalFs.writeFile(path16__namespace.join(baseOutDir, "ontology", "objects.js"), `module.exports = require("../../dist/module/ontology/objects")`);
+  await minimalFs.writeFile(path16__namespace.join(baseOutDir, "ontology", "objects.d.ts"), `export * from "../dist/module/ontology/objects"`);
+}
+function getTsCompilerOptions(packageType) {
+  const commonTsconfig = {
+    importHelpers: true,
+    declaration: true,
+    isolatedModules: true,
+    esModuleInterop: true,
+    forceConsistentCasingInFileNames: true,
+    strict: true,
+    skipLibCheck: true
+  };
+  const compilerOptions = packageType === "commonjs" ? {
+    ...commonTsconfig,
+    module: "commonjs",
+    target: "es2018"
+  } : {
+    ...commonTsconfig,
+    module: "NodeNext",
+    target: "ES2020"
+  };
+  return compilerOptions;
+}
+function getPackageJsonContents(name, version, sdkVersion, {
+  typescriptVersion,
+  tslibVersion,
+  areTheTypesWrongVersion,
+  osdkApiVersion,
+  osdkClientVersion,
+  osdkLegacyClientVersion
+}) {
+  const esmPrefix = "./dist/module";
+  const commonjsPrefix = "./dist/commonjs";
+  return {
+    name,
+    version,
+    main: `${commonjsPrefix}/index.js`,
+    module: `${esmPrefix}/index.js`,
+    exports: {
+      ".": {
+        import: `${esmPrefix}/index.js`,
+        require: `${commonjsPrefix}/index.js`
+      },
+      "./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)"
+    },
+    devDependencies: {
+      "typescript": typescriptVersion,
+      "tslib": tslibVersion,
+      "@arethetypeswrong/cli": areTheTypesWrongVersion,
+      "@osdk/api": osdkApiVersion,
+      ...sdkVersion === "2.0" ? {
+        "@osdk/client": osdkClientVersion
+      } : {
+        "@osdk/legacy-client": osdkLegacyClientVersion
+      }
+    },
+    peerDependencies: {
+      "@osdk/api": osdkApiVersion,
+      ...sdkVersion === "2.0" ? {
+        "@osdk/client": osdkClientVersion
+      } : {
+        "@osdk/legacy-client": osdkLegacyClientVersion
+      }
+    },
+    files: ["**/*.js", "**/*.d.ts", "dist/**/package.json"]
+  };
+}
+async function writeJson(minimalFs, filePath, body) {
+  return await minimalFs.writeFile(filePath, JSON.stringify(body, void 0, 2) + "\n");
+}
+
+exports.__UNSTABLE_generateClientSdkPackage = generateClientSdkPackage;
 exports.generateClientSdkVersionOneDotOne = generateClientSdkVersionOneDotOne;
 exports.generateClientSdkVersionTwoPointZero = generateClientSdkVersionTwoPointZero;
 //# sourceMappingURL=out.js.map