@osdk/generator 1.0.1 → 1.0.3

package/build/js/index.mjs

@@ -1,68 +1,278 @@
-import * as d from 'path';
-import d__default, { join } from 'path';
+import * as path15 from 'path';
+import path15__default, { join } from 'path';
 import { format } from 'prettier';
-import at from 'prettier-plugin-organize-imports';
-
-function B(e){return {...e,actionTypes:Object.fromEntries(Object.values(e.actionTypes).map(t=>[ee(t.apiName),{...t,apiName:ee(t.apiName)}]))}}function ee(e){return e.replace(/-./g,t=>t[1].toUpperCase())}function N(e){let t=new Set,r=new Set;for(let n of e.operations)switch(n.type){case"createObject":t.add(n.objectTypeApiName);break;case"modifyObject":r.add(n.objectTypeApiName);break;}return {addedObjects:t,modifiedObjects:r}}function o(e){return format(e,{parser:"typescript",singleQuote:!0,trailingComma:"all",plugins:[at],tabWidth:2,printWidth:120})}async function te(e,t,r,n=""){let a=new Set,s=[];for(let c of Object.values(e.actionTypes)){let l=Object.entries(c.parameters),u=N(c),y=Array.from(u.addedObjects),w=Array.from(u.modifiedObjects);y.forEach(a.add,a),w.forEach(a.add,a);let p=["/**"];c.description&&p.push(`* ${c.description}`);let g="";if(l.length>0){g=`params: { 
-`;for(let[x,P]of l){g+=`"${x}"`,g+=P.required?": ":"?: ";let X=re(P.dataType,a);g+=`${X};
-`,p.push(`* @param {${X}} params.${x}`);}g+="}, ";}p.push("*/"),s.push(`
-      ${p.join(`
-`)}
-      ${c.apiName}<O extends ActionExecutionOptions>(${g}options?: O): 
-        Promise<Result<ActionResponseFromOptions<O, Edits<${y.length>0?y.join(" | "):"void"}, ${w.length>0?w.join(" | "):"void"}>>, ActionError>>;`);}await t.mkdir(r,{recursive:!0}),await t.writeFile(d__default.join(r,"Actions.ts"),await o(`
+import organizeImports from 'prettier-plugin-organize-imports';
+
+// src/v1.1/generateClientSdkVersionOneDotOne.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/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`);
+    }
+  } catch (e) {
+    if (e.code === "ENOENT") ; else {
+      throw e;
+    }
+  }
+}
+
+// src/shared/getEditedEntities.ts
+function getModifiedEntityTypes(action) {
+  const addedObjects = /* @__PURE__ */ new Set();
+  const modifiedObjects = /* @__PURE__ */ new Set();
+  for (const operation of action.operations) {
+    switch (operation.type) {
+      case "createObject":
+        addedObjects.add(operation.objectTypeApiName);
+        break;
+      case "modifyObject":
+        modifiedObjects.add(operation.objectTypeApiName);
+        break;
+    }
+  }
+  return {
+    addedObjects,
+    modifiedObjects
+  };
+}
+function formatTs(contents) {
+  return format(contents, {
+    parser: "typescript",
+    singleQuote: true,
+    trailingComma: "all",
+    plugins: [organizeImports],
+    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__default.join(outDir, "Actions.ts"), await formatTs(`
     import type { ObjectSet, LocalDate, Timestamp, Attachment, Edits, ActionExecutionOptions, ActionError, Result, ActionResponseFromOptions } from "@osdk/legacy-client";
-    ${Array.from(a).map(c=>`import type { ${c} } from "../objects/${c}${n}";`).join(`
-`)}
+    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
     export interface Actions {
-    ${s.join(`
-`)}
+    ${actionSignatures.join("\n")}
+    }
+  `));
+}
+function getTypeScriptTypeFromDataType(actionParameter, importedObjects) {
+  switch (actionParameter.type) {
+    case "objectSet": {
+      const objectType = actionParameter.objectTypeApiName;
+      importedObjects.add(objectType);
+      return `ObjectSet<${objectType}>`;
     }
-  `));}function re(e,t){switch(e.type){case"objectSet":{let n=e.objectTypeApiName;return t.add(n),`ObjectSet<${n}>`}case"object":{let n=e.objectTypeApiName;return t.add(n),`${n} | ${n}["__primaryKey"]`}case"array":return `Array<${re(e.subType,t)}>`;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";default:throw new Error(`Unsupported action parameter type: ${e}`)}}function m(e){return `
-          import  { ${e.map(t=>`${t} as OG_${t}`).join(", ")}} from "@osdk/legacy-client";
+    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`;
+    default:
+      throw new Error(`Unsupported action parameter type: ${actionParameter}`);
+  }
+}
+
+// src/v1.1/backcompat/util/reexportConsts.ts
+function reexportConsts(typesToExport) {
+  return `
+          import  { ${typesToExport.map((q) => `${q} as OG_${q}`).join(", ")}} from "@osdk/legacy-client";
       
-          ${e.map(t=>`
+          ${typesToExport.map((q) => `
       /** @deprecated submodule imports arent public api **/
-              export const ${t} = OG_${t};
-          `).join(`
+              export const ${q} = OG_${q};
+          `).join("\n\n")}
+      `;
+}
 
-`)}
-      `}async function oe(e,t){let r=d__default.join(t,"ConfidentialClient");await e.mkdir(r,{recursive:!0}),await e.writeFile(d__default.join(r,"index.ts"),await o(`
+// src/v1.1/backcompat/internal-foundry-oauth-dist/generateConfidentialClientDir.ts
+async function generateConfidentialClientDir(fs, oauthDistDir) {
+  const confidentialClientDistDir = path15__default.join(oauthDistDir, "ConfidentialClient");
+  await fs.mkdir(confidentialClientDistDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15__default.join(confidentialClientDistDir, "index.ts"), await formatTs(`
     export * from "./ConfidentialClientAuth";
-  `)),await e.writeFile(d__default.join(r,"ConfidentialClientAuth.ts"),await o(`
-        ${m(["ConfidentialClientAuth"])}
-    `));}async function ie(e,t){let r=d__default.join(t,"PublicClient");await e.mkdir(r,{recursive:!0}),await e.writeFile(d__default.join(r,"index.ts"),await o(`
+  `));
+  await fs.writeFile(path15__default.join(confidentialClientDistDir, "ConfidentialClientAuth.ts"), await formatTs(`
+        ${reexportConsts(["ConfidentialClientAuth"])}
+    `));
+}
+async function generatePublicClientDir(fs, oauthDistDir) {
+  const publicClientDistDir = path15__default.join(oauthDistDir, "PublicClient");
+  await fs.mkdir(publicClientDistDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15__default.join(publicClientDistDir, "index.ts"), await formatTs(`
     export * from "./PublicClientAuth";
-  `)),await e.writeFile(d__default.join(r,"PublicClientAuth.ts"),await o(`
-        ${m(["PublicClientAuth"])}
-    `));}async function ae(e,t){let r=d__default.join(t,"UserToken");await e.mkdir(r,{recursive:!0}),await e.writeFile(d__default.join(r,"index.ts"),await o(`
+  `));
+  await fs.writeFile(path15__default.join(publicClientDistDir, "PublicClientAuth.ts"), await formatTs(`
+        ${reexportConsts(["PublicClientAuth"])}
+    `));
+}
+async function generateUserTokenDir(fs, oauthDistDir) {
+  const userTokenDistDir = path15__default.join(oauthDistDir, "UserToken");
+  await fs.mkdir(userTokenDistDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15__default.join(userTokenDistDir, "index.ts"), await formatTs(`
     export * from "./UserTokenAuth";
-  `)),await e.writeFile(d__default.join(r,"UserTokenAuth.ts"),await o(`
-        ${m(["UserTokenAuth"])}
-    `));}function i(e,t="",r=ct(t)){return `
-    import type { ${e.map(n=>`${n} as OG_${n}`).join(", ")}} from "@osdk/legacy-client";
+  `));
+  await fs.writeFile(path15__default.join(userTokenDistDir, "UserTokenAuth.ts"), await formatTs(`
+        ${reexportConsts(["UserTokenAuth"])}
+    `));
+}
+
+// src/v1.1/backcompat/util/reexportTypes.ts
+function reexportTypes(typesToExport, genericArgsLeft = "", genericArgsRight = cleanup(genericArgsLeft)) {
+  return `
+    import type { ${typesToExport.map((q) => `${q} as OG_${q}`).join(", ")}} from "@osdk/legacy-client";
     
-        ${e.map(n=>`
+        ${typesToExport.map((q) => `
       /** @deprecated submodule imports arent public api **/
-      export type ${n}${t} = OG_${n}${r};
-    `).join(`
+      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(",")}>`;
+}
 
-`)}
-    `}var st=/<(.*?)>/,pt=/^\s?(.+?)( extends .*?)?( = .*?)?\s?$/;function ct(e){return e.length===0?"":`<${st.exec(e)?.[1]?.split(",")?.map(r=>pt.exec(r)?.[1]??r)?.join(",")}>`}async function ne(e,t){let r=d.join(e,"internal","@foundry","oauth-client","dist");await t.mkdir(r,{recursive:!0}),await t.writeFile(d.join(r,"index.ts"),await o(`
+// src/v1.1/backcompat/generateOAuthDistDir.ts
+async function generateOAuthClientDistDir(outDir, fs) {
+  const oauthDistDir = path15.join(outDir, "internal", "@foundry", "oauth-client", "dist");
+  await fs.mkdir(oauthDistDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15.join(oauthDistDir, "index.ts"), await formatTs(`
     export * from "./Auth";
     export * from "./ConfidentialClient";
     export * from "./OAuthClient";
     export * from "./PublicClient";
     export * from "./Token";
     export * from "./UserToken";
-`)),await t.writeFile(d.join(r,"Auth.ts"),await o(i(["Auth"]))),await t.writeFile(d.join(r,"Token.ts"),await o(i(["Token","TokenValue"]))),await t.writeFile(d.join(r,"OAuthClient.ts"),await o(i(["AuthSubscription","UnsubscribeFunction","SignInResponse","RefreshResponse","SignOutResponse"]))),await t.writeFile(d.join(r,"OAuthToken.ts"),await o(m(["OAuthToken"]))),await t.writeFile(d.join(r,"Auth.ts"),await o(i(["Auth"]))),await oe(t,r),await ie(t,r),await ae(t,r);}async function pe(e,t){await e.writeFile(d.join(t,"Aggregations.ts"),await o(`
+`));
+  await fs.writeFile(path15.join(oauthDistDir, "Auth.ts"), await formatTs(reexportTypes(["Auth"])));
+  await fs.writeFile(path15.join(oauthDistDir, "Token.ts"), await formatTs(reexportTypes(["Token", "TokenValue"])));
+  await fs.writeFile(path15.join(oauthDistDir, "OAuthClient.ts"), await formatTs(reexportTypes(["AuthSubscription", "UnsubscribeFunction", "SignInResponse", "RefreshResponse", "SignOutResponse"])));
+  await fs.writeFile(path15.join(oauthDistDir, "OAuthToken.ts"), await formatTs(reexportConsts(["OAuthToken"])));
+  await fs.writeFile(path15.join(oauthDistDir, "Auth.ts"), await formatTs(reexportTypes(["Auth"])));
+  await generateConfidentialClientDir(fs, oauthDistDir);
+  await generatePublicClientDir(fs, oauthDistDir);
+  await generateUserTokenDir(fs, oauthDistDir);
+}
+async function generateAggregationsAggregations(fs, aggregationsDir) {
+  await fs.writeFile(path15.join(aggregationsDir, "Aggregations.ts"), await formatTs(`
       import { LocalDate, Timestamp } from "@osdk/legacy-client";
-      `+i(["Double","Rangeable","MetricValue","Date","BucketKey","BucketValue","TimeUnit","BucketGroup","Metrics","AggregatableProperties","AggregationClause"])+i(["Range"],"<T extends Rangeable>","<T>")+i(["BaseGroupBy"],"<_T extends BucketValue = BucketValue>")+i(["Duration"],"<_T extends Timestamp | LocalDate = Timestamp | LocalDate>")+i(["AggregatableProperty","MultipleAggregationsOperations"],"<_T extends MetricValue = MetricValue>")+i(["AggregationGroup"],"<TMetrics extends Metrics | MetricValue, TBucketGroup extends BucketGroup>")+i(["Bucketing"],"<_T extends string , _X extends BucketValue>")+i(["AggregationResult"],"<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue>")+i(["BaseBucketing"],"<TBucketKey extends BucketKey, TBucketValue extends BucketValue, Kind extends string>")+i(["ExactValueBucketing","InternalBucketing"],"<TBucketKey extends BucketKey, TBucketValue extends BucketValue>")+i(["RangeBucketing","FixedWidthBucketing"],"<TBucketKey extends BucketKey, TBucketValue extends Range<Rangeable>>")+i(["DurationBucketing"],"<TBucketKey extends BucketKey, TBucketValue extends Date>")+i(["InternalBucketingVisitor"],"<TBucketKey extends BucketKey, T extends BucketValue, R>")+i(["AggregationBuilderResult"],"<T, TMultipleAggregationProperties>")+i(["AggregatablePropertiesForResult","AggregatablePropertyNamesForResult"],"<TAggregatableProperties, TResult extends MetricValue>")+m(["assertBucketingInternal","visitInternalBucketing"])+i(["AggregatableObjectSetStep"],"<TAggregatableProperties, TMultipleAggregationProperties, TBucketableProperties, TBucketGroup extends BucketGroup = {}>")+i(["GroupedTerminalAggregationOperations"],"<TAggregatableProperties, TMultipleAggregationProperties, TBucketGroup extends BucketGroup = {}>")));}async function ce(e,t){await e.mkdir(d.join(t,"groupBy"),{recursive:!0});let r=["BooleanGroupBy","LocalDateGroupBy","NumericGroupBy","StringGroupBy","TimestampGroupBy"],n=[...r,"GroupKeyType"];for(let a of n)await e.writeFile(d.join(t,"groupBy",`${a}.ts`),await o(`export {${a}} from "./index";`));await e.writeFile(d.join(t,"groupBy","index.ts"),await o('import { Bucketing, BucketKey, Duration, Range, Rangeable } from "../Aggregations";'+m(r)+i(r,"<T extends BucketKey>")+`export {GroupKeyType} from "@osdk/legacy-client";
-          `));}async function me(e,t){let r=d.join(t,"metrics");await e.mkdir(r,{recursive:!0}),await e.writeFile(d.join(r,"metrics.ts"),await o('export {MetricValueType} from "@osdk/legacy-client";')),await e.writeFile(d.join(r,"ApproximateDistinctCountAggregatableProperty.ts"),await o(m(["ApproximateDistinctCountAggregatableProperty"])+i(["ApproximateDistinctCountAggregatableProperty"]))),await e.writeFile(d.join(r,"MultipleAggregatableProperty.ts"),await o(`
+      ` + 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) {
+  await fs.mkdir(path15.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.join(aggregationsDir, "groupBy", `${key}.ts`), await formatTs(`export {${key}} from "./index";`));
+  }
+  await fs.writeFile(path15.join(aggregationsDir, "groupBy", "index.ts"), await formatTs(`import { Bucketing, BucketKey, Duration, Range, Rangeable } from "../Aggregations";` + reexportConsts(groupBys) + reexportTypes(groupBys, "<T extends BucketKey>") + `export {GroupKeyType} from "@osdk/legacy-client";
+          `));
+}
+async function generateMetrics(fs, aggregationsDir) {
+  const metricsDir = path15.join(aggregationsDir, "metrics");
+  await fs.mkdir(metricsDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15.join(metricsDir, "metrics.ts"), await formatTs(`export {MetricValueType} from "@osdk/legacy-client";`));
+  await fs.writeFile(path15.join(metricsDir, "ApproximateDistinctCountAggregatableProperty.ts"), await formatTs(reexportConsts(["ApproximateDistinctCountAggregatableProperty"]) + reexportTypes(["ApproximateDistinctCountAggregatableProperty"])));
+  await fs.writeFile(path15.join(metricsDir, "MultipleAggregatableProperty.ts"), await formatTs(`
         import { Double, MetricValue, MultipleAggregationsOperations } from "../Aggregations";
         import { MetricValueType } from "./metrics";
-      `+m(["MultipleAggregatableProperty"])+i(["MultipleAggregatableProperty"],"<TResult extends MetricValue = Double>")));for(let n of ["DefaultAggregatableProperty","LocalDatePropertyMetric","NumericPropertyMetric","TimestampPropertyMetric"])await e.writeFile(d.join(r,`${n}.ts`),await o(`
+      ` + reexportConsts(["MultipleAggregatableProperty"]) + reexportTypes(["MultipleAggregatableProperty"], "<TResult extends MetricValue = Double>")));
+  for (const typeName of ["DefaultAggregatableProperty", "LocalDatePropertyMetric", "NumericPropertyMetric", "TimestampPropertyMetric"]) {
+    await fs.writeFile(path15.join(metricsDir, `${typeName}.ts`), await formatTs(`
           import { MultipleAggregatableProperty } from "./MultipleAggregatableProperty";
-        `+m([n])));await e.writeFile(d.join(r,"index.ts"),await o(`
+        ` + reexportConsts([typeName])));
+  }
+  await fs.writeFile(path15.join(metricsDir, "index.ts"), await formatTs(`
       export * from "./ApproximateDistinctCountAggregatableProperty";
       export * from "./DefaultAggregatableProperty";
       export * from "./LocalDatePropertyMetric";
@@ -70,9 +280,21 @@ function B(e){return {...e,actionTypes:Object.fromEntries(Object.values(e.action
       export * from "./MultipleAggregatableProperty";
       export * from "./NumericPropertyMetric";
       export * from "./TimestampPropertyMetric";
-      `));}async function le(e,t){let r=d.join(t,"aggregations");await e.mkdir(r,{recursive:!0}),await ce(e,r),await pe(e,r),await me(e,r),await e.writeFile(d.join(r,"index.ts"),await o(`
-    
-    
+      `));
+}
+
+// src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateAggregationsDir.ts
+async function generateAggregationsDir(fs, runtimeDistDir) {
+  const aggregationsDir = path15.join(runtimeDistDir, "aggregations");
+  await fs.mkdir(aggregationsDir, {
+    recursive: true
+  });
+  await generateGroupBy(fs, aggregationsDir);
+  await generateAggregationsAggregations(fs, aggregationsDir);
+  await generateMetrics(fs, aggregationsDir);
+  await fs.writeFile(path15.join(aggregationsDir, "index.ts"), await formatTs(`
+    ${""}
+    ${""}
     
     export * from "./Aggregations";
     export * from "./ComputeStep";
@@ -80,16 +302,33 @@ function B(e){return {...e,actionTypes:Object.fromEntries(Object.values(e.action
     export * from "./groupBy";
     export * from "./internalAggregationRequest";
     export * from "./metrics";
-  `)),await e.writeFile(d.join(r,"ComputeStep.ts"),await o(`
+  `));
+  await fs.writeFile(path15.join(aggregationsDir, "ComputeStep.ts"), await formatTs(`
       import { ObjectSetDefinition } from "../baseTypes";
       import { FoundryClientOptions } from "../client";
       import { AggregateObjectsError, OntologyMetadata, Result } from "../ontologyProvider";
       import { AggregationClause, AggregationResult, BucketGroup, BucketValue, InternalBucketing, Metrics, MetricValue } from "./Aggregations";
-      `+m(["ComputeStep"])+i(["ComputeStep"],"<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue> ")+i(["AggregationComputeStep"],"<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue>")+`
+      ` + reexportConsts(["ComputeStep"]) + reexportTypes(["ComputeStep"], "<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue> ") + reexportTypes(["AggregationComputeStep"], "<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue>") + `
     
-    `)),await e.writeFile(d.join(r,"CountOperation.ts"),await o(""+m(["CountOperation","isCountOperation"])+i(["CountOperation"]))),await e.writeFile(d.join(r,"internalAggregationRequest.ts"),await o(i(["InternalAggregationRequest"])));}async function ue(e,t){await t.mkdir(e,{recursive:!0}),await t.writeFile(d__default.join(e,"index.ts"),await o(`export * from "./Attachment";
+    `));
+  await fs.writeFile(path15.join(aggregationsDir, "CountOperation.ts"), await formatTs(`` + reexportConsts(["CountOperation", "isCountOperation"]) + reexportTypes(["CountOperation"])));
+  await fs.writeFile(path15.join(aggregationsDir, "internalAggregationRequest.ts"), await formatTs(reexportTypes(["InternalAggregationRequest"])));
+}
+async function generateAttachmentsDir(attachmentsDir, fs) {
+  await fs.mkdir(attachmentsDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15__default.join(attachmentsDir, "index.ts"), await formatTs(`export * from "./Attachment";
        export * from "./Attachments";
-    `)),await t.writeFile(d__default.join(e,"Attachment.ts"),await o(i(["Attachment","AttachmentMetadata"]))),await t.writeFile(d__default.join(e,"Attachments.ts"),await o(i(["Attachments"])));}async function ye(e,t){await t.mkdir(e,{recursive:!0}),await t.writeFile(d.join(e,"index.ts"),await o(`export * from "./Distance";
+    `));
+  await fs.writeFile(path15__default.join(attachmentsDir, "Attachment.ts"), await formatTs(reexportTypes(["Attachment", "AttachmentMetadata"])));
+  await fs.writeFile(path15__default.join(attachmentsDir, "Attachments.ts"), await formatTs(reexportTypes(["Attachments"])));
+}
+async function generateGeoshapesDir(runtimeDistDir, fs) {
+  await fs.mkdir(runtimeDistDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15.join(runtimeDistDir, "index.ts"), await formatTs(`export * from "./Distance";
        export * from "./GeoJson";
        export * from "./GeometryCollection";
        export * from "./GeoPoint";
@@ -98,19 +337,64 @@ function B(e){return {...e,actionTypes:Object.fromEntries(Object.values(e.action
        export * from "./MultiGeoPoint";
        export * from "./MultiLineString";
        export * from "./MultiPolygon";
-       export * from "./Polygon";`)),await t.writeFile(d.join(e,"Distance.ts"),await o(""+m(["Distance","DistanceUnit"])+i(["Distance","DistanceUnit"]))),await t.writeFile(d.join(e,"GeoJson.ts"),await o(i(["GeoJsonPoint","GeoJsonPolygon","GeoJsonLineString","GeoJsonMultiPoint","GeoJsonMultiPolygon","GeoJsonMultiLineString","GeoJsonGeometryCollection","GeoJsonGeometry","GeoJson"]))),await t.writeFile(d.join(e,"GeometryCollection.ts"),await o(m(["GeometryCollection"]))),await t.writeFile(d.join(e,"GeoPoint.ts"),await o(""+m(["isGeoPoint","GeoPoint","mapCoordinatesToGeoPoint"])+i(["GeoHash","Coordinates","GeoPoint"]))),await t.writeFile(d.join(e,"GeoShape.ts"),await o(m(["GeoShape"])+i(["GeoShape"]))),await t.writeFile(d.join(e,"LineString.ts"),await o(m(["LineString"])+i(["LineString"]))),await t.writeFile(d.join(e,"MultiGeoPoint.ts"),await o(m(["MultiGeoPoint"])+i(["MultiGeoPoint"]))),await t.writeFile(d.join(e,"MultiLineString.ts"),await o(m(["MultiLineString"])+i(["MultiLineString"]))),await t.writeFile(d.join(e,"MultiPolygon.ts"),await o(m(["MultiPolygon"])+i(["MultiPolygon"]))),await t.writeFile(d.join(e,"Polygon.ts"),await o(m(["Polygon"])+i(["LinearRing","Polygon"])));}async function ge(e,t){await t.mkdir(e,{recursive:!0}),await t.writeFile(d__default.join(e,"index.ts"),await o(`
+       export * from "./Polygon";`));
+  await fs.writeFile(path15.join(runtimeDistDir, "Distance.ts"), await formatTs(`` + reexportConsts(["Distance", "DistanceUnit"]) + reexportTypes(["Distance", "DistanceUnit"])));
+  await fs.writeFile(path15.join(runtimeDistDir, "GeoJson.ts"), await formatTs(reexportTypes(["GeoJsonPoint", "GeoJsonPolygon", "GeoJsonLineString", "GeoJsonMultiPoint", "GeoJsonMultiPolygon", "GeoJsonMultiLineString", "GeoJsonGeometryCollection", "GeoJsonGeometry", "GeoJson"])));
+  await fs.writeFile(path15.join(runtimeDistDir, "GeometryCollection.ts"), await formatTs(reexportConsts(["GeometryCollection"])));
+  await fs.writeFile(path15.join(runtimeDistDir, "GeoPoint.ts"), await formatTs(`` + reexportConsts(["isGeoPoint", "GeoPoint", "mapCoordinatesToGeoPoint"]) + reexportTypes(["GeoHash", "Coordinates", "GeoPoint"])));
+  await fs.writeFile(path15.join(runtimeDistDir, "GeoShape.ts"), await formatTs(reexportConsts(["GeoShape"]) + reexportTypes(["GeoShape"])));
+  await fs.writeFile(path15.join(runtimeDistDir, "LineString.ts"), await formatTs(reexportConsts(["LineString"]) + reexportTypes(["LineString"])));
+  await fs.writeFile(path15.join(runtimeDistDir, "MultiGeoPoint.ts"), await formatTs(reexportConsts(["MultiGeoPoint"]) + reexportTypes(["MultiGeoPoint"])));
+  await fs.writeFile(path15.join(runtimeDistDir, "MultiLineString.ts"), await formatTs(reexportConsts(["MultiLineString"]) + reexportTypes(["MultiLineString"])));
+  await fs.writeFile(path15.join(runtimeDistDir, "MultiPolygon.ts"), await formatTs(reexportConsts(["MultiPolygon"]) + reexportTypes(["MultiPolygon"])));
+  await fs.writeFile(path15.join(runtimeDistDir, "Polygon.ts"), await formatTs(reexportConsts(["Polygon"]) + reexportTypes(["LinearRing", "Polygon"])));
+}
+async function generateObjectSetDir(objectSetDir, fs) {
+  await fs.mkdir(objectSetDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15__default.join(objectSetDir, "index.ts"), await formatTs(`
     export * from "./ObjectSetDefinition";
     export * from "./OntologyObjectSet";
-    `)),await t.writeFile(d__default.join(e,"ObjectSetDefinition.ts"),await o(i(["BaseObjectSetDefinition","ReferenceObjectSetDefinition","StaticObjectSetDefinition","IntersectObjectSetDefinition","SubtractObjectSetDefinition","SearchAroundObjectSetDefinition","FilterObjectSetDefinition","ObjectSetDefinition"]))),await t.writeFile(d__default.join(e,"OntologyObjectSet.ts"),await o(i(["OntologyObjectSet"])));}async function fe(e,t){await t.mkdir(e,{recursive:!0}),await t.writeFile(d__default.join(e,"index.ts"),await o(`
+    `));
+  await fs.writeFile(path15__default.join(objectSetDir, "ObjectSetDefinition.ts"), await formatTs(reexportTypes(["BaseObjectSetDefinition", "ReferenceObjectSetDefinition", "StaticObjectSetDefinition", "IntersectObjectSetDefinition", "SubtractObjectSetDefinition", "SearchAroundObjectSetDefinition", "FilterObjectSetDefinition", "ObjectSetDefinition"])));
+  await fs.writeFile(path15__default.join(objectSetDir, "OntologyObjectSet.ts"), await formatTs(reexportTypes(["OntologyObjectSet"])));
+}
+async function generateSharedObjectCodeDir(sharedObjectCodeDir, fs) {
+  await fs.mkdir(sharedObjectCodeDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15__default.join(sharedObjectCodeDir, "index.ts"), await formatTs(`
     export * from "./FilteredPropertiesTerminalOperations";
-    `)),await t.writeFile(d__default.join(e,"FilteredPropertiesTerminalOperations.ts"),await o('import { OntologyObject } from "../OntologyObject'+i(["FilteredPropertiesTerminalOperations","FilteredPropertiesTerminalOperationsWithGet"],"<T extends OntologyObject, V extends Array<keyof T>>")));}async function Te(e,t){await t.mkdir(e,{recursive:!0}),await t.writeFile(d.join(e,"index.ts"),await o(`
+    `));
+  await fs.writeFile(path15__default.join(sharedObjectCodeDir, "FilteredPropertiesTerminalOperations.ts"), await formatTs(`import { OntologyObject } from "../OntologyObject` + reexportTypes(["FilteredPropertiesTerminalOperations", "FilteredPropertiesTerminalOperationsWithGet"], "<T extends OntologyObject, V extends Array<keyof T>>")));
+}
+async function generateTimeSeriesDir(timeseriesDir, fs) {
+  await fs.mkdir(timeseriesDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15.join(timeseriesDir, "index.ts"), await formatTs(`
     export * from "./TimeSeries";
     export * from "./TimeSeriesDuration";
     export * from "./TimeSeriesPoint";
-    
+    ${""}
     export * from "./TimeSeriesQuery";
     export * from "./TimeSeriesTerminalOperations";
-  `)),await t.writeFile(d.join(e,"TimeSeries.ts"),await o(i(["TimeSeries"],"<T extends number | string>"))),await t.writeFile(d.join(e,"TimeSeriesDuration.ts"),await o(i(["WhenUnit","DurationUnit","TimeSeriesDuration"]))),await t.writeFile(d.join(e,"TimeSeriesPoint.ts"),await o(i(["TimeSeriesPoint"],"<T extends number | string>"))),await t.writeFile(d.join(e,"TimeSeriesQuery.ts"),await o(i(["TimeSeriesQuery"],"<T extends number | string>"))),await t.writeFile(d.join(e,"TimeSeriesTerminalOperations.ts"),await o(i(["TimeSeriesTerminalOperations","TimeSeriesIterator"],"<T extends number | string>")));}async function we(e,t){let r=d.join(e,"baseTypes");await t.mkdir(r,{recursive:!0}),await t.writeFile(d.join(r,"index.ts"),await o(`export * from "./ActionType";
+  `));
+  await fs.writeFile(path15.join(timeseriesDir, "TimeSeries.ts"), await formatTs(reexportTypes(["TimeSeries"], `<T extends number | string>`)));
+  await fs.writeFile(path15.join(timeseriesDir, "TimeSeriesDuration.ts"), await formatTs(reexportTypes([`WhenUnit`, `DurationUnit`, `TimeSeriesDuration`])));
+  await fs.writeFile(path15.join(timeseriesDir, "TimeSeriesPoint.ts"), await formatTs(reexportTypes(["TimeSeriesPoint"], `<T extends number | string>`)));
+  await fs.writeFile(path15.join(timeseriesDir, "TimeSeriesQuery.ts"), await formatTs(reexportTypes(["TimeSeriesQuery"], `<T extends number | string>`)));
+  await fs.writeFile(path15.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) {
+  const baseTypesDir = path15.join(runtimeDistDir, "baseTypes");
+  await fs.mkdir(baseTypesDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15.join(baseTypesDir, "index.ts"), await formatTs(`export * from "./ActionType";
       export * from "./attachments";
       export * from "./geoshapes";
       export * from "./links";
@@ -120,9 +404,41 @@ function B(e){return {...e,actionTypes:Object.fromEntries(Object.values(e.action
       export * from "./OntologyObject";
       export * from "./Queries";
       export * from "./timeseries";
-      export * from "./timestamp";`));let n=d.join(r,"geoshapes");await ye(n,t);let a=d.join(r,"timeseries");await Te(a,t);let s=d.join(r,"attachments");await ue(s,t);let c=d.join(r,"objectset");await ge(c,t);let l=d.join(r,"sharedObjectCode");await fe(l,t),await t.writeFile(d.join(r,"ActionType.ts"),await o(`import { OntologyObject } from "./OntologyObject";
-      `+m(["ActionExecutionMode","ReturnEditsMode","ActionValidationResult"])+i(["ActionExecutionOptions","ValidationResponse","BulkEdits"])+i(["CreatedObjectEdits","ModifiedObjectEdits"],"<T extends OntologyObject>")+i(["Edits"],"<TAddedObjects extends OntologyObject | void, TModifiedObjects extends OntologyObject | void>")+i(["ActionResponse"],"<TEdits extends Edits<any, any> | undefined = undefined>","<TEdits>")+i(["ActionResponseFromOptions"],"<TOptions extends ActionExecutionOptions | undefined = undefined, TEdits extends Edits<any, any> | undefined = undefined>","<TOptions, TEdits>"))),await t.writeFile(d.join(r,"OntologyObject.ts"),await o(i(["OntologyObject"])+m(["isOntologyObject"]))),await t.writeFile(d.join(r,"links.ts"),await o('import { OntologyObject } from "./OntologyObject'+i(["SingleLink","MultiLink"],"<T extends OntologyObject = OntologyObject>"))),await t.writeFile(d.join(r,"localDate.ts"),await o(m(["LocalDate"])+i(["LocalDate"]))),await t.writeFile(d.join(r,"timestamp.ts"),await o(m(["Timestamp"])+i(["Timestamp"]))),await t.writeFile(d.join(r,"Queries.ts"),await o(`import { BucketValue, Range, Rangeable } from "../aggregations";
-      `+i(["QueryResponse"],"<T>")+i(["BaseBucket"],"<K, V>")+i(["NestedBucket"],"<TGroupKey, TSegmentKey, TValue extends BucketValue>")+i(["TwoDimensionalAggregation"],"<TGroupKey extends QueryBucketKey, TValue extends BucketValue = number>")+i(["ThreeDimensionalAggregation"],"<TGroupKey extends QueryBucketKey, TSegmentKey extends QueryBucketKey, TValue extends BucketValue = number>")+i(["QueryBucketKey"]))),await t.writeFile(d.join(r,"ObjectType.ts"),await o('import { OntologyObject } from "./OntologyObject";'+i(["BaseType","StringType","IntegerType","DateType","BooleanType","ByteType","DecimalType","FloatType","TimestampType","ShortType","LongType","DoubleType","GeoPointType","GeoShapeType","AttachmentType","ObjectType","StructField","QueryBucketRangeableType","QueryBucketKeyType","QueryBucketValueType","AllValueTypes","OntologyType","ObjectTypeProperties","StructType"])+i(["TimeSeriesType","ArrayType","SetType"],"<T extends BaseType>")+i(["Property"],"<TType extends OntologyType = OntologyType>")+i(["BaseObjectType"],"<TOntologyObject extends OntologyObject = OntologyObject>")+i(["ObjectSetType"],"<T extends ObjectType>")+i(["RangeType"],"<T extends QueryBucketRangeableType>")+i(["TwoDimensionalAggregationType"],"<TGroupKey extends QueryBucketKeyType, TValue extends QueryBucketValueType>")+i(["ThreeDimensionalAggregationType"],"<TGroupKey extends QueryBucketKeyType, TSegmentKey extends QueryBucketKeyType, TValue extends QueryBucketValueType>")));}async function je(e,t){let r=d__default.join(e,"client");await t.mkdir(r,{recursive:!0}),await t.writeFile(d__default.join(r,"index.ts"),await o('export * from "./clientOptions";')),await t.writeFile(d__default.join(r,"clientOptions.ts"),await o('import {Auth} from "@osdk/legacy-client";'+i(["FoundryClientOptions"],"<TAuth extends Auth = Auth>")));}async function be(e,t){let r=d__default.join(e,"filters");await t.mkdir(r,{recursive:!0}),await t.writeFile(d__default.join(r,"index.ts"),await o(`export * from "./ArrayFilter";
+      export * from "./timestamp";`));
+  const geoshapesDir = path15.join(baseTypesDir, "geoshapes");
+  await generateGeoshapesDir(geoshapesDir, fs);
+  const timeseriesDir = path15.join(baseTypesDir, "timeseries");
+  await generateTimeSeriesDir(timeseriesDir, fs);
+  const attachmentsDir = path15.join(baseTypesDir, "attachments");
+  await generateAttachmentsDir(attachmentsDir, fs);
+  const objectSetDir = path15.join(baseTypesDir, "objectset");
+  await generateObjectSetDir(objectSetDir, fs);
+  const sharedObjectCodeDir = path15.join(baseTypesDir, "sharedObjectCode");
+  await generateSharedObjectCodeDir(sharedObjectCodeDir, fs);
+  await fs.writeFile(path15.join(baseTypesDir, "ActionType.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject";
+      ` + 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.join(baseTypesDir, "OntologyObject.ts"), await formatTs(reexportTypes(["OntologyObject"]) + reexportConsts(["isOntologyObject"])));
+  await fs.writeFile(path15.join(baseTypesDir, "links.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject` + reexportTypes(["SingleLink", "MultiLink"], "<T extends OntologyObject = OntologyObject>")));
+  await fs.writeFile(path15.join(baseTypesDir, "localDate.ts"), await formatTs(reexportConsts(["LocalDate"]) + reexportTypes(["LocalDate"])));
+  await fs.writeFile(path15.join(baseTypesDir, "timestamp.ts"), await formatTs(reexportConsts(["Timestamp"]) + reexportTypes(["Timestamp"])));
+  await fs.writeFile(path15.join(baseTypesDir, "Queries.ts"), await formatTs(`import { BucketValue, Range, Rangeable } from "../aggregations";
+      ` + 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.join(baseTypesDir, "ObjectType.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject";` + 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) {
+  const pagingDir = path15__default.join(runtimeDistDir, "client");
+  await fs.mkdir(pagingDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15__default.join(pagingDir, "index.ts"), await formatTs(`export * from "./clientOptions";`));
+  await fs.writeFile(path15__default.join(pagingDir, "clientOptions.ts"), await formatTs(`import {Auth} from "@osdk/legacy-client";` + reexportTypes(["FoundryClientOptions"], "<TAuth extends Auth = Auth>")));
+}
+async function generateFiltersDir(runtimeDistDir, fs) {
+  const pagingDir = path15__default.join(runtimeDistDir, "filters");
+  await fs.mkdir(pagingDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15__default.join(pagingDir, "index.ts"), await formatTs(`export * from "./ArrayFilter";
       export * from "./AttachmentFilter";
       export * from "./BooleanFilter";
       export * from "./DateTimeFilters";
@@ -132,28 +448,96 @@ function B(e){return {...e,actionTypes:Object.fromEntries(Object.values(e.action
       export * from "./NumericFilter";
       export * from "./Op";
       export * from "./OrderByOption";
-      export * from "./StringFilter";`)),await t.writeFile(d__default.join(r,"ArrayFilter.ts"),await o('import { Attachment, GeoPoint, GeoShape, LocalDate, Timestamp } from "../baseTypes";'+m(["ArrayFilter"])+i(["ArrayFilter"],"<T extends string | number | Timestamp | LocalDate | boolean | GeoShape | GeoPoint | Attachment>"))),await t.writeFile(d__default.join(r,"AttachmentFilter.ts"),await o(m(["AttachmentFilter"])+i(["AttachmentFilter"]))),await t.writeFile(d__default.join(r,"BooleanFilter.ts"),await o(m(["BooleanFilter"])+i(["BooleanFilter"]))),await t.writeFile(d__default.join(r,"GeoPointFilter.ts"),await o(m(["GeoPointFilter"])+i(["GeoPointFilter","BoundingBox"]))),await t.writeFile(d__default.join(r,"DateTimeFilters.ts"),await o(m(["TimestampFilter","LocalDateFilter"])+i(["TimestampFilter","LocalDateFilter"]))),await t.writeFile(d__default.join(r,"GeoShapeFilter.ts"),await o(m(["GeoShapeFilter"])+i(["GeoShapeFilter"]))),await t.writeFile(d__default.join(r,"NumericFilter.ts"),await o(m(["NumericFilter"])+i(["NumericFilter"]))),await t.writeFile(d__default.join(r,"Op.ts"),await o(m(["Op"]))),await t.writeFile(d__default.join(r,"OrderByOption.ts"),await o(m(["OrderByOption"])+i(["OrderByOption"]))),await t.writeFile(d__default.join(r,"StringFilter.ts"),await o(m(["StringFilter"])+i(["StringFilter"]))),await t.writeFile(d__default.join(r,"Filters.ts"),await o('import { OntologyObject } from "@osdk/legacy-client";'+i(["ObjectTypeFilterFunction","ObjectTypeOrderByFunction"],"<T extends OntologyObject>")+i(["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"])+i(["FilterType"],"<T extends string | number>")));}async function xe(e,t){await e.writeFile(d.join(t,"Errors.ts"),await o(i(["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 Ae(e,t){await e.writeFile(d.join(t,"OntologyMetadata.ts"),await o(i(["OntologyMetadata"])));}async function Fe(e,t){await e.writeFile(d.join(t,"Result.ts"),await o(`import {FoundryApiError} from "@osdk/legacy-client";
-        `+i(["Ok","Err"],"<T>")+i(["Result"],"<V, E = FoundryApiError>","<V,E>")+m(["isOk","isErr","visitError"])+i(["ErrorVisitor"],"<E extends FoundryApiError, R>","<E,R>")+i(["ExtractKeysWithType"],"<T, K extends keyof T>","<T,K>")));}async function ke(e,t){let r=d.join(t,"ontologyProvider");await e.mkdir(r,{recursive:!0}),await xe(e,r),await Ae(e,r),await Fe(e,r),await e.writeFile(d.join(r,"index.ts"),await o(`
-    
+      export * from "./StringFilter";`));
+  await fs.writeFile(path15__default.join(pagingDir, "ArrayFilter.ts"), await formatTs(`import { Attachment, GeoPoint, GeoShape, LocalDate, Timestamp } from "../baseTypes";` + reexportConsts(["ArrayFilter"]) + reexportTypes(["ArrayFilter"], "<T extends string | number | Timestamp | LocalDate | boolean | GeoShape | GeoPoint | Attachment>")));
+  await fs.writeFile(path15__default.join(pagingDir, "AttachmentFilter.ts"), await formatTs(reexportConsts(["AttachmentFilter"]) + reexportTypes(["AttachmentFilter"])));
+  await fs.writeFile(path15__default.join(pagingDir, "BooleanFilter.ts"), await formatTs(reexportConsts(["BooleanFilter"]) + reexportTypes(["BooleanFilter"])));
+  await fs.writeFile(path15__default.join(pagingDir, "GeoPointFilter.ts"), await formatTs(reexportConsts(["GeoPointFilter"]) + reexportTypes(["GeoPointFilter", "BoundingBox"])));
+  await fs.writeFile(path15__default.join(pagingDir, "DateTimeFilters.ts"), await formatTs(reexportConsts(["TimestampFilter", "LocalDateFilter"]) + reexportTypes(["TimestampFilter", "LocalDateFilter"])));
+  await fs.writeFile(path15__default.join(pagingDir, "GeoShapeFilter.ts"), await formatTs(reexportConsts(["GeoShapeFilter"]) + reexportTypes(["GeoShapeFilter"])));
+  await fs.writeFile(path15__default.join(pagingDir, "NumericFilter.ts"), await formatTs(reexportConsts(["NumericFilter"]) + reexportTypes(["NumericFilter"])));
+  await fs.writeFile(path15__default.join(pagingDir, "Op.ts"), await formatTs(reexportConsts(["Op"])));
+  await fs.writeFile(path15__default.join(pagingDir, "OrderByOption.ts"), await formatTs(reexportConsts(["OrderByOption"]) + reexportTypes(["OrderByOption"])));
+  await fs.writeFile(path15__default.join(pagingDir, "StringFilter.ts"), await formatTs(reexportConsts(["StringFilter"]) + reexportTypes(["StringFilter"])));
+  await fs.writeFile(path15__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.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.join(ontologyProviderDir, "OntologyMetadata.ts"), await formatTs(reexportTypes(["OntologyMetadata"])));
+}
+async function generateResult(fs, ontologyProviderDir) {
+  await fs.writeFile(path15.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) {
+  const ontologyProviderDir = path15.join(runtimeDistDir, "ontologyProvider");
+  await fs.mkdir(ontologyProviderDir, {
+    recursive: true
+  });
+  await generateErrors(fs, ontologyProviderDir);
+  await generateOntologyMetadata(fs, ontologyProviderDir);
+  await generateResult(fs, ontologyProviderDir);
+  await fs.writeFile(path15.join(ontologyProviderDir, "index.ts"), await formatTs(`
+    ${""}
       export * from "./Errors";
       export * from "./OntologyMetadata";
-      
-    
+      ${""}
+    ${""}
       // export * from "./Result";
-  `));}async function Se(e,t){let r=d.join(e,"paging");await t.mkdir(r,{recursive:!0}),await t.writeFile(d.join(r,"index.ts"),await o('export * from "./Page";')),await t.writeFile(d.join(r,"Page.ts"),await o(i(["Page"],"<T>")));}async function Pe(e,t){let r=d.join(e,"internal","@foundry","ontology-runtime","dist");await t.mkdir(r,{recursive:!0}),await ke(t,r),await le(t,r),await Se(r,t),await we(r,t),await je(r,t),await be(r,t),await t.writeFile(d.join(r,"index.ts"),await o(`
+  `));
+}
+async function generatePagingDir(runtimeDistDir, fs) {
+  const pagingDir = path15.join(runtimeDistDir, "paging");
+  await fs.mkdir(pagingDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15.join(pagingDir, "index.ts"), await formatTs(`export * from "./Page";`));
+  await fs.writeFile(path15.join(pagingDir, "Page.ts"), await formatTs(reexportTypes(["Page"], "<T>")));
+}
+
+// src/v1.1/backcompat/generateOntologyRuntimeDistDir.ts
+async function generateOntologyRuntimeDistDir(outDir, fs) {
+  const runtimeDistDir = path15.join(outDir, "internal", "@foundry", "ontology-runtime", "dist");
+  await fs.mkdir(runtimeDistDir, {
+    recursive: true
+  });
+  await generateOntologyProviderDir(fs, runtimeDistDir);
+  await generateAggregationsDir(fs, runtimeDistDir);
+  await generatePagingDir(runtimeDistDir, fs);
+  await generateBaseTypesDir(runtimeDistDir, fs);
+  await generateClientDir(runtimeDistDir, fs);
+  await generateFiltersDir(runtimeDistDir, fs);
+  await fs.writeFile(
+    path15.join(runtimeDistDir, "index.ts"),
+    // TRASHFIXME
+    await formatTs(`
       export * from "./aggregations";
       export * from "./baseTypes";
-      
+      ${""}
       // export * from "./filters";
-      
-      
+      ${""}
+      ${""}
     
       export * from "./ontologyProvider";
       export * from "./paging";
-`));}async function De(e,t){await Pe(t,e),await ne(t,e);}async function Be(e,t,r=""){await e.writeFile(d__default.join(t,"FoundryClient.ts"),await o(`
+`)
+  );
+}
+
+// src/v1.1/generateBackCompatDeprecatedExports.ts
+async function generateBackCompatDeprecatedExports(fs, outDir) {
+  await generateOntologyRuntimeDistDir(outDir, fs);
+  await generateOAuthClientDistDir(outDir, fs);
+}
+async function generateFoundryClientFile(fs, outDir, importExt = "") {
+  await fs.writeFile(path15__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${r}";
+    import { Ontology } from "./Ontology${importExt}";
 
     export class FoundryClient<TAuth extends Auth = Auth> extends BaseFoundryClient<typeof Ontology, TAuth> {
         constructor(options: FoundryClientOptions<TAuth>) {
@@ -163,199 +547,1050 @@ function B(e){return {...e,actionTypes:Object.fromEntries(Object.values(e.action
         get ontology(): Ontology {
           return super.ontology;
         }
-    }`));}async function Ce(e,t,r){await e.mkdir(t,{recursive:!0}),await e.writeFile(d.join(t,"index.ts"),await o(`
+    }`));
+}
+async function generateIndexFile(fs, outDir, importExt) {
+  await fs.mkdir(outDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15.join(outDir, "index.ts"), await formatTs(`
     export * from "@osdk/legacy-client";
-    export type { Ontology } from "./Ontology${r}";
-    export { FoundryClient } from "./FoundryClient${r}";
-    `));}function G(e,t){return e.map(r=>{let n=t?.get(r);return n?`${r}: ${n}`:r}).join(",")}function E(e,t){return e.map(r=>`${r}: typeof ${t?.get(r)??r}`).join(",")}async function Me(e,t,r,n=""){let a=Object.keys(e.objectTypes),s=Object.keys(e.actionTypes),c=Object.keys(e.queryTypes),l=new Map,u=new Map,y=new Set(a);for(let p of s)y.has(p)?l.set(p,`${p}Action`):y.add(p);for(let p of c)y.has(p)&&u.set(p,`${p}Query`);let w=(p,g)=>{let x=g.get(p);return x?`${p} as ${x}`:p};await t.writeFile(d__default.join(r,"Ontology.ts"),await o(`
+    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, 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__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${n}";
-  import type { Actions } from "./ontology/actions/Actions${n}";
-  import type { Queries } from "./ontology/queries/Queries${n}";
-  ${a.map(p=>`import {${p}} from "./ontology/objects/${p}${n}";`).join(`
-`)}
-  ${s.map(p=>`import {${w(p,l)}} from "./ontology/actions/${p}${n}";`).join(`
-`)}
-  ${c.map(p=>`import {${w(p,u)}} from "./ontology/queries/${p}${n}";`).join(`
-`)}
+  import type { Objects } from "./ontology/objects/Objects${importExt}";
+  import type { Actions } from "./ontology/actions/Actions${importExt}";
+  import type { Queries } from "./ontology/queries/Queries${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: "${e.ontology.rid}",
-      ontologyApiName: "${e.ontology.apiName}",
+      ontologyRid: "${ontology.ontology.rid}",
+      ontologyApiName: "${ontology.ontology.apiName}",
       userAgent: "foundry-typescript-osdk/0.0.1",
     },
     objects: {
-      ${E(a)}
+      ${commaSeparatedTypeIdentifiers(objectNames)}
     },
     actions: {
-      ${E(s,l)}
+      ${commaSeparatedTypeIdentifiers(actionNames, actionAltNames)}
     },
     queries: {
-      ${E(c,u)}
+      ${commaSeparatedTypeIdentifiers(queryNames, queryAltNames)}
     },
   } = {
     metadata: {
-        ontologyRid: "${e.ontology.rid}" as const,
-        ontologyApiName: "${e.ontology.apiName}" as const,
+        ontologyRid: "${ontology.ontology.rid}" as const,
+        ontologyApiName: "${ontology.ontology.apiName}" as const,
         userAgent: "foundry-typescript-osdk/0.0.1" as const,
     },
     objects: {
-        ${G(a)}
+        ${commaSeparatedIdentifiers(objectNames)}
     },
     actions: {
-        ${G(s,l)}
+        ${commaSeparatedIdentifiers(actionNames, actionAltNames)}
     },
     queries: {
-        ${G(c,u)}
+        ${commaSeparatedIdentifiers(queryNames, queryAltNames)}
     }
-  } satisfies OntologyDefinition<${a.map(p=>`"${p}"`).join("|")}, ${Object.values(e.actionTypes).map(p=>`"${p.apiName}"`).join("|")}, ${Object.values(e.queryTypes).map(p=>`"${p.apiName}"`).join("|")}>;
+  } 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;
     queries: Queries;
-}`));}async function Ge(e,t,r,n=""){await t.mkdir(r,{recursive:!0}),await t.writeFile(d__default.join(r,"Objects.ts"),await o(`
+}`));
+}
+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__default.join(outDir, "Objects.ts"), await formatTs(`
     import { BaseObjectSet } from "@osdk/legacy-client";
-    ${Array.from(Object.keys(e.objectTypes)).map(a=>`import type { ${a} } from "./${a}${n}";`).join(`
-`)}
+    ${Array.from(Object.keys(ontology.objectTypes)).map((importedObject) => `import type { ${importedObject} } from "./${importedObject}${importExt}";`).join("\n")}
     
     export interface Objects {
-      ${Object.keys(e.objectTypes).map(a=>`${a} : BaseObjectSet<${a}>;`).join(`
-`)}
+      ${Object.keys(ontology.objectTypes).map((apiName) => `${apiName} : BaseObjectSet<${apiName}>;`).join("\n")}
     }
-    ;`));}async function Ee(e,t,r,n=""){await t.mkdir(r,{recursive:!0});for(let{objectType:{apiName:a}}of Object.values(e.objectTypes)){let s=join(r,`${a}.ts`),c=`OG_${a}`,l=[];l.push('import { ObjectSetAggregateArg, ObjectSetFilterArg, ObjectSetGroupByArg, ObjectSetMultipleAggregateArg, ObjectSetOrderByArg } from "@osdk/legacy-client";'),l.push(`import { ${a} as ${c} } from "../${a}${n}";`),l.push(""),l.push(`/** @deprecated Use ${a} from ontology/objects instead */`,`export type ${a} = ${c};`),l.push(`/** @deprecated Use ObjectSetFilterArg<${a}> instead */`,`export type ${a}Filter = ObjectSetFilterArg<${c}>;`),l.push(`/** @deprecated Use ObjectSetOrderByArg<${a}> instead */`,`export type ${a}OrderBy = ObjectSetOrderByArg<${c}>;`),l.push(`/** @deprecated Use ObjectSetGroupByArg<${a}> instead */`,`export type ${a}GroupByProperties = ObjectSetGroupByArg<${c}>;`),l.push(`
+    ;`));
+}
+async function generateObjectsInterfaceSupportFiles(ontology, fs, outDir, importExt = "") {
+  await fs.mkdir(outDir, {
+    recursive: true
+  });
+  for (const {
+    objectType: {
+      apiName
+    }
+  } of Object.values(ontology.objectTypes)) {
+    const fileName = join(outDir, `${apiName}.ts`);
+    const localApiName = `OG_${apiName}`;
+    const contents = [];
+    contents.push(`import { ObjectSetAggregateArg, ObjectSetFilterArg, ObjectSetGroupByArg, ObjectSetMultipleAggregateArg, ObjectSetOrderByArg } from "@osdk/legacy-client";`);
+    contents.push(`import { ${apiName} as ${localApiName} } from "../${apiName}${importExt}";`);
+    contents.push("");
+    contents.push(`/** @deprecated Use ${apiName} from ontology/objects instead */`, `export type ${apiName} = ${localApiName};`);
+    contents.push(`/** @deprecated Use ObjectSetFilterArg<${apiName}> instead */`, `export type ${apiName}Filter = ObjectSetFilterArg<${localApiName}>;`);
+    contents.push(`/** @deprecated Use ObjectSetOrderByArg<${apiName}> instead */`, `export type ${apiName}OrderBy = ObjectSetOrderByArg<${localApiName}>;`);
+    contents.push(`/** @deprecated Use ObjectSetGroupByArg<${apiName}> instead */`, `export type ${apiName}GroupByProperties = ObjectSetGroupByArg<${localApiName}>;`);
+    contents.push(`
       /**
-        * Aggregation properties for ${a}
-        * @deprecated Use ObjectSetAggregateArg<${a}> instead
-        */`,`export type ${a}AggregationProperties = ObjectSetAggregateArg<${c}>;`),l.push(`
+        * Aggregation properties for ${apiName}
+        * @deprecated Use ObjectSetAggregateArg<${apiName}> instead
+        */`, `export type ${apiName}AggregationProperties = ObjectSetAggregateArg<${localApiName}>;`);
+    contents.push(`
       /**
-        * Multiple aggregation properties for ${a}.
-        * @deprecated Use ObjectSetMultipleAggregateArg<${a}> instead
-        */`,`export type ${a}MultipleAggregationProperties = ObjectSetMultipleAggregateArg<${c}>;`),await t.writeFile(s,l.join(`
-`));}}async function Ve(e,t){await e.mkdir(t,{recursive:!0}),await e.writeFile(d.join(t,"index.ts"),await o(`
+        * 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.join(outDir, "index.ts"), await formatTs(`
         export type { ObjectSet } from "@osdk/legacy-client";
-    `));}function Re(e){let t=N(e);return {apiName:e.apiName,parameters:Object.fromEntries(Object.entries(e.parameters).map(([r,n])=>[r,gt(n)])),displayName:e.displayName,description:e.description,modifiedEntities:dt(t.addedObjects,t.modifiedObjects)}}function gt(e){switch(e.dataType.type){case"string":case"boolean":case"object":case"attachment":case"date":case"double":case"integer":case"long":case"objectSet":case"timestamp":return {multiplicity:!1,type:W(e.dataType),nullable:!e.required,description:e.description};case"array":return {multiplicity:!0,type:W(e.dataType),nullable:!e.required,description:e.description}}}function W(e){switch(e.type){case"string":case"boolean":case"attachment":case"double":case"integer":case"long":case"timestamp":return e.type;case"date":return "datetime";case"objectSet":return {type:"objectSet",objectSet:e.objectTypeApiName};case"object":return {type:"object",object:e.objectTypeApiName};case"array":return W(e.subType)}}function dt(e,t){let r={};for(let n of e)r[n]={created:!0,modified:!1};for(let n of t)r[n]?r[n].modified=!0:r[n]={created:!1,modified:!0};return r}async function v(e,t,r,n=""){await t.mkdir(r,{recursive:!0}),await Promise.all(Object.values(e.actionTypes).map(async a=>{let s=new Set(ft(a));await t.writeFile(d__default.join(r,`${a.apiName}.ts`),await o(`
+    `));
+}
+
+// src/shared/wireActionTypeV2ToSdkActionDefinition.ts
+function wireActionTypeV2ToSdkActionDefinition(input) {
+  const modifiedEntityTypes = getModifiedEntityTypes(input);
+  return {
+    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) {
+  switch (value.dataType.type) {
+    case "string":
+    case "boolean":
+    case "object":
+    case "attachment":
+    case "date":
+    case "double":
+    case "integer":
+    case "long":
+    case "objectSet":
+    case "timestamp":
+      return {
+        multiplicity: false,
+        type: actionPropertyToSdkPropertyDefinition(value.dataType),
+        nullable: value.required ? false : true,
+        description: value.description
+      };
+    case "array":
+      return {
+        multiplicity: true,
+        type: actionPropertyToSdkPropertyDefinition(value.dataType),
+        nullable: value.required ? false : true,
+        description: value.description
+      };
+  }
+}
+function actionPropertyToSdkPropertyDefinition(parameterType) {
+  switch (parameterType.type) {
+    case "string":
+    case "boolean":
+    case "attachment":
+    case "double":
+    case "integer":
+    case "long":
+    case "timestamp":
+      return parameterType.type;
+    case "date":
+      return "datetime";
+    case "objectSet":
+      return {
+        type: "objectSet",
+        objectSet: parameterType.objectTypeApiName
+      };
+    case "object":
+      return {
+        type: "object",
+        object: parameterType.objectTypeApiName
+      };
+    case "array":
+      return actionPropertyToSdkPropertyDefinition(parameterType.subType);
+  }
+}
+function createModifiedEntities(addedObjects, modifiedObjects) {
+  let entities = {};
+  for (const key of addedObjects) {
+    entities[key] = {
+      created: true,
+      modified: false
+    };
+  }
+  for (const key of modifiedObjects) {
+    if (entities[key]) {
+      entities[key].modified = true;
+    } else {
+      entities[key] = {
+        created: false,
+        modified: true
+      };
+    }
+  }
+  return entities;
+}
+
+// src/v1.1/generatePerActionDataFiles.ts
+async function generatePerActionDataFiles(ontology, fs, outDir, importExt = "") {
+  await fs.mkdir(outDir, {
+    recursive: true
+  });
+  await Promise.all(Object.values(ontology.actionTypes).map(async (action) => {
+    const uniqueApiNames = new Set(extractReferencedObjectsFromAction(action));
+    await fs.writeFile(path15__default.join(outDir, `${action.apiName}.ts`), await formatTs(`
           import { ActionDefinition } from "@osdk/api";
   
-           export const ${a.apiName} = ${JSON.stringify(Re(a),null,2)} satisfies ActionDefinition<"${a.apiName}", ${s.size>0?[...s].map(c=>`"${c}"`).join("|"):"never"}>;`));})),await t.writeFile(d__default.join(r,"index.ts"),await o(`
-      ${Object.values(e.actionTypes).map(a=>`export * from "./${a.apiName}${n}";`).join(`
-`)}
-      `));}function ft(e){let t=Object.values(e.parameters).flatMap(({dataType:n})=>{let a=Qe(n);return a?[a]:[]});return [...e.operations.flatMap(n=>{switch(n.type){case"createObject":return [n.objectTypeApiName];case"modifyObject":return [n.objectTypeApiName];case"deleteObject":case"createLink":case"deleteLink":return []}}),...t]}function Qe(e){switch(e.type){case"objectSet":case"object":return e.objectTypeApiName;case"array":return Qe(e.subType);case"string":case"boolean":case"attachment":case"date":case"double":case"integer":case"long":case"timestamp":return}}function Ke(e){switch(e.dataType.type){case"integer":case"double":case"string":case"boolean":case"attachment":case"byte":case"decimal":case"float":case"geopoint":case"geoshape":case"long":case"short":return e.dataType.type;case"date":return "datetime";case"timestamp":return "timestamp";case"timeseries":case"array":throw new Error(`Type not supported for primaryKey: ${e.dataType.type}`);default:e.dataType;throw new Error(`Unknown type encountered for primaryKey: ${e.dataType}`)}}function V(e,t=!0){switch(e.dataType.type){case"integer":case"string":case"byte":case"decimal":case"double":case"float":case"long":case"short":case"boolean":case"date":case"attachment":case"geopoint":case"geoshape":case"timestamp":case"timeseries":return {multiplicity:!1,description:e.description,type:z(e.dataType),nullable:t};case"array":return {multiplicity:!0,description:e.description,type:z(e.dataType),nullable:!0};default:e.dataType;throw new Error(`Unexpected data type ${JSON.stringify(e.dataType)}`)}}function z(e){switch(e.type){case"integer":case"string":case"byte":case"decimal":case"double":case"float":case"long":case"short":case"boolean":case"attachment":case"geopoint":case"geoshape":case"timestamp":return e.type;case"date":return "datetime";case"array":return z(e.subType);case"timeseries":return e.itemType.type==="string"?"stringTimeseries":"numericTimeseries";default:throw new Error(`Unexecpected data type ${e}`)}}function _e(e,t){if(e.objectType.properties[e.objectType.primaryKey]===void 0)throw new Error(`Primary key ${e.objectType.primaryKey} not found in ${e.objectType.apiName}`);return {apiName:e.objectType.apiName,description:e.objectType.description,primaryKeyType:Ke(e.objectType.properties[e.objectType.primaryKey]),links:Object.fromEntries(e.linkTypes.map(r=>[r.apiName,{multiplicity:r.cardinality==="MANY",targetType:r.objectTypeApiName}])),properties:Object.fromEntries(Object.entries(e.objectType.properties).map(([r,n])=>[r,V(n,!(t&&e.objectType.primaryKey===r))]))}}function R(e,t=!1){let r=new Set(e.linkTypes.map(n=>n.objectTypeApiName));return `
-    export const ${e.objectType.apiName} = ${JSON.stringify(_e(e,t),null,2)} satisfies ObjectTypeDefinition<"${e.objectType.apiName}", ${r.size>0?[...r].map(n=>`"${n}"`).join("|"):"never"}>;`}var Tt=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 Le(e){return Tt.has(e)}function qe(e){let t=new Set(e.linkTypes.map(r=>r.objectTypeApiName).filter(r=>r!==e.objectType.apiName));return `import type { OntologyObject, LocalDate, Timestamp, GeoShape, GeoPoint, Attachment, TimeSeries, MultiLink, SingleLink } from "@osdk/legacy-client";
-${Array.from(t).map(r=>`import type { ${r} } from "./${r}";`).join(`
-`)}
-
-  ${Ue(e.objectType.description)}export interface ${e.objectType.apiName} extends OntologyObject {
-  readonly __apiName: "${e.objectType.apiName}";
-  readonly __primaryKey: ${Y(e.objectType.properties[e.objectType.primaryKey].dataType)};
-${Object.entries(e.objectType.properties).flatMap(([r,n])=>{let a=Y(n.dataType),s=[`${Ue(n.description)}readonly ${r}: ${a} | undefined`];return Le(r)&&s.push(`/** @deprecated please migrate to '${r}' instead */
-          readonly ${r}_: ${a} | undefined`),s}).join(`;
-`)}
-${e.linkTypes.flatMap(r=>[`readonly ${r.apiName}: ${r.cardinality==="MANY"?"MultiLink":"SingleLink"}<${r.objectTypeApiName}>`]).join(`;
-`)}
-}
-  `}function Y(e){switch(e.type){case"string":return "string";case"boolean":return "boolean";case"array":return Y(e.subType)+"[]";case"integer":return "number";case"attachment":return "Attachment";case"byte":return "number";case"date":return "LocalDate";case"decimal":return "number";case"double":return "number";case"float":return "number";case"geopoint":return "GeoPoint";case"geoshape":return "GeoShape";case"long":return "number";case"short":return "number";case"timestamp":return "Timestamp";case"timeseries":return e.itemType.type==="string"?"TimeSeries<string>":"TimeSeries<number>";default:throw new Error(`Unknown property type ${e}`)}}function Ue(e){return e?`/**
- * ${e}
+           export const ${action.apiName} = ${JSON.stringify(wireActionTypeV2ToSdkActionDefinition(action), null, 2)} satisfies ActionDefinition<"${action.apiName}", ${uniqueApiNames.size > 0 ? [...uniqueApiNames].map((apiName) => `"${apiName}"`).join("|") : "never"}>;`));
+  }));
+  await fs.writeFile(path15__default.join(outDir, `index.ts`), await formatTs(`
+      ${Object.values(ontology.actionTypes).map((action) => `export * from "./${action.apiName}${importExt}";`).join("\n")}
+      `));
+}
+function extractReferencedObjectsFromAction(actionType) {
+  const referencedObjectsInParameters = Object.values(actionType.parameters).flatMap(({
+    dataType
+  }) => {
+    const objectTypeReference = extractReferencedObjectsFromActionParameter(dataType);
+    return objectTypeReference ? [objectTypeReference] : [];
+  });
+  const referenceObjectsInEdits = actionType.operations.flatMap((value) => {
+    switch (value.type) {
+      case "createObject":
+        return [value.objectTypeApiName];
+      case "modifyObject":
+        return [value.objectTypeApiName];
+      case "deleteObject":
+      case "createLink":
+      case "deleteLink":
+        return [];
+    }
+  });
+  return [...referenceObjectsInEdits, ...referencedObjectsInParameters];
+}
+function extractReferencedObjectsFromActionParameter(actionParameter) {
+  switch (actionParameter.type) {
+    case "objectSet":
+    case "object":
+      return actionParameter.objectTypeApiName;
+    case "array":
+      return extractReferencedObjectsFromActionParameter(actionParameter.subType);
+    case "string":
+    case "boolean":
+    case "attachment":
+    case "date":
+    case "double":
+    case "integer":
+    case "long":
+    case "timestamp":
+      return void 0;
+  }
+}
+
+// src/shared/wirePropertyV2ToSdkPrimaryKeyTypeDefinition.ts
+function wirePropertyV2ToSdkPrimaryKeyTypeDefinition(input) {
+  switch (input.dataType.type) {
+    case "integer":
+    case "double":
+    case "string":
+    case "boolean":
+    case "attachment":
+    case "byte":
+    case "decimal":
+    case "float":
+    case "geopoint":
+    case "geoshape":
+    case "long":
+    case "short": {
+      return input.dataType.type;
+    }
+    case "date": {
+      return "datetime";
+    }
+    case "timestamp": {
+      return "timestamp";
+    }
+    case "timeseries":
+    case "array":
+      throw new Error(`Type not supported for primaryKey: ${input.dataType.type}`);
+    default:
+      input.dataType;
+      throw new Error(`Unknown type encountered for primaryKey: ${input.dataType}`);
+  }
+}
+
+// src/shared/wirePropertyV2ToSdkPropertyDefinition.ts
+function wirePropertyV2ToSdkPropertyDefinition(input, isNullable = true) {
+  switch (input.dataType.type) {
+    case "integer":
+    case "string":
+    case "byte":
+    case "decimal":
+    case "double":
+    case "float":
+    case "long":
+    case "short":
+    case "boolean":
+    case "date":
+    case "attachment":
+    case "geopoint":
+    case "geoshape":
+    case "timestamp":
+    case "timeseries":
+      return {
+        multiplicity: false,
+        description: input.description,
+        type: objectPropertyTypeToSdkPropertyDefinition(input.dataType),
+        nullable: isNullable
+      };
+    case "array": {
+      return {
+        multiplicity: true,
+        description: input.description,
+        type: objectPropertyTypeToSdkPropertyDefinition(input.dataType),
+        nullable: true
+      };
+    }
+    default:
+      input.dataType;
+      throw new Error(`Unexpected data type ${JSON.stringify(input.dataType)}`);
+  }
+}
+function objectPropertyTypeToSdkPropertyDefinition(propertyType) {
+  switch (propertyType.type) {
+    case "integer":
+    case "string":
+    case "byte":
+    case "decimal":
+    case "double":
+    case "float":
+    case "long":
+    case "short":
+    case "boolean":
+    case "attachment":
+    case "geopoint":
+    case "geoshape":
+    case "timestamp":
+      return propertyType.type;
+    case "date":
+      return "datetime";
+    case "array":
+      return objectPropertyTypeToSdkPropertyDefinition(propertyType.subType);
+    case "timeseries":
+      if (propertyType.itemType.type === "string") {
+        return "stringTimeseries";
+      }
+      return "numericTimeseries";
+    default:
+      throw new Error(`Unexecpected data type ${propertyType}`);
+  }
+}
+
+// src/shared/wireObjectTypeV2ToSdkObjectDefinition.ts
+function wireObjectTypeV2ToSdkObjectDefinition(objectTypeWithLink, v2) {
+  if (objectTypeWithLink.objectType.properties[objectTypeWithLink.objectType.primaryKey] === void 0) {
+    throw new Error(`Primary key ${objectTypeWithLink.objectType.primaryKey} not found in ${objectTypeWithLink.objectType.apiName}`);
+  }
+  return {
+    apiName: objectTypeWithLink.objectType.apiName,
+    description: objectTypeWithLink.objectType.description,
+    primaryKeyType: wirePropertyV2ToSdkPrimaryKeyTypeDefinition(objectTypeWithLink.objectType.properties[objectTypeWithLink.objectType.primaryKey]),
+    links: Object.fromEntries(objectTypeWithLink.linkTypes.map((linkType) => {
+      return [linkType.apiName, {
+        multiplicity: linkType.cardinality === "MANY",
+        targetType: linkType.objectTypeApiName
+      }];
+    })),
+    properties: Object.fromEntries(Object.entries(objectTypeWithLink.objectType.properties).map(([key, value]) => [key, wirePropertyV2ToSdkPropertyDefinition(value, !(v2 && objectTypeWithLink.objectType.primaryKey === key))]))
+  };
+}
+
+// src/shared/wireObjectTypeV2ToSdkObjectConst.ts
+function wireObjectTypeV2ToSdkObjectConst(object, v2 = false) {
+  const uniqueLinkTargetTypes = new Set(object.linkTypes.map((a) => a.objectTypeApiName));
+  return `
+    export const ${object.objectType.apiName} = ${JSON.stringify(wireObjectTypeV2ToSdkObjectDefinition(object, v2), null, 2)} satisfies ObjectTypeDefinition<"${object.objectType.apiName}", ${uniqueLinkTargetTypes.size > 0 ? [...uniqueLinkTargetTypes].map((apiName) => `"${apiName}"`).join("|") : "never"}>;`;
+}
+
+// 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) {
+  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}";`).join("\n")}
+
+  ${getDescriptionIfPresent(objectTypeWithLinks.objectType.description)}export interface ${objectTypeWithLinks.objectType.apiName} extends OntologyObject {
+  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)}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 "number";
+    case "double":
+      return "number";
+    case "float":
+      return "number";
+    case "geopoint":
+      return "GeoPoint";
+    case "geoshape":
+      return "GeoShape";
+    case "long":
+      return "number";
+    case "short":
+      return "number";
+    case "timestamp":
+      return "Timestamp";
+    case "timeseries":
+      return property.itemType.type === "string" ? `TimeSeries<string>` : `TimeSeries<number>`;
+    default:
+      throw new Error(`Unknown property type ${property}`);
+  }
+}
+function getDescriptionIfPresent(description) {
+  if (description) {
+    return `/**
+ * ${description}
  */
-`:""}async function We(e,t,r,n=""){await t.mkdir(r,{recursive:!0}),await Promise.all(Object.values(e.objectTypes).map(async a=>{a.linkTypes;await t.writeFile(d__default.join(r,`${a.objectType.apiName}.ts`),await o(`
-        import { ObjectTypeDefinition } from "@osdk/api";
-        ${qe(a)}
-
-        ${R(a)}
-        `));})),await t.writeFile(d__default.join(r,"index.ts"),await o(`
-    ${Object.keys(e.objectTypes).map(a=>`export * from "./${a}${n}";`).join(`
-`)}
+`;
+  }
+  return "";
+}
+
+// src/v1.1/generatePerObjectInterfaceAndDataFiles.ts
+async function generatePerObjectInterfaceAndDataFiles(ontology, fs, outDir, importExt = "") {
+  await fs.mkdir(outDir, {
+    recursive: true
+  });
+  await Promise.all(Object.values(ontology.objectTypes).map(async (object) => {
+    object.linkTypes;
+    await fs.writeFile(path15__default.join(outDir, `${object.objectType.apiName}.ts`), await formatTs(`
+        import type { ObjectTypeDefinition } from "@osdk/api";
+        ${wireObjectTypeV2ToObjectInterfaceStringV1(object)}
+
+        ${wireObjectTypeV2ToSdkObjectConst(object)}
+        `));
+  }));
+  await fs.writeFile(path15__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";
 
-    `));}function F(e){return e.type==="null"?!0:e.type==="union"?e.unionTypes.some(t=>F(t)):!1}function b(e){switch(e.type){case"double":case"float":case"integer":case"long":case"attachment":case"boolean":case"date":case"string":case"timestamp":return {type:e.type,nullable:!1};case"object":return {type:"object",object:e.objectTypeApiName,nullable:!1};case"objectSet":return {type:"objectSet",objectSet:e.objectTypeApiName,nullable:!1};case"array":return {...b(e.subType),multiplicity:!0};case"set":return {type:"set",set:b(e.subType),nullable:!1};case"union":let t=F(e);if(t&&e.unionTypes.length===2){let n=e.unionTypes.find(a=>a.type!==null);if(n)return {...b(n),nullable:!0}}return {type:"union",union:e.unionTypes.reduce((n,a)=>(a.type==="null"||n.push(b(a)),n),[]),nullable:t};case"struct":return {type:"struct",struct:Object.fromEntries(e.fields.map(n=>[n.name,b(n.fieldType)])),nullable:!1};case"twoDimensionalAggregation":return {type:"twoDimensionalAggregation",twoDimensionalAggregation:Z(e)};case"threeDimensionalAggregation":return {type:"threeDimensionalAggregation",threeDimensionalAggregation:wt(e)};case"null":case"unsupported":throw new Error(`Accidentally tried to handle QueryDataType.type ${e.type}`);default:throw new Error(`Unsupported QueryDataType.type ${e.type}`)}}function Z(e){if(e.keyType.type==="range")return {keyType:e.keyType.type,keySubtype:e.keyType.subType.type,valueType:e.valueType.type};if(ze(e.keyType))return {keyType:e.keyType.type,valueType:e.valueType.type};throw new Error(`Cannot create 2D aggregation with ${e.keyType.type} as its type`)}function wt(e){if(e.keyType.type==="range")return {keyType:e.keyType.type,keySubtype:e.keyType.subType.type,valueType:Z(e.valueType)};if(ze(e.keyType))return {keyType:e.keyType.type,valueType:Z(e.valueType)};throw new Error(`Cannot create 3D aggregation with ${e.keyType.type} as its type`)}function ze(e){return e.type==="string"||e.type==="boolean"}function Ye(e){return {apiName:e.apiName,description:e.description,displayName:e.displayName,version:e.version,parameters:Object.fromEntries(Object.entries(e.parameters).map(([t,r])=>[t,jt(r)])),output:b(e.output)}}function jt(e){return {description:e.description,...b(e.dataType)}}async function He(e,t,r,n=""){await t.mkdir(r,{recursive:!0}),await Promise.all(Object.values(e.queryTypes).map(async a=>{let s=bt(a);await t.writeFile(d__default.join(r,`${a.apiName}.ts`),await o(`
+    `));
+}
+
+// src/shared/isNullableQueryDataType.ts
+function isNullableQueryDataType(input) {
+  if (input.type === "null") {
+    return true;
+  }
+  if (input.type === "union") {
+    return input.unionTypes.some((t) => isNullableQueryDataType(t));
+  }
+  return false;
+}
+
+// src/shared/wireQueryDataTypeToQueryDataTypeDefinition.ts
+function wireQueryDataTypeToQueryDataTypeDefinition(input) {
+  switch (input.type) {
+    case "double":
+    case "float":
+    case "integer":
+    case "long":
+    case "attachment":
+    case "boolean":
+    case "date":
+    case "string":
+    case "timestamp":
+      return {
+        type: input.type,
+        nullable: false
+      };
+    case "object":
+      return {
+        type: "object",
+        object: input.objectTypeApiName,
+        nullable: false
+      };
+    case "objectSet":
+      return {
+        type: "objectSet",
+        objectSet: input.objectTypeApiName,
+        nullable: false
+      };
+    case "array":
+      return {
+        ...wireQueryDataTypeToQueryDataTypeDefinition(input.subType),
+        multiplicity: true
+      };
+    case "set":
+      return {
+        type: "set",
+        set: wireQueryDataTypeToQueryDataTypeDefinition(input.subType),
+        nullable: false
+      };
+    case "union":
+      const allowNulls = isNullableQueryDataType(input);
+      if (allowNulls && input.unionTypes.length === 2) {
+        const nonnull = input.unionTypes.find((t) => t.type !== null);
+        if (nonnull) {
+          return {
+            ...wireQueryDataTypeToQueryDataTypeDefinition(nonnull),
+            nullable: true
+          };
+        }
+      }
+      return {
+        type: "union",
+        union: input.unionTypes.reduce((acc, t) => {
+          if (t.type === "null") {
+            return acc;
+          }
+          acc.push(wireQueryDataTypeToQueryDataTypeDefinition(t));
+          return acc;
+        }, []),
+        nullable: allowNulls
+      };
+    case "struct":
+      return {
+        type: "struct",
+        struct: Object.fromEntries(input.fields.map((f) => [f.name, wireQueryDataTypeToQueryDataTypeDefinition(f.fieldType)])),
+        nullable: false
+      };
+    case "twoDimensionalAggregation":
+      return {
+        type: "twoDimensionalAggregation",
+        twoDimensionalAggregation: get2DQueryAggregationProps(input)
+      };
+    case "threeDimensionalAggregation":
+      return {
+        type: "threeDimensionalAggregation",
+        threeDimensionalAggregation: get3DQueryAggregationProps(input)
+      };
+    case "null":
+    case "unsupported":
+      throw new Error(`Accidentally tried to handle QueryDataType.type ${input.type}`);
+    default:
+      throw new Error(`Unsupported QueryDataType.type ${input.type}`);
+  }
+}
+function get2DQueryAggregationProps(input) {
+  if (input.keyType.type === "range") {
+    return {
+      keyType: input.keyType.type,
+      keySubtype: input.keyType.subType.type,
+      valueType: input.valueType.type
+    };
+  } else {
+    if (guardInvalidKeyTypes(input.keyType)) {
+      return {
+        keyType: input.keyType.type,
+        valueType: input.valueType.type
+      };
+    }
+    throw new Error(`Cannot create 2D aggregation with ${input.keyType.type} as its type`);
+  }
+}
+function get3DQueryAggregationProps(input) {
+  if (input.keyType.type === "range") {
+    return {
+      keyType: input.keyType.type,
+      keySubtype: input.keyType.subType.type,
+      valueType: get2DQueryAggregationProps(input.valueType)
+    };
+  } else {
+    if (guardInvalidKeyTypes(input.keyType)) {
+      return {
+        keyType: input.keyType.type,
+        valueType: get2DQueryAggregationProps(input.valueType)
+      };
+    }
+    throw new Error(`Cannot create 3D aggregation with ${input.keyType.type} as its type`);
+  }
+}
+function guardInvalidKeyTypes(key) {
+  return key.type === "string" || key.type === "boolean";
+}
+
+// src/shared/wireQueryTypeV2ToSdkQueryDefinition.ts
+function wireQueryTypeV2ToSdkQueryDefinition(input) {
+  return {
+    apiName: input.apiName,
+    description: input.description,
+    displayName: input.displayName,
+    version: input.version,
+    parameters: Object.fromEntries(Object.entries(input.parameters).map(([name, parameter]) => [name, wireQueryParameterV2ToQueryParameterDefinition(parameter)])),
+    output: wireQueryDataTypeToQueryDataTypeDefinition(input.output)
+  };
+}
+function wireQueryParameterV2ToQueryParameterDefinition(parameter) {
+  return {
+    description: parameter.description,
+    ...wireQueryDataTypeToQueryDataTypeDefinition(parameter.dataType)
+  };
+}
+
+// src/v1.1/generatePerQueryDataFiles.ts
+async function generatePerQueryDataFiles(ontology, fs, outDir, importExt = "") {
+  await fs.mkdir(outDir, {
+    recursive: true
+  });
+  await Promise.all(Object.values(ontology.queryTypes).map(async (query) => {
+    const objectTypes = getObjectTypesFromQuery(query);
+    await fs.writeFile(path15__default.join(outDir, `${query.apiName}.ts`), await formatTs(`
         import { QueryDefinition } from "@osdk/api";
 
-        export const ${a.apiName} = ${JSON.stringify(Ye(a))} satisfies QueryDefinition<"${a.apiName}", ${s.length>0?s.map(c=>`"${c}"`).join("|"):"never"}>;`));})),await t.writeFile(d__default.join(r,"index.ts"),await o(`
-  ${Object.values(e.queryTypes).map(a=>`export * from "./${a.apiName}${n}";`).join(`
-`)}
-  `));}function bt(e){let t=new Set;for(let{dataType:r}of Object.values(e.parameters))D(r,t);return D(e.output,t),Array.from(t)}function D(e,t){switch(e.type){case"array":case"set":D(e.subType,t);return;case"object":t.add(e.objectTypeApiName);return;case"objectSet":t.add(e.objectTypeApiName);return;case"struct":for(let n of Object.values(e.fields))D(n.fieldType,t);return;case"union":for(let n of e.unionTypes)D(n,t);return;case"attachment":case"boolean":case"date":case"double":case"float":case"integer":case"long":case"null":case"string":case"threeDimensionalAggregation":case"timestamp":case"twoDimensionalAggregation":case"unsupported":return;default:throw new Error(`Cannot find object types from unsupported QueryDataType ${e.type}`)}}async function tt(e,t,r,n=""){let a=new Set,s=[];for(let c of Object.values(e.queryTypes)){let l=["/**"];c.description&&l.push(`* ${c.description}`);let u=k(c.output,a,!0),y=[];for(let[p,g]of Object.entries(c.parameters)){let x=F(g.dataType),P=k(g.dataType,a,!1);y.push(`"${p}"${x?"?":""}: ${P}`),l.push(`* @param {${et(P)}} params.${p}${g.description?` - ${g.description}`:""}`);}let w=y.length===0?"":`params: { ${y.join("; ")} }`;l.push(`* @returns ${et(u)}`,"*/"),s.push(`
-      ${l.join(`
-`)}
-      ${c.apiName}(${w}): Promise<Result<QueryResponse<${u}>, QueryError>>;
-      `);}await t.mkdir(r,{recursive:!0}),await t.writeFile(d__default.join(r,"Queries.ts"),await o(`
+        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__default.join(outDir, "index.ts"), await formatTs(`
+  ${Object.values(ontology.queryTypes).map((query) => `export * from "./${query.apiName}${importExt}";`).join("\n")}
+  `));
+}
+function getObjectTypesFromQuery(query) {
+  const types = /* @__PURE__ */ new Set();
+  for (const {
+    dataType
+  } of Object.values(query.parameters)) {
+    getObjectTypesFromDataType(dataType, types);
+  }
+  getObjectTypesFromDataType(query.output, types);
+  return Array.from(types);
+}
+function getObjectTypesFromDataType(dataType, types) {
+  switch (dataType.type) {
+    case "array":
+    case "set":
+      getObjectTypesFromDataType(dataType.subType, types);
+      return;
+    case "object":
+      types.add(dataType.objectTypeApiName);
+      return;
+    case "objectSet":
+      types.add(dataType.objectTypeApiName);
+      return;
+    case "struct":
+      for (const prop of Object.values(dataType.fields)) {
+        getObjectTypesFromDataType(prop.fieldType, types);
+      }
+      return;
+    case "union":
+      for (const type of dataType.unionTypes) {
+        getObjectTypesFromDataType(type, types);
+      }
+      return;
+    case "attachment":
+    case "boolean":
+    case "date":
+    case "double":
+    case "float":
+    case "integer":
+    case "long":
+    case "null":
+    case "string":
+    case "threeDimensionalAggregation":
+    case "timestamp":
+    case "twoDimensionalAggregation":
+    case "unsupported":
+      return;
+    default:
+      throw new Error(`Cannot find object types from unsupported QueryDataType ${dataType.type}`);
+  }
+}
+async function generateQueries(ontology, fs, outDir, importExt = "") {
+  const importedObjects = /* @__PURE__ */ new Set();
+  const signatures = [];
+  for (const query of Object.values(ontology.queryTypes)) {
+    const jsDocBlock = ["/**"];
+    if (query.description) {
+      jsDocBlock.push(`* ${query.description}`);
+    }
+    const outputType = handleQueryDataType(query.output, importedObjects, true);
+    const paramEntries = [];
+    for (const [name, parameter] of Object.entries(query.parameters)) {
+      const nullable = isNullableQueryDataType(parameter.dataType);
+      const type = handleQueryDataType(parameter.dataType, importedObjects, false);
+      paramEntries.push(`"${name}"${nullable ? "?" : ""}: ${type}`);
+      jsDocBlock.push(`* @param {${sanitizeDocTypeName(type)}} params.${name}${parameter.description ? ` - ${parameter.description}` : ""}`);
+    }
+    const param = paramEntries.length === 0 ? "" : `params: { ${paramEntries.join("; ")} }`;
+    jsDocBlock.push(`* @returns ${sanitizeDocTypeName(outputType)}`, "*/");
+    signatures.push(`
+      ${jsDocBlock.join("\n")}
+      ${query.apiName}(${param}): Promise<Result<QueryResponse<${outputType}>, QueryError>>;
+      `);
+  }
+  await fs.mkdir(outDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15__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(a).map(c=>`import type { ${c} } from "../objects/${c}${n}";`).join(`
-`)}
+    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
 
     export interface Queries {
-    ${s.join(`
-`)}
+    ${signatures.join("\n")}
     }
-  `));}function k(e,t,r){switch(e.type){case"boolean":return "boolean";case"string":return "string";case"double":case"float":case"integer":case"long":return "number";case"date":return "LocalDate";case"timestamp":return "Timestamp";case"attachment":return "Attachment";case"array":return `Array<${k(e.subType,t,r)}>`;case"object":{let s=e.objectTypeApiName;return t.add(s),r?s:`${s} | ${s}["__primaryKey"]`}case"objectSet":{let s=e.objectTypeApiName;return t.add(s),`ObjectSet<${s}>`}case"set":return `Set<${k(e.subType,t,r)}>`;case"struct":return `{ ${e.fields.map(s=>{let c=F(s.fieldType);return `${s.name}${c?"?":""}: ${k(s.fieldType,t,r)}`}).join(`,
-`)} }`;case"union":return e.unionTypes.map(s=>k(s,t,r)).filter(s=>s!=="null").join("|");case"twoDimensionalAggregation":return e.valueType,`TwoDimensionalAggregation<
-        ${H(e.keyType)},
-        ${Xe(e.valueType)}
-      >`;case"threeDimensionalAggregation":return `ThreeDimensionalAggregation<
-        ${H(e.keyType)},
-        ${H(e.valueType.keyType)},
-        ${Xe(e.valueType.valueType)}
-      >`;case"null":return "null";case"unsupported":throw new Error("Cannot generate queries for unsupported type");default:throw new Error(`Cannot generate queries for type ${e.type}`)}}function H(e){switch(e.type){case"boolean":return "boolean";case"double":case"integer":return "number";case"string":return "string";case"date":return "LocalDate";case"timestamp":return "Timestamp";case"range":return `Range<${xt(e.subType)}>`;default:throw new Error(`Unknown TwoDimensionalAggregation keyType ${e.type}`)}}function xt(e){switch(e.type){case"date":return "LocalDate";case"double":case"integer":return "number";case"timestamp":return "Timestamp";default:throw new Error(`Unsupported QueryAggregationRangeSubType ${e.type}`)}}function Xe(e){switch(e.type){case"date":return "LocalDate";case"double":return "number";case"timestamp":return "Timestamp";default:throw new Error(`Unsupported QueryAggregationValueType ${e.type}`)}}function et(e){return e.replace(/\s/g,"")}async function ht(e,t,r,n="commonjs"){let a=n==="module"?".js":"",s=d.join(r,"ontology","objects"),c=d.join(r,"ontology","actions"),l=d.join(r,"ontology","queries"),u=B(e);await Be(t,r,a),await Me(u,t,r,a),await Ve(t,d.join(r,"ontology")),await Ge(u,t,s,a),await Ee(u,t,d.join(s,"objects-api"),a),await We(u,t,s,a),await te(u,t,c,a),await v(u,t,c,a),await tt(u,t,l,a),await He(u,t,l,a),await Ce(t,r,a),await De(t,r);}function rt(e,t=!1){return `
-    export const ${e.apiName} = ${JSON.stringify(At(e),null,2)} satisfies InterfaceDefinition<"${e.apiName}", "">;`}function At(e,t){return {apiName:e.apiName,description:e.description,properties:Object.fromEntries(Object.entries(e.properties).map(([r,n])=>[r,V(n,!0)]))}}async function ot(e,t,r){t.writeFile(d__default.join(r,"OntologyMetadata.ts"),await o(`
+  `));
+}
+function handleQueryDataType(dataType, importedObjects, isReturnValue) {
+  switch (dataType.type) {
+    case "boolean":
+      return "boolean";
+    case "string":
+      return "string";
+    case "double":
+    case "float":
+    case "integer":
+    case "long":
+      return "number";
+    case "date":
+      return "LocalDate";
+    case "timestamp":
+      return "Timestamp";
+    case "attachment":
+      return "Attachment";
+    case "array":
+      return `Array<${handleQueryDataType(dataType.subType, importedObjects, isReturnValue)}>`;
+    case "object": {
+      const objectType = dataType.objectTypeApiName;
+      importedObjects.add(objectType);
+      return isReturnValue ? objectType : `${objectType} | ${objectType}["__primaryKey"]`;
+    }
+    case "objectSet": {
+      const objectType = dataType.objectTypeApiName;
+      importedObjects.add(objectType);
+      return `ObjectSet<${objectType}>`;
+    }
+    case "set":
+      return `Set<${handleQueryDataType(dataType.subType, importedObjects, isReturnValue)}>`;
+    case "struct":
+      const properties = dataType.fields.map((field) => {
+        const isNullable = isNullableQueryDataType(field.fieldType);
+        return `${field.name}${isNullable ? "?" : ""}: ${handleQueryDataType(field.fieldType, importedObjects, isReturnValue)}`;
+      });
+      return `{ ${properties.join(",\n")} }`;
+    case "union":
+      return dataType.unionTypes.map((type) => handleQueryDataType(type, importedObjects, isReturnValue)).filter((type) => type !== "null").join("|");
+    case "twoDimensionalAggregation":
+      dataType.valueType;
+      return `TwoDimensionalAggregation<
+        ${aggregationKeyToTypescriptType(dataType.keyType)},
+        ${aggregationValueToTypescriptType(dataType.valueType)}
+      >`;
+    case "threeDimensionalAggregation":
+      return `ThreeDimensionalAggregation<
+        ${aggregationKeyToTypescriptType(dataType.keyType)},
+        ${aggregationKeyToTypescriptType(dataType.valueType.keyType)},
+        ${aggregationValueToTypescriptType(dataType.valueType.valueType)}
+      >`;
+    case "null":
+      return "null";
+    case "unsupported":
+      throw new Error("Cannot generate queries for unsupported type");
+    default:
+      throw new Error(`Cannot generate queries for type ${dataType.type}`);
+  }
+}
+function aggregationKeyToTypescriptType(keyType) {
+  switch (keyType.type) {
+    case "boolean":
+      return "boolean";
+    case "double":
+    case "integer":
+      return "number";
+    case "string":
+      return "string";
+    case "date":
+      return "LocalDate";
+    case "timestamp":
+      return "Timestamp";
+    case "range":
+      return `Range<${aggregationRangeToTypescriptType(keyType.subType)}>`;
+    default:
+      throw new Error(`Unknown TwoDimensionalAggregation keyType ${keyType.type}`);
+  }
+}
+function aggregationRangeToTypescriptType(subType) {
+  switch (subType.type) {
+    case "date":
+      return "LocalDate";
+    case "double":
+    case "integer":
+      return "number";
+    case "timestamp":
+      return "Timestamp";
+    default:
+      throw new Error(`Unsupported QueryAggregationRangeSubType ${subType.type}`);
+  }
+}
+function aggregationValueToTypescriptType(valueType) {
+  switch (valueType.type) {
+    case "date":
+      return "LocalDate";
+    case "double":
+      return "number";
+    case "timestamp":
+      return "Timestamp";
+    default:
+      throw new Error(`Unsupported QueryAggregationValueType ${valueType.type}`);
+  }
+}
+function sanitizeDocTypeName(type) {
+  return type.replace(/\s/g, "");
+}
+
+// src/v1.1/generateClientSdkVersionOneDotOne.ts
+async function generateClientSdkVersionOneDotOne(ontology, fs, outDir, packageType = "commonjs") {
+  const importExt = packageType === "module" ? ".js" : "";
+  const objectsDir = path15.join(outDir, "ontology", "objects");
+  const actionsDir = path15.join(outDir, "ontology", "actions");
+  const queriesDir = path15.join(outDir, "ontology", "queries");
+  await verifyOutdir(outDir, fs);
+  const sanitizedOntology = sanitizeMetadata(ontology);
+  await generateFoundryClientFile(fs, outDir, importExt);
+  await generateMetadataFile(sanitizedOntology, fs, outDir, importExt);
+  await generateOntologyIndexFile(fs, path15.join(outDir, "ontology"));
+  await generateObjectsInterfaceFile(sanitizedOntology, fs, objectsDir, importExt);
+  await generateObjectsInterfaceSupportFiles(sanitizedOntology, fs, path15.join(objectsDir, "objects-api"), importExt);
+  await generatePerObjectInterfaceAndDataFiles(sanitizedOntology, fs, objectsDir, importExt);
+  await generateActions(sanitizedOntology, fs, actionsDir, importExt);
+  await generatePerActionDataFiles(sanitizedOntology, fs, actionsDir, importExt);
+  await generateQueries(sanitizedOntology, fs, queriesDir, importExt);
+  await generatePerQueryDataFiles(sanitizedOntology, fs, queriesDir, importExt);
+  await generateIndexFile(fs, outDir, importExt);
+  await generateBackCompatDeprecatedExports(fs, outDir);
+}
+
+// src/shared/UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst.ts
+function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceType, v2 = false) {
+  return `
+    export const ${interfaceType.apiName} = ${JSON.stringify(wireInterfaceTypeV2ToSdkObjectDefinition(interfaceType), null, 2)} satisfies InterfaceDefinition<"${interfaceType.apiName}", "">;`;
+}
+function wireInterfaceTypeV2ToSdkObjectDefinition(interfaceType, v2) {
+  return {
+    apiName: interfaceType.apiName,
+    description: interfaceType.description,
+    properties: Object.fromEntries(Object.entries(interfaceType.properties).map(([key, value]) => {
+      return [key, wirePropertyV2ToSdkPropertyDefinition(value, true)];
+    }))
+  };
+}
+async function generateOntologyMetadataFile(ontology, fs, outDir) {
+  fs.writeFile(path15__default.join(outDir, "OntologyMetadata.ts"), await formatTs(`
       export const OntologyMetadata = {
-        ontologyRid: "${e.ontology.rid}",
-        ontologyApiName: "${e.ontology.apiName}",
+        ontologyRid: "${ontology.ontology.rid}",
+        ontologyApiName: "${ontology.ontology.apiName}",
         userAgent: "foundry-typescript-osdk/2.0.0",
       }
-      `));}async function Ft(e,t,r,n="commonjs"){let a=B(e),s=Object.keys(a.objectTypes),c=Object.keys(a.actionTypes),u=Object.keys(a.__UNSTABLE_interfaceTypes??{}),y=n==="module"?".js":"";await t.mkdir(r,{recursive:!0}),t.writeFile(d__default.join(r,"index.ts"),await o(`
-        export { Ontology } from "./Ontology${y}";
-    `)),await ot(a,t,r),await t.writeFile(d__default.join(r,"Ontology.ts"),await o(`
+      `));
+}
+
+// src/v2.0/generateClientSdkVersionTwoPointZero.ts
+async function generateClientSdkVersionTwoPointZero(ontology, fs, outDir, packageType = "commonjs") {
+  await verifyOutdir(outDir, fs);
+  const sanitizedOntology = sanitizeMetadata(ontology);
+  const objectNames = Object.keys(sanitizedOntology.objectTypes);
+  const actionNames = Object.keys(sanitizedOntology.actionTypes);
+  const interfaceNames = Object.keys(sanitizedOntology.__UNSTABLE_interfaceTypes ?? {});
+  const importExt = packageType === "module" ? ".js" : "";
+  await fs.mkdir(outDir, {
+    recursive: true
+  });
+  fs.writeFile(path15__default.join(outDir, "index.ts"), await formatTs(`
+        export { Ontology } from "./Ontology${importExt}";
+    `));
+  await generateOntologyMetadataFile(sanitizedOntology, fs, outDir);
+  await fs.writeFile(path15__default.join(outDir, "Ontology.ts"), await formatTs(`
       import type { OntologyDefinition } from "@osdk/api";
-      import * as Actions from "./ontology/actions/index${y}";
-      import * as Objects from "./ontology/objects${y}";
-      import * as Interfaces from "./ontology/interfaces${y}";
-      import { OntologyMetadata } from "./OntologyMetadata${y}";
+      import * as Actions from "./ontology/actions/index${importExt}";
+      import * as Objects from "./ontology/objects${importExt}";
+      import * as Interfaces from "./ontology/interfaces${importExt}";
+      import { OntologyMetadata } from "./OntologyMetadata${importExt}";
       
       const _Ontology = {
         metadata: OntologyMetadata,
         objects: {
-          ${s.map(p=>`${p}: Objects.${p}`).join(`,
-`)}
+          ${objectNames.map((objectName) => {
+    return `${objectName}: Objects.${objectName}`;
+  }).join(",\n")}
           
         },
         actions: {
-          ${c.map(p=>`${p}: Actions.${p}`).join(`,
-`)}
+          ${actionNames.map((actionName) => {
+    return `${actionName}: Actions.${actionName}`;
+  }).join(",\n")}
         },
         queries: {
           // TODO
         },
         interfaces: {
-          ${u.map(p=>`${p}: Interfaces.${p}`).join(`,
-`)}
+          ${interfaceNames.map((objectName) => {
+    return `${objectName}: Interfaces.${objectName}`;
+  }).join(",\n")}
               
         }
-      } satisfies OntologyDefinition<${s.map(p=>`"${p}"`).join("|")}>;
+      } satisfies OntologyDefinition<${stringUnionFrom2(objectNames)}>;
 
       type _Ontology = typeof _Ontology;
       export interface Ontology extends _Ontology {}
       export const Ontology = _Ontology as Ontology;
-    `)),await t.mkdir(d__default.join(r,"ontology","objects"),{recursive:!0});for(let p of s){let g=e.objectTypes[p];await t.writeFile(d__default.join(r,"ontology","objects",`${p}.ts`),await o(`
+    `));
+  await fs.mkdir(path15__default.join(outDir, "ontology", "objects"), {
+    recursive: true
+  });
+  for (const name of objectNames) {
+    const obj = ontology.objectTypes[name];
+    await fs.writeFile(path15__default.join(outDir, "ontology", `objects`, `${name}.ts`), await formatTs(`
     
       import type { ObjectTypeDefinition } from "@osdk/api";
 
-      ${R(g,!0)}
+      ${wireObjectTypeV2ToSdkObjectConst(obj, true)}
 
-      
-    `));}await kt(t,r,u,e,y);let w=d__default.join(r,"ontology","actions");await t.mkdir(w,{recursive:!0}),await v(a,t,w,y),await t.writeFile(d__default.join(r,"ontology","objects.ts"),await o(`
-    ${Object.keys(e.objectTypes).map(p=>`export * from "./objects/${p}${y}";`).join(`
-`)}
-    `));}async function kt(e,t,r,n,a){let s=d__default.join(t,"ontology","interfaces");await e.mkdir(s,{recursive:!0});for(let c of r){let l=n.__UNSTABLE_interfaceTypes[c];await e.writeFile(d__default.join(s,`${c}.ts`),await o(`
+      ${/* TODO: FIXME
+    //   wireObjectTypeV2ToObjectDefinitionInterfaceString(
+    //     obj,
+    //   )
+    */
+    ""}
+    `));
+  }
+  await generateOntologyInterfaces(fs, outDir, interfaceNames, ontology, importExt);
+  const actionsDir = path15__default.join(outDir, "ontology", "actions");
+  await fs.mkdir(actionsDir, {
+    recursive: true
+  });
+  await generatePerActionDataFiles(sanitizedOntology, fs, actionsDir, importExt);
+  await fs.writeFile(path15__default.join(outDir, "ontology", "objects.ts"), await formatTs(`
+    ${Object.keys(ontology.objectTypes).map((apiName) => `export * from "./objects/${apiName}${importExt}";`).join("\n")}
+    `));
+}
+function stringUnionFrom2(values) {
+  if (values.length === 0) {
+    return "never";
+  } else {
+    return values.map((v) => `"${v}"`).join("|");
+  }
+}
+async function generateOntologyInterfaces(fs, outDir, interfaceNames, ontology, importExt) {
+  const interfacesDir = path15__default.join(outDir, "ontology", "interfaces");
+  await fs.mkdir(interfacesDir, {
+    recursive: true
+  });
+  for (const name of interfaceNames) {
+    const obj = ontology.__UNSTABLE_interfaceTypes[name];
+    await fs.writeFile(path15__default.join(interfacesDir, `${name}.ts`), await formatTs(`
     
       import type { InterfaceDefinition } from "@osdk/api";
 
-      ${rt(l,!0)}
-    `));}await e.writeFile(s+".ts",await o(`
-    ${Object.keys(n.__UNSTABLE_interfaceTypes??{}).map(c=>`export * from "./interfaces/${c}${a}";`).join(`
-`)}
-    `));}
+      ${__UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(obj, true)}
+    `));
+  }
+  await fs.writeFile(interfacesDir + ".ts", await formatTs(`
+    ${Object.keys(ontology.__UNSTABLE_interfaceTypes ?? {}).map((apiName) => `export * from "./interfaces/${apiName}${importExt}";`).join("\n")}
+    `));
+}
 
-export { ht as generateClientSdkVersionOneDotOne, Ft as generateClientSdkVersionTwoPointZero };
+export { generateClientSdkVersionOneDotOne, generateClientSdkVersionTwoPointZero };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.mjs.map