@osdk/generator 1.10.0 → 1.11.0-main-20240514141215

package/build/js/index.browser.mjs

@@ -0,0 +1,1888 @@
+import * as fs from 'fs';
+import * as path16 from 'path';
+import path16__default, { join } from 'path';
+import { format } from 'prettier';
+import organizeImports from 'prettier-plugin-organize-imports';
+import { wireObjectTypeFullMetadataToSdkObjectTypeDefinition, __UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition } from '@osdk/generator-converters';
+
+// src/generateClientSdkPackage.ts
+
+// src/util/deleteUndefineds.ts
+function deleteUndefineds(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== void 0));
+}
+
+// src/util/stringify.ts
+var defaultCustomizer = (value, defaultValueFormatter, key, defaultKeyFormatter) => {
+  return [defaultKeyFormatter(key), defaultValueFormatter(value)];
+};
+function stringify(obj, customizer = {}, separator = ",\n") {
+  const defaultKeyFormatter = (key) => `${JSON.stringify(key)}`;
+  const entries = [];
+  const sortedKeys = Object.keys(obj).sort((a, b) => a.localeCompare(b));
+  for (const key of sortedKeys) {
+    const value = obj[key];
+    const res = (customizer[key] ?? customizer["*"] ?? defaultCustomizer)(value, (value2) => JSON.stringify(value2, null, 2), key, defaultKeyFormatter);
+    if (res) {
+      if (typeof res === "string") {
+        entries.push(`${defaultKeyFormatter(key)}: ${res}`);
+      } else {
+        entries.push(`${res[0]}: ${res[1]}`);
+      }
+    }
+  }
+  return entries.join(separator);
+}
+function formatTs(contents) {
+  return format(contents, {
+    parser: "typescript",
+    singleQuote: true,
+    trailingComma: "all",
+    plugins: [organizeImports],
+    tabWidth: 2,
+    printWidth: 120
+  });
+}
+
+// src/util/reservedKeywords.ts
+var reservedKeywords = /* @__PURE__ */ new Set(["break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do", "else", "enum", "export", "extends", "false", "finally", "for", "function", "if", "import", "in", "instanceof", "new", "null", "return", "super", "switch", "this", "throw", "true", "try", "typeof", "var", "void", "while", "with", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"]);
+function isReservedKeyword(name) {
+  return reservedKeywords.has(name);
+}
+
+// src/v1.1/wireObjectTypeV2ToV1ObjectInterfaceString.ts
+function wireObjectTypeV2ToObjectInterfaceStringV1(objectTypeWithLinks, importExt = "") {
+  const uniqueLinkTargets = new Set(objectTypeWithLinks.linkTypes.map((a) => a.objectTypeApiName).filter((a) => a !== objectTypeWithLinks.objectType.apiName));
+  return `import type { OntologyObject, LocalDate, Timestamp, GeoShape, GeoPoint, Attachment, TimeSeries, MultiLink, SingleLink } from "@osdk/legacy-client";
+${Array.from(uniqueLinkTargets).map((linkTarget) => `import type { ${linkTarget} } from "./${linkTarget}${importExt}";`).join("\n")}
+
+  ${getDescriptionIfPresent(objectTypeWithLinks.objectType.description)}
+  export interface ${objectTypeWithLinks.objectType.apiName} extends OntologyObject {
+  /** @deprecated please migrate to $apiName instead */
+  readonly __apiName: "${objectTypeWithLinks.objectType.apiName}" & {${objectTypeWithLinks.linkTypes.map((linkType) => {
+    return `/** @deprecated please migrate to pivotTo(${linkType.apiName}) instead */ searchAround${linkType.apiName.charAt(0).toUpperCase() + linkType.apiName.slice(1)}?: never`;
+  })}};
+  /** @deprecated please migrate to $primaryKey instead */
+  readonly __primaryKey: ${wirePropertyTypeV2ToTypeScriptType(objectTypeWithLinks.objectType.properties[objectTypeWithLinks.objectType.primaryKey].dataType)};
+  readonly $apiName: "${objectTypeWithLinks.objectType.apiName}";
+  readonly $primaryKey: ${wirePropertyTypeV2ToTypeScriptType(objectTypeWithLinks.objectType.properties[objectTypeWithLinks.objectType.primaryKey].dataType)};
+${Object.entries(objectTypeWithLinks.objectType.properties).sort((a, b) => a[0].localeCompare(b[0])).flatMap(([propertyName, propertyDefinition]) => {
+    const propertyType = wirePropertyTypeV2ToTypeScriptType(propertyDefinition.dataType);
+    const entries = [`${getDescriptionIfPresent(propertyDefinition.description, true)}readonly ${propertyName}: ${propertyType} | undefined`];
+    if (isReservedKeyword(propertyName)) {
+      entries.push(`/** @deprecated please migrate to '${propertyName}' instead */
+          readonly ${propertyName}_: ${propertyType} | undefined`);
+    }
+    return entries;
+  }).join(";\n")}
+${objectTypeWithLinks.linkTypes.flatMap((linkType) => {
+    const entries = [`readonly ${linkType.apiName}: ${linkType.cardinality === "MANY" ? "MultiLink" : "SingleLink"}<${linkType.objectTypeApiName}>`];
+    return entries;
+  }).join(";\n")}
+}
+  `;
+}
+function wirePropertyTypeV2ToTypeScriptType(property) {
+  switch (property.type) {
+    case "string":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return wirePropertyTypeV2ToTypeScriptType(property.subType) + "[]";
+    case "integer":
+      return "number";
+    case "attachment":
+      return "Attachment";
+    case "byte":
+      return "number";
+    case "date":
+      return "LocalDate";
+    case "decimal":
+      return "string";
+    case "double":
+      return "number";
+    case "float":
+      return "number";
+    case "geopoint":
+      return "GeoPoint";
+    case "geoshape":
+      return "GeoShape";
+    case "long":
+      return "string";
+    case "short":
+      return "number";
+    case "timestamp":
+      return "Timestamp";
+    case "timeseries":
+      return property.itemType.type === "string" ? `TimeSeries<string>` : `TimeSeries<number>`;
+    case "marking":
+      return "string";
+    default:
+      throw new Error(`Unknown property type ${property}`);
+  }
+}
+function getDescriptionIfPresent(description, includeNewline) {
+  if (description) {
+    return `/**
+ * ${description}
+ */${includeNewline ? "\n" : ""}`;
+  }
+  return "";
+}
+
+// src/shared/getEditedEntities.ts
+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
+  };
+}
+
+// src/shared/wireActionTypeV2ToSdkActionDefinition.ts
+function wireActionTypeV2ToSdkActionDefinition(input) {
+  const modifiedEntityTypes = getModifiedEntityTypes(input);
+  return {
+    type: "action",
+    apiName: input.apiName,
+    parameters: Object.fromEntries(Object.entries(input.parameters).map(([key, value]) => [key, wireActionParameterV2ToSdkParameterDefinition(value)])),
+    displayName: input.displayName,
+    description: input.description,
+    modifiedEntities: createModifiedEntities(modifiedEntityTypes.addedObjects, modifiedEntityTypes.modifiedObjects)
+  };
+}
+function wireActionParameterV2ToSdkParameterDefinition(value) {
+  return {
+    multiplicity: value.dataType.type === "array",
+    type: actionPropertyToSdkPropertyDefinition(value.dataType.type === "array" ? value.dataType.subType : value.dataType),
+    nullable: !value.required,
+    description: value.description
+  };
+}
+function actionPropertyToSdkPropertyDefinition(parameterType) {
+  switch (parameterType.type) {
+    case "string":
+    case "boolean":
+    case "attachment":
+    case "double":
+    case "integer":
+    case "long":
+    case "timestamp":
+    case "marking":
+      return parameterType.type;
+    case "date":
+      return "datetime";
+    case "objectSet":
+      return {
+        type: "objectSet",
+        objectSet: parameterType.objectTypeApiName
+      };
+    case "object":
+      return {
+        type: "object",
+        object: parameterType.objectTypeApiName
+      };
+    case "array":
+      return actionPropertyToSdkPropertyDefinition(parameterType.subType);
+  }
+}
+function createModifiedEntities(addedObjects, modifiedObjects) {
+  let entities = {};
+  for (const key of addedObjects) {
+    entities[key] = {
+      created: true,
+      modified: false
+    };
+  }
+  for (const key of modifiedObjects) {
+    if (entities[key]) {
+      entities[key].modified = true;
+    } else {
+      entities[key] = {
+        created: false,
+        modified: true
+      };
+    }
+  }
+  return entities;
+}
+function getObjectDefIdentifier(name, v2) {
+  return v2 ? name : `${name}Def`;
+}
+function wireObjectTypeV2ToSdkObjectConst(object, importExt, v2 = false) {
+  const uniqueLinkTargetTypes = new Set(object.linkTypes.map((a) => a.objectTypeApiName));
+  const definition = deleteUndefineds(wireObjectTypeFullMetadataToSdkObjectTypeDefinition(object, v2));
+  const objectDefIdentifier = getObjectDefIdentifier(object.objectType.apiName, v2);
+  function getV1Types() {
+    return `
+      export interface ${objectDefIdentifier} extends ObjectTypeDefinition<"${object.objectType.apiName}", ${object.objectType.apiName}> {
+        ${stringify(definition, {
+      osdkMetadata: () => void 0,
+      // not used in v1
+      links: (_value) => `{
+          ${stringify(definition.links, {
+        "*": (definition2) => `ObjectTypeLinkDefinition<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
+      })}
+        }`
+    })}
+      }
+    `;
+  }
+  function getV2Types() {
+    return `
+      export interface ${objectDefIdentifier} extends ObjectTypeDefinition<"${object.objectType.apiName}", ${object.objectType.apiName}>, VersionBound<$ExpectedClientVersion> {
+        osdkMetadata: typeof $osdkMetadata;
+        ${stringify(definition, {
+      osdkMetadata: () => void 0,
+      // we are going to reference another object instead
+      type: () => void 0,
+      apiName: () => void 0,
+      links: (_value) => `{
+          ${stringify(definition.links, {
+        "*": (definition2) => `ObjectTypeLinkDefinition<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
+      })}
+        }`,
+      properties: (_value) => `{
+          ${stringify(definition.properties, {
+        "*": (propertyDefinition) => `PropertyDef<"${propertyDefinition.type}", "${propertyDefinition.nullable ? "nullable" : "non-nullable"}", "${propertyDefinition.multiplicity ? "array" : "single"}">`
+      })}
+        }`
+    })}
+    
+      }
+
+    `;
+  }
+  const imports = Array.from(uniqueLinkTargetTypes).filter((type) => type !== definition.apiName).map((type) => `import type { ${getObjectDefIdentifier(type, v2)} } from "./${type}${importExt}";`);
+  return `${imports.join("\n")}
+
+    ${v2 ? getV2Types() : getV1Types()}
+
+    export const ${object.objectType.apiName}: ${objectDefIdentifier} = {
+      ${v2 ? `osdkMetadata: $osdkMetadata,` : ""}
+      ${stringify(definition, {
+    osdkMetadata: (value) => void 0
+  })}
+    
+    };`;
+}
+
+// src/shared/generatePerActionDataFiles.ts
+async function generatePerActionDataFiles(ontology, fs2, outDir, importExt, v2) {
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await Promise.all(Object.values(ontology.actionTypes).map(async (action) => {
+    const uniqueApiNames = new Set(extractReferencedObjectsFromAction(action));
+    const uniqueApiNamesString = uniqueApiNames.size > 0 ? [...uniqueApiNames].map((apiName) => `"${apiName}"`).join("|") : "never";
+    const fullActionDef = deleteUndefineds(wireActionTypeV2ToSdkActionDefinition(action));
+    const {
+      parameters,
+      ...actionDefSansParameters
+    } = fullActionDef;
+    const actionDefIdentifier = `ActionDef$${action.apiName}`;
+    const paramsDefIdentifier = `${actionDefIdentifier}$Params`;
+    const paramsIdentifier = `${action.apiName}$Params`;
+    function createParamsDef() {
+      const entries = Object.entries(parameters);
+      entries.sort((a, b) => a[0].localeCompare(b[0]));
+      if (entries.length === 0) {
+        return `// Represents the definition of the parameters for the action
+          export type ${paramsDefIdentifier} = Record<string, never>;`;
+      }
+      return `// Represents the definition of the parameters for the action
+        export type ${paramsDefIdentifier} = {
+          ${entries.map(([key, value]) => {
+        return `"${key}": {
+                ${stringify(value, {
+          description: (value2, d) => value2 ? d(value2) : void 0,
+          // trick to remove undefineds
+          type: (type) => {
+            if (typeof type === "string") {
+              return JSON.stringify(type);
+            } else if (type.type === "object") {
+              return `ObjectActionDataType<"${type.object}", ${getObjectDefIdentifier(type.object, v2)}>`;
+            } else if (type.type === "objectSet") {
+              return `ObjectSetActionDataType<"${type.objectSet}", ${getObjectDefIdentifier(type.objectSet, v2)}>`;
+            }
+            return void 0;
+          }
+        })}
+            }`;
+      }).join(";\n")}
+        }`;
+    }
+    function createV2Types() {
+      return `
+        
+          ${createParamsDef()}
+          
+
+          // Represents the runtime arguments for the action
+          export type ${paramsIdentifier} = NOOP<OsdkActionParameters<${paramsDefIdentifier}>>;
+
+          
+          // Represents a fqn of the action
+          export interface ${action.apiName} {
+            ${getDescriptionIfPresent(action.description)}
+             <OP extends ApplyActionOptions>(args: ${paramsIdentifier}, options?: OP): Promise<ActionReturnTypeForOptions<OP>>;
+          }
+
+          
+          // Represents the definition of the action
+          export interface ${actionDefIdentifier} extends ActionDefinition<"${action.apiName}", ${uniqueApiNamesString}, ${action.apiName}>{
+          ${Object.entries(actionDefSansParameters).sort((a, b) => a[0].localeCompare(b[0])).map(([key, value]) => {
+        return `${key}: ${JSON.stringify(value)};`;
+      }).join("\n")}
+          parameters: ${paramsDefIdentifier};
+          osdkMetadata: typeof $osdkMetadata;
+        }`;
+    }
+    function createV2Object() {
+      return `  export const ${action.apiName}: ${actionDefIdentifier} = 
+        {
+          ${stringify(fullActionDef)},
+          osdkMetadata: $osdkMetadata
+        }
+        `;
+    }
+    function createV1Object() {
+      return `  export const ${action.apiName} = ${JSON.stringify(fullActionDef, null, 2)} satisfies ActionDefinition<"${action.apiName}", ${uniqueApiNamesString}>;`;
+    }
+    const referencedObjectDefs = /* @__PURE__ */ new Set();
+    for (const p of Object.values(action.parameters)) {
+      if (p.dataType.type === "object" || p.dataType.type === "objectSet") {
+        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.objectApiName, v2));
+        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.objectTypeApiName, v2));
+      }
+      if (p.dataType.type === "array" && (p.dataType.subType.type === "object" || p.dataType.subType.type === "objectSet")) {
+        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.subType.objectApiName, v2));
+        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.subType.objectTypeApiName, v2));
+      }
+    }
+    const importObjects = referencedObjectDefs.size > 0 ? `import type {${[...referencedObjectDefs].join(",")}} from "../objects${importExt}";` : "";
+    await fs2.writeFile(path16__default.join(outDir, `${action.apiName}.ts`), await formatTs(`
+          import type { ActionDefinition, ObjectActionDataType, ObjectSetActionDataType } from "@osdk/api";
+          import type { ActionSignature, ApplyActionOptions, OsdkActionParameters,ActionReturnTypeForOptions, NOOP } from '@osdk/client';
+          import { $osdkMetadata} from "../../OntologyMetadata${importExt}";
+          ${importObjects}
+
+        
+          ${v2 ? createV2Types() : ""}
+
+          ${v2 ? createV2Object() : createV1Object()}
+        `));
+  }));
+  await fs2.writeFile(path16__default.join(outDir, `index.ts`), await formatTs(`
+      ${Object.values(ontology.actionTypes).map((action) => `export {${action.apiName}} from "./${action.apiName}${importExt}";`).join("\n")}
+    ${Object.keys(ontology.actionTypes).length === 0 ? "export {};" : ""}
+      `));
+}
+function extractReferencedObjectsFromAction(actionType) {
+  const referencedObjectsInParameters = Object.values(actionType.parameters).flatMap(({
+    dataType
+  }) => {
+    const objectTypeReference = extractReferencedObjectsFromActionParameter(dataType);
+    return objectTypeReference ? [objectTypeReference] : [];
+  });
+  const referenceObjectsInEdits = actionType.operations.flatMap((value) => {
+    switch (value.type) {
+      case "createObject":
+        return [value.objectTypeApiName];
+      case "modifyObject":
+        return [value.objectTypeApiName];
+      case "deleteObject":
+      case "createLink":
+      case "deleteLink":
+        return [];
+    }
+  });
+  return [...referenceObjectsInEdits, ...referencedObjectsInParameters];
+}
+function extractReferencedObjectsFromActionParameter(actionParameter) {
+  switch (actionParameter.type) {
+    case "objectSet":
+    case "object":
+      return actionParameter.objectTypeApiName;
+    case "array":
+      return extractReferencedObjectsFromActionParameter(actionParameter.subType);
+    case "string":
+    case "boolean":
+    case "attachment":
+    case "date":
+    case "double":
+    case "integer":
+    case "long":
+    case "timestamp":
+      return void 0;
+  }
+}
+
+// src/shared/sanitizeMetadata.ts
+function sanitizeMetadata(ontology) {
+  return {
+    ...ontology,
+    actionTypes: Object.fromEntries(Object.values(ontology.actionTypes).map((actionType) => {
+      return [camelize(actionType.apiName), {
+        ...actionType,
+        apiName: camelize(actionType.apiName)
+      }];
+    }))
+  };
+}
+function camelize(name) {
+  return name.replace(/-./g, (segment) => segment[1].toUpperCase());
+}
+
+// src/util/verifyOutdir.ts
+async function verifyOutdir(outDir, fs2) {
+  try {
+    const contents = await fs2.readdir(outDir);
+    if (contents.length !== 0) {
+      throw new Error(`outDir ${outDir} is not empty, please delete its contents and try again`);
+    }
+  } catch (e) {
+    if (e.code === "ENOENT") ; else {
+      throw e;
+    }
+  }
+}
+async function generateActions(ontology, fs2, outDir, importExt = "") {
+  const importedObjects = /* @__PURE__ */ new Set();
+  let actionSignatures = [];
+  for (const action of Object.values(ontology.actionTypes)) {
+    const entries = Object.entries(action.parameters);
+    const modifiedEntityTypes = getModifiedEntityTypes(action);
+    const addedObjects = Array.from(modifiedEntityTypes.addedObjects);
+    const modifiedObjects = Array.from(modifiedEntityTypes.modifiedObjects);
+    addedObjects.forEach(importedObjects.add, importedObjects);
+    modifiedObjects.forEach(importedObjects.add, importedObjects);
+    let jsDocBlock = ["/**"];
+    if (action.description) {
+      jsDocBlock.push(`* ${action.description}`);
+    }
+    let parameterBlock = "";
+    if (entries.length > 0) {
+      parameterBlock = `params: { 
+`;
+      for (const [parameterName, parameterData] of entries) {
+        parameterBlock += `"${parameterName}"`;
+        parameterBlock += parameterData.required ? ": " : "?: ";
+        const typeScriptType = getTypeScriptTypeFromDataType(parameterData.dataType, importedObjects);
+        parameterBlock += `${typeScriptType};
+`;
+        jsDocBlock.push(`* @param {${typeScriptType}} params.${parameterName}`);
+      }
+      parameterBlock += "}, ";
+    }
+    jsDocBlock.push(`*/`);
+    actionSignatures.push(`
+      ${jsDocBlock.join("\n")}
+      ${action.apiName}<O extends ActionExecutionOptions>(${parameterBlock}options?: O): 
+        Promise<Result<ActionResponseFromOptions<O, Edits<${addedObjects.length > 0 ? addedObjects.join(" | ") : "void"}, ${modifiedObjects.length > 0 ? modifiedObjects.join(" | ") : "void"}>>, ActionError>>;`);
+  }
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__default.join(outDir, "Actions.ts"), await formatTs(`
+    import type { ObjectSet, LocalDate, Timestamp, Attachment, Edits, ActionExecutionOptions, ActionError, Result, ActionResponseFromOptions } from "@osdk/legacy-client";
+    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
+    export interface Actions {
+    ${actionSignatures.join("\n")}
+    }
+  `));
+}
+function getTypeScriptTypeFromDataType(actionParameter, importedObjects) {
+  switch (actionParameter.type) {
+    case "objectSet": {
+      const objectType = actionParameter.objectTypeApiName;
+      importedObjects.add(objectType);
+      return `ObjectSet<${objectType}>`;
+    }
+    case "object": {
+      const objectType = actionParameter.objectTypeApiName;
+      importedObjects.add(objectType);
+      return `${objectType} | ${objectType}["__primaryKey"]`;
+    }
+    case "array":
+      return `Array<${getTypeScriptTypeFromDataType(actionParameter.subType, importedObjects)}>`;
+    case "string":
+      return `string`;
+    case "boolean":
+      return `boolean`;
+    case "attachment":
+      return `Attachment`;
+    case "date":
+      return `LocalDate`;
+    case "double":
+    case "integer":
+    case "long":
+      return `number`;
+    case "timestamp":
+      return `Timestamp`;
+    case "marking":
+      return "string";
+    default:
+      throw new Error(`Unsupported action parameter type: ${actionParameter}`);
+  }
+}
+
+// src/v1.1/backcompat/util/reexportConsts.ts
+function reexportConsts(typesToExport) {
+  return `
+          import  { ${typesToExport.map((q) => `${q} as OG_${q}`).join(", ")}} from "@osdk/legacy-client";
+      
+          ${typesToExport.map((q) => `
+      /** @deprecated submodule imports arent public api **/
+              export const ${q} = OG_${q};
+          `).join("\n\n")}
+      `;
+}
+
+// src/v1.1/backcompat/internal-foundry-oauth-dist/generateConfidentialClientDir.ts
+async function generateConfidentialClientDir(fs2, oauthDistDir, importExt = "") {
+  const confidentialClientDistDir = path16__default.join(oauthDistDir, "ConfidentialClient");
+  await fs2.mkdir(confidentialClientDistDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__default.join(confidentialClientDistDir, "index.ts"), await formatTs(`
+    export * from "./ConfidentialClientAuth${importExt}";
+  `));
+  await fs2.writeFile(path16__default.join(confidentialClientDistDir, "ConfidentialClientAuth.ts"), await formatTs(`
+        ${reexportConsts(["ConfidentialClientAuth"])}
+    `));
+}
+async function generatePublicClientDir(fs2, oauthDistDir, importExt = "") {
+  const publicClientDistDir = path16__default.join(oauthDistDir, "PublicClient");
+  await fs2.mkdir(publicClientDistDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__default.join(publicClientDistDir, "index.ts"), await formatTs(`
+    export * from "./PublicClientAuth${importExt}";
+  `));
+  await fs2.writeFile(path16__default.join(publicClientDistDir, "PublicClientAuth.ts"), await formatTs(`
+        ${reexportConsts(["PublicClientAuth"])}
+    `));
+}
+async function generateUserTokenDir(fs2, oauthDistDir, importExt = "") {
+  const userTokenDistDir = path16__default.join(oauthDistDir, "UserToken");
+  await fs2.mkdir(userTokenDistDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__default.join(userTokenDistDir, "index.ts"), await formatTs(`
+    export * from "./UserTokenAuth${importExt}";
+  `));
+  await fs2.writeFile(path16__default.join(userTokenDistDir, "UserTokenAuth.ts"), await formatTs(`
+        ${reexportConsts(["UserTokenAuth"])}
+    `));
+}
+
+// src/v1.1/backcompat/util/reexportTypes.ts
+function reexportTypes(typesToExport, genericArgsLeft = "", genericArgsRight = cleanup(genericArgsLeft)) {
+  return `
+    import type { ${typesToExport.map((q) => `${q} as OG_${q}`).join(", ")}} from "@osdk/legacy-client";
+    
+        ${typesToExport.map((q) => `
+      /** @deprecated submodule imports arent public api **/
+      export type ${q}${genericArgsLeft} = OG_${q}${genericArgsRight};
+    `).join("\n\n")}
+    `;
+}
+var captureInBracketsRegex = /<(.*?)>/;
+var captureGenericParamNameRegex = /^\s?(.+?)( extends .*?)?( = .*?)?\s?$/;
+function cleanup(s) {
+  if (s.length === 0)
+    return "";
+  const genericParameterNames = captureInBracketsRegex.exec(s)?.[1]?.split(",")?.map((a) => {
+    return captureGenericParamNameRegex.exec(a)?.[1] ?? a;
+  });
+  return `<${genericParameterNames?.join(",")}>`;
+}
+
+// src/v1.1/backcompat/generateOAuthDistDir.ts
+async function generateOAuthClientDistDir(outDir, fs2, importExt = "") {
+  const oauthDistDir = path16.join(outDir, "internal", "@foundry", "oauth-client", "dist");
+  await fs2.mkdir(oauthDistDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16.join(oauthDistDir, "index.ts"), await formatTs(`
+    export * from "./Auth${importExt}";
+    export * from "./ConfidentialClient/index${importExt}";
+    export * from "./OAuthClient${importExt}";
+    export * from "./PublicClient/index${importExt}";
+    export * from "./Token${importExt}";
+    export * from "./UserToken/index${importExt}";
+`));
+  await fs2.writeFile(path16.join(oauthDistDir, "Auth.ts"), await formatTs(reexportTypes(["Auth"])));
+  await fs2.writeFile(path16.join(oauthDistDir, "Token.ts"), await formatTs(reexportTypes(["Token", "TokenValue"])));
+  await fs2.writeFile(path16.join(oauthDistDir, "OAuthClient.ts"), await formatTs(reexportTypes(["AuthSubscription", "UnsubscribeFunction", "SignInResponse", "RefreshResponse", "SignOutResponse"])));
+  await fs2.writeFile(path16.join(oauthDistDir, "OAuthToken.ts"), await formatTs(reexportConsts(["OAuthToken"])));
+  await fs2.writeFile(path16.join(oauthDistDir, "Auth.ts"), await formatTs(reexportTypes(["Auth"])));
+  await generateConfidentialClientDir(fs2, oauthDistDir, importExt);
+  await generatePublicClientDir(fs2, oauthDistDir, importExt);
+  await generateUserTokenDir(fs2, oauthDistDir, importExt);
+}
+async function generateAggregationsAggregations(fs2, aggregationsDir) {
+  await fs2.writeFile(path16.join(aggregationsDir, "Aggregations.ts"), await formatTs(`
+      import { LocalDate, Timestamp } from "@osdk/legacy-client";
+      ` + reexportTypes(["Double", "Rangeable", "MetricValue", "Date", "BucketKey", "BucketValue", "TimeUnit", "BucketGroup", "Metrics", "AggregatableProperties", "AggregationClause"]) + reexportTypes(["Range"], "<T extends Rangeable>", "<T>") + reexportTypes(["BaseGroupBy"], "<_T extends BucketValue = BucketValue>") + reexportTypes(["Duration"], "<_T extends Timestamp | LocalDate = Timestamp | LocalDate>") + reexportTypes(["AggregatableProperty", "MultipleAggregationsOperations"], "<_T extends MetricValue = MetricValue>") + reexportTypes(["AggregationGroup"], "<TMetrics extends Metrics | MetricValue, TBucketGroup extends BucketGroup>") + reexportTypes(["Bucketing"], "<_T extends string , _X extends BucketValue>") + reexportTypes(["AggregationResult"], "<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue>") + reexportTypes(["BaseBucketing"], "<TBucketKey extends BucketKey, TBucketValue extends BucketValue, Kind extends string>") + reexportTypes(["ExactValueBucketing", "InternalBucketing"], `<TBucketKey extends BucketKey, TBucketValue extends BucketValue>`) + reexportTypes(["RangeBucketing", "FixedWidthBucketing"], `<TBucketKey extends BucketKey, TBucketValue extends Range<Rangeable>>`) + reexportTypes(["DurationBucketing"], `<TBucketKey extends BucketKey, TBucketValue extends Date>`) + reexportTypes(["InternalBucketingVisitor"], "<TBucketKey extends BucketKey, T extends BucketValue, R>") + reexportTypes(["AggregationBuilderResult"], "<T, TMultipleAggregationProperties>") + reexportTypes(["AggregatablePropertiesForResult", "AggregatablePropertyNamesForResult"], "<TAggregatableProperties, TResult extends MetricValue>") + reexportConsts(["assertBucketingInternal", "visitInternalBucketing"]) + reexportTypes(["AggregatableObjectSetStep"], "<TAggregatableProperties, TMultipleAggregationProperties, TBucketableProperties, TBucketGroup extends BucketGroup = {}>") + reexportTypes(["GroupedTerminalAggregationOperations"], "<TAggregatableProperties, TMultipleAggregationProperties, TBucketGroup extends BucketGroup = {}>")));
+}
+async function generateGroupBy(fs2, aggregationsDir, importExt = "") {
+  await fs2.mkdir(path16.join(aggregationsDir, "groupBy"), {
+    recursive: true
+  });
+  const groupBys = ["BooleanGroupBy", "LocalDateGroupBy", "NumericGroupBy", "StringGroupBy", "TimestampGroupBy"];
+  const reexportFiles = [...groupBys, "GroupKeyType"];
+  for (const key of reexportFiles) {
+    await fs2.writeFile(path16.join(aggregationsDir, "groupBy", `${key}.ts`), await formatTs(`export {${key}} from "./index${importExt}";`));
+  }
+  await fs2.writeFile(path16.join(aggregationsDir, "groupBy", "index.ts"), await formatTs(`import { Bucketing, BucketKey, Duration, Range, Rangeable } from "../Aggregations${importExt}";` + reexportConsts(groupBys) + reexportTypes(groupBys, "<T extends BucketKey>") + `export {GroupKeyType} from "@osdk/legacy-client";
+          `));
+}
+async function generateMetrics(fs2, aggregationsDir, importExt = "") {
+  const metricsDir = path16.join(aggregationsDir, "metrics");
+  await fs2.mkdir(metricsDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16.join(metricsDir, "metrics.ts"), await formatTs(`export {MetricValueType} from "@osdk/legacy-client";`));
+  await fs2.writeFile(path16.join(metricsDir, "ApproximateDistinctCountAggregatableProperty.ts"), await formatTs(reexportConsts(["ApproximateDistinctCountAggregatableProperty"]) + reexportTypes(["ApproximateDistinctCountAggregatableProperty"])));
+  await fs2.writeFile(path16.join(metricsDir, "MultipleAggregatableProperty.ts"), await formatTs(`
+        import { Double, MetricValue, MultipleAggregationsOperations } from "../Aggregations${importExt}";
+        import { MetricValueType } from "./metrics/index${importExt}";
+      ` + reexportConsts(["MultipleAggregatableProperty"]) + reexportTypes(["MultipleAggregatableProperty"], "<TResult extends MetricValue = Double>")));
+  for (const typeName of ["DefaultAggregatableProperty", "LocalDatePropertyMetric", "NumericPropertyMetric", "TimestampPropertyMetric"]) {
+    await fs2.writeFile(path16.join(metricsDir, `${typeName}.ts`), await formatTs(`
+          import { MultipleAggregatableProperty } from "./MultipleAggregatableProperty${importExt}";
+        ` + reexportConsts([typeName])));
+  }
+  await fs2.writeFile(path16.join(metricsDir, "index.ts"), await formatTs(`
+      export * from "./ApproximateDistinctCountAggregatableProperty${importExt}";
+      export * from "./DefaultAggregatableProperty${importExt}";
+      export * from "./LocalDatePropertyMetric${importExt}";
+      export * from "./metrics${importExt}";
+      export * from "./MultipleAggregatableProperty${importExt}";
+      export * from "./NumericPropertyMetric${importExt}";
+      export * from "./TimestampPropertyMetric${importExt}";
+      `));
+}
+
+// src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateAggregationsDir.ts
+async function generateAggregationsDir(fs2, runtimeDistDir, importExt = "") {
+  const aggregationsDir = path16.join(runtimeDistDir, "aggregations");
+  await fs2.mkdir(aggregationsDir, {
+    recursive: true
+  });
+  await generateGroupBy(fs2, aggregationsDir, importExt);
+  await generateAggregationsAggregations(fs2, aggregationsDir);
+  await generateMetrics(fs2, aggregationsDir, importExt);
+  await fs2.writeFile(path16.join(aggregationsDir, "index.ts"), await formatTs(`
+    ${""}
+    ${""}
+    
+    export * from "./Aggregations${importExt}";
+    export * from "./ComputeStep${importExt}";
+    export * from "./CountOperation${importExt}";
+    export * from "./groupBy/index${importExt}";
+    export * from "./internalAggregationRequest${importExt}";
+    export * from "./metrics/index${importExt}";
+  `));
+  await fs2.writeFile(path16.join(aggregationsDir, "ComputeStep.ts"), await formatTs(`
+      import { ObjectSetDefinition } from "../baseTypes/index${importExt}";
+      import { FoundryClientOptions } from "../client/${importExt}";
+      import { AggregateObjectsError, OntologyMetadata, Result } from "../ontologyProvider/index${importExt}";
+      import { AggregationClause, AggregationResult, BucketGroup, BucketValue, InternalBucketing, Metrics, MetricValue } from "./Aggregations${importExt}";
+      ` + reexportConsts(["ComputeStep"]) + reexportTypes(["ComputeStep"], "<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue> ") + reexportTypes(["AggregationComputeStep"], "<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue>") + `
+    
+    `));
+  await fs2.writeFile(path16.join(aggregationsDir, "CountOperation.ts"), await formatTs(`` + reexportConsts(["CountOperation", "isCountOperation"]) + reexportTypes(["CountOperation"])));
+  await fs2.writeFile(path16.join(aggregationsDir, "internalAggregationRequest.ts"), await formatTs(reexportTypes(["InternalAggregationRequest"])));
+}
+async function generateAttachmentsDir(attachmentsDir, fs2, importExt = "") {
+  await fs2.mkdir(attachmentsDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__default.join(attachmentsDir, "index.ts"), await formatTs(`export * from "./Attachment${importExt}";
+       export * from "./Attachments${importExt}";
+    `));
+  await fs2.writeFile(path16__default.join(attachmentsDir, "Attachment.ts"), await formatTs(reexportTypes(["Attachment", "AttachmentMetadata"])));
+  await fs2.writeFile(path16__default.join(attachmentsDir, "Attachments.ts"), await formatTs(reexportTypes(["Attachments"])));
+}
+async function generateGeoshapesDir(runtimeDistDir, fs2, importExt = "") {
+  await fs2.mkdir(runtimeDistDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16.join(runtimeDistDir, "index.ts"), await formatTs(`export * from "./Distance${importExt}";
+       export * from "./GeoJson${importExt}";
+       export * from "./GeometryCollection${importExt}";
+       export * from "./GeoPoint${importExt}";
+       export * from "./GeoShape${importExt}";
+       export * from "./LineString${importExt}";
+       export * from "./MultiGeoPoint${importExt}";
+       export * from "./MultiLineString${importExt}";
+       export * from "./MultiPolygon${importExt}";
+       export * from "./Polygon${importExt}";`));
+  await fs2.writeFile(path16.join(runtimeDistDir, "Distance.ts"), await formatTs(`` + reexportConsts(["Distance", "DistanceUnit"]) + reexportTypes(["Distance", "DistanceUnit"])));
+  await fs2.writeFile(path16.join(runtimeDistDir, "GeoJson.ts"), await formatTs(reexportTypes(["GeoJsonPoint", "GeoJsonPolygon", "GeoJsonLineString", "GeoJsonMultiPoint", "GeoJsonMultiPolygon", "GeoJsonMultiLineString", "GeoJsonGeometryCollection", "GeoJsonGeometry", "GeoJson"])));
+  await fs2.writeFile(path16.join(runtimeDistDir, "GeometryCollection.ts"), await formatTs(reexportConsts(["GeometryCollection"])));
+  await fs2.writeFile(path16.join(runtimeDistDir, "GeoPoint.ts"), await formatTs(`` + reexportConsts(["isGeoPoint", "GeoPoint", "mapCoordinatesToGeoPoint"]) + reexportTypes(["GeoHash", "Coordinates", "GeoPoint"])));
+  await fs2.writeFile(path16.join(runtimeDistDir, "GeoShape.ts"), await formatTs(reexportConsts(["GeoShape"]) + reexportTypes(["GeoShape"])));
+  await fs2.writeFile(path16.join(runtimeDistDir, "LineString.ts"), await formatTs(reexportConsts(["LineString"]) + reexportTypes(["LineString"])));
+  await fs2.writeFile(path16.join(runtimeDistDir, "MultiGeoPoint.ts"), await formatTs(reexportConsts(["MultiGeoPoint"]) + reexportTypes(["MultiGeoPoint"])));
+  await fs2.writeFile(path16.join(runtimeDistDir, "MultiLineString.ts"), await formatTs(reexportConsts(["MultiLineString"]) + reexportTypes(["MultiLineString"])));
+  await fs2.writeFile(path16.join(runtimeDistDir, "MultiPolygon.ts"), await formatTs(reexportConsts(["MultiPolygon"]) + reexportTypes(["MultiPolygon"])));
+  await fs2.writeFile(path16.join(runtimeDistDir, "Polygon.ts"), await formatTs(reexportConsts(["Polygon"]) + reexportTypes(["LinearRing", "Polygon"])));
+}
+async function generateObjectSetDir(objectSetDir, fs2, importExt = "") {
+  await fs2.mkdir(objectSetDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__default.join(objectSetDir, "index.ts"), await formatTs(`
+    export * from "./ObjectSetDefinition${importExt}";
+    export * from "./OntologyObjectSet${importExt}";
+    `));
+  await fs2.writeFile(path16__default.join(objectSetDir, "ObjectSetDefinition.ts"), await formatTs(reexportTypes(["BaseObjectSetDefinition", "ReferenceObjectSetDefinition", "StaticObjectSetDefinition", "IntersectObjectSetDefinition", "SubtractObjectSetDefinition", "SearchAroundObjectSetDefinition", "FilterObjectSetDefinition", "ObjectSetDefinition"])));
+  await fs2.writeFile(path16__default.join(objectSetDir, "OntologyObjectSet.ts"), await formatTs(reexportTypes(["OntologyObjectSet"])));
+}
+async function generateSharedObjectCodeDir(sharedObjectCodeDir, fs2, importExt = "") {
+  await fs2.mkdir(sharedObjectCodeDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__default.join(sharedObjectCodeDir, "index.ts"), await formatTs(`
+    export * from "./FilteredPropertiesTerminalOperations${importExt}";
+    `));
+  await fs2.writeFile(path16__default.join(sharedObjectCodeDir, "FilteredPropertiesTerminalOperations.ts"), await formatTs(`import { OntologyObject } from "../OntologyObject${importExt}` + reexportTypes(["FilteredPropertiesTerminalOperations", "FilteredPropertiesTerminalOperationsWithGet"], "<T extends OntologyObject, V extends Array<keyof T>>")));
+}
+async function generateTimeSeriesDir(timeseriesDir, fs2, importExt = "") {
+  await fs2.mkdir(timeseriesDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16.join(timeseriesDir, "index.ts"), await formatTs(`
+    export * from "./TimeSeries${importExt}";
+    export * from "./TimeSeriesDuration${importExt}";
+    export * from "./TimeSeriesPoint${importExt}";
+    ${""}
+    export * from "./TimeSeriesQuery${importExt}";
+    export * from "./TimeSeriesTerminalOperations${importExt}";
+  `));
+  await fs2.writeFile(path16.join(timeseriesDir, "TimeSeries.ts"), await formatTs(reexportTypes(["TimeSeries"], `<T extends number | string>`)));
+  await fs2.writeFile(path16.join(timeseriesDir, "TimeSeriesDuration.ts"), await formatTs(reexportTypes([`WhenUnit`, `DurationUnit`, `TimeSeriesDuration`])));
+  await fs2.writeFile(path16.join(timeseriesDir, "TimeSeriesPoint.ts"), await formatTs(reexportTypes(["TimeSeriesPoint"], `<T extends number | string>`)));
+  await fs2.writeFile(path16.join(timeseriesDir, "TimeSeriesQuery.ts"), await formatTs(reexportTypes(["TimeSeriesQuery"], `<T extends number | string>`)));
+  await fs2.writeFile(path16.join(timeseriesDir, "TimeSeriesTerminalOperations.ts"), await formatTs(reexportTypes(["TimeSeriesTerminalOperations", "TimeSeriesIterator"], `<T extends number | string>`)));
+}
+
+// src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateBaseTypesDir.ts
+async function generateBaseTypesDir(runtimeDistDir, fs2, importExt = "") {
+  const baseTypesDir = path16.join(runtimeDistDir, "baseTypes");
+  await fs2.mkdir(baseTypesDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16.join(baseTypesDir, "index.ts"), await formatTs(`export * from "./ActionType${importExt}";
+      export * from "./attachments/index${importExt}";
+      export * from "./geoshapes/index${importExt}";
+      export * from "./links${importExt}";
+      export * from "./localDate${importExt}";
+      export * from "./objectset/index${importExt}";
+      export * from "./ObjectType${importExt}";
+      export * from "./OntologyObject${importExt}";
+      export * from "./Queries${importExt}";
+      export * from "./timeseries/index${importExt}";
+      export * from "./timestamp${importExt}";`));
+  const geoshapesDir = path16.join(baseTypesDir, "geoshapes");
+  await generateGeoshapesDir(geoshapesDir, fs2, importExt);
+  const timeseriesDir = path16.join(baseTypesDir, "timeseries");
+  await generateTimeSeriesDir(timeseriesDir, fs2, importExt);
+  const attachmentsDir = path16.join(baseTypesDir, "attachments");
+  await generateAttachmentsDir(attachmentsDir, fs2, importExt);
+  const objectSetDir = path16.join(baseTypesDir, "objectset");
+  await generateObjectSetDir(objectSetDir, fs2, importExt);
+  const sharedObjectCodeDir = path16.join(baseTypesDir, "sharedObjectCode");
+  await generateSharedObjectCodeDir(sharedObjectCodeDir, fs2, importExt);
+  await fs2.writeFile(path16.join(baseTypesDir, "ActionType.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject${importExt}";
+      ` + reexportConsts(["ActionExecutionMode", "ReturnEditsMode", "ActionValidationResult"]) + reexportTypes(["ActionExecutionOptions", "ValidationResponse", "BulkEdits"]) + reexportTypes(["CreatedObjectEdits", "ModifiedObjectEdits"], "<T extends OntologyObject>") + reexportTypes(["Edits"], "<TAddedObjects extends OntologyObject | void, TModifiedObjects extends OntologyObject | void>") + reexportTypes(["ActionResponse"], "<TEdits extends Edits<any, any> | undefined = undefined>", "<TEdits>") + reexportTypes(["ActionResponseFromOptions"], "<TOptions extends ActionExecutionOptions | undefined = undefined, TEdits extends Edits<any, any> | undefined = undefined>", "<TOptions, TEdits>")));
+  await fs2.writeFile(path16.join(baseTypesDir, "OntologyObject.ts"), await formatTs(reexportTypes(["OntologyObject"]) + reexportConsts(["isOntologyObject"])));
+  await fs2.writeFile(path16.join(baseTypesDir, "links.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject${importExt}` + reexportTypes(["SingleLink", "MultiLink"], "<T extends OntologyObject = OntologyObject>")));
+  await fs2.writeFile(path16.join(baseTypesDir, "localDate.ts"), await formatTs(reexportConsts(["LocalDate"]) + reexportTypes(["LocalDate"])));
+  await fs2.writeFile(path16.join(baseTypesDir, "timestamp.ts"), await formatTs(reexportConsts(["Timestamp"]) + reexportTypes(["Timestamp"])));
+  await fs2.writeFile(path16.join(baseTypesDir, "Queries.ts"), await formatTs(`import { BucketValue, Range, Rangeable } from "../aggregations/index${importExt}";
+      ` + reexportTypes(["QueryResponse"], "<T>") + reexportTypes(["BaseBucket"], "<K, V>") + reexportTypes(["NestedBucket"], "<TGroupKey, TSegmentKey, TValue extends BucketValue>") + reexportTypes(["TwoDimensionalAggregation"], "<TGroupKey extends QueryBucketKey, TValue extends BucketValue = number>") + reexportTypes(["ThreeDimensionalAggregation"], "<TGroupKey extends QueryBucketKey, TSegmentKey extends QueryBucketKey, TValue extends BucketValue = number>") + reexportTypes(["QueryBucketKey"])));
+  await fs2.writeFile(path16.join(baseTypesDir, "ObjectType.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject${importExt}";` + reexportTypes(["BaseType", "StringType", "IntegerType", "DateType", "BooleanType", "ByteType", "DecimalType", "FloatType", "TimestampType", "ShortType", "LongType", "DoubleType", "GeoPointType", "GeoShapeType", "AttachmentType", "ObjectType", "StructField", "QueryBucketRangeableType", "QueryBucketKeyType", "QueryBucketValueType", "AllValueTypes", "OntologyType", "ObjectTypeProperties", "StructType"]) + reexportTypes(["TimeSeriesType", "ArrayType", "SetType"], "<T extends BaseType>") + reexportTypes(["Property"], "<TType extends OntologyType = OntologyType>") + reexportTypes(["BaseObjectType"], "<TOntologyObject extends OntologyObject = OntologyObject>") + reexportTypes(["ObjectSetType"], "<T extends ObjectType>") + reexportTypes(["RangeType"], "<T extends QueryBucketRangeableType>") + reexportTypes(["TwoDimensionalAggregationType"], "<TGroupKey extends QueryBucketKeyType, TValue extends QueryBucketValueType>") + reexportTypes(["ThreeDimensionalAggregationType"], "<TGroupKey extends QueryBucketKeyType, TSegmentKey extends QueryBucketKeyType, TValue extends QueryBucketValueType>")));
+}
+async function generateClientDir(runtimeDistDir, fs2, importExt = "") {
+  const pagingDir = path16__default.join(runtimeDistDir, "client");
+  await fs2.mkdir(pagingDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__default.join(pagingDir, "index.ts"), await formatTs(`export * from "./clientOptions${importExt}";`));
+  await fs2.writeFile(path16__default.join(pagingDir, "clientOptions.ts"), await formatTs(`import {Auth} from "@osdk/legacy-client";` + reexportTypes(["FoundryClientOptions"], "<TAuth extends Auth = Auth>")));
+}
+async function generateFiltersDir(runtimeDistDir, fs2, importExt = "") {
+  const pagingDir = path16__default.join(runtimeDistDir, "filters");
+  await fs2.mkdir(pagingDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__default.join(pagingDir, "index.ts"), await formatTs(`export * from "./ArrayFilter${importExt}";
+      export * from "./AttachmentFilter${importExt}";
+      export * from "./BooleanFilter${importExt}";
+      export * from "./DateTimeFilters${importExt}";
+      export * from "./Filters${importExt}";
+      export * from "./GeoPointFilter${importExt}";
+      export * from "./GeoShapeFilter${importExt}";
+      export * from "./NumericFilter${importExt}";
+      export * from "./Op${importExt}";
+      export * from "./OrderByOption${importExt}";
+      export * from "./StringFilter${importExt}";`));
+  await fs2.writeFile(path16__default.join(pagingDir, "ArrayFilter.ts"), await formatTs(`import { Attachment, GeoPoint, GeoShape, LocalDate, Timestamp } from "../baseTypes/index${importExt}";` + reexportConsts(["ArrayFilter"]) + reexportTypes(["ArrayFilter"], "<T extends string | number | Timestamp | LocalDate | boolean | GeoShape | GeoPoint | Attachment>")));
+  await fs2.writeFile(path16__default.join(pagingDir, "AttachmentFilter.ts"), await formatTs(reexportConsts(["AttachmentFilter"]) + reexportTypes(["AttachmentFilter"])));
+  await fs2.writeFile(path16__default.join(pagingDir, "BooleanFilter.ts"), await formatTs(reexportConsts(["BooleanFilter"]) + reexportTypes(["BooleanFilter"])));
+  await fs2.writeFile(path16__default.join(pagingDir, "GeoPointFilter.ts"), await formatTs(reexportConsts(["GeoPointFilter"]) + reexportTypes(["GeoPointFilter", "BoundingBox"])));
+  await fs2.writeFile(path16__default.join(pagingDir, "DateTimeFilters.ts"), await formatTs(reexportConsts(["TimestampFilter", "LocalDateFilter"]) + reexportTypes(["TimestampFilter", "LocalDateFilter"])));
+  await fs2.writeFile(path16__default.join(pagingDir, "GeoShapeFilter.ts"), await formatTs(reexportConsts(["GeoShapeFilter"]) + reexportTypes(["GeoShapeFilter"])));
+  await fs2.writeFile(path16__default.join(pagingDir, "NumericFilter.ts"), await formatTs(reexportConsts(["NumericFilter"]) + reexportTypes(["NumericFilter"])));
+  await fs2.writeFile(path16__default.join(pagingDir, "Op.ts"), await formatTs(reexportConsts(["Op"])));
+  await fs2.writeFile(path16__default.join(pagingDir, "OrderByOption.ts"), await formatTs(reexportConsts(["OrderByOption"]) + reexportTypes(["OrderByOption"])));
+  await fs2.writeFile(path16__default.join(pagingDir, "StringFilter.ts"), await formatTs(reexportConsts(["StringFilter"]) + reexportTypes(["StringFilter"])));
+  await fs2.writeFile(path16__default.join(pagingDir, "Filters.ts"), await formatTs(`import { OntologyObject } from "@osdk/legacy-client";` + reexportTypes(["ObjectTypeFilterFunction", "ObjectTypeOrderByFunction"], "<T extends OntologyObject>") + reexportTypes(["BoundingBoxFilter", "DistanceOf", "SearchClause", "LtWhereClause", "GtWhereClause", "LteWhereClause", "GteWhereClause", "EqWhereClause", "IsNullWhereClause", "ContainsWhereClause", "StartsWithWhereClause", "ContainsAllTermsInOrderWhereClause", "ContainsAnyTermWhereClause", "ContainsAllTermsWhereClause", "WithinDistanceOfWhereClause", "WithinBoundingBoxWhereClause", "IntersectsBoundingBoxWhereClause", "DoesNotIntersectBoundingBoxWhereClause", "WithinPolygonWhereClause", "IntersectsPolygonWhereClause", "DoesNotIntersectPolygonWhereClause", "AndWhereClause", "OrWhereClause", "NotWhereClause", "WhereClause", "OrderByClause"]) + reexportTypes(["FilterType"], "<T extends string | number>")));
+}
+async function generateErrors(fs2, ontologyProviderDir) {
+  await fs2.writeFile(path16.join(ontologyProviderDir, "Errors.ts"), await formatTs(reexportTypes(["PermissionDenied", "Unauthorized", "InvalidAggregationRangeValue", "MalformedPropertyFilters", "PropertiesNotFilterable", "ParametersNotFound", "ApplyActionFailed", "PropertyTypesSearchNotSupported", "InvalidParameterValue", "QueryTimeExceededLimit", "CompositePrimaryKeyNotSupported", "PropertyBaseTypeNotSupported", "PropertiesNotSearchable", "AttachmentNotFound", "ObjectTypeNotFound", "InvalidGroupId", "OntologySyncing", "ActionNotFound", "ParameterObjectSetRidNotFound", "LinkTypeNotFound", "InvalidRangeQuery", "ActionParameterObjectNotFound", "InvalidPropertyValue", "PropertiesNotSortable", "FunctionExecutionTimedOut", "InvalidFields", "ActionTypeNotFound", "ObjectTypeNotSynced", "OntologyEditsExceededLimit", "AggregationGroupCountExceededLimit", "InvalidContentType", "PropertiesNotFound", "FunctionInvalidInput", "InvalidSortOrder", "QueryDepthExceededLimit", "InvalidPropertyFiltersCombination", "ObjectsExceededLimit", "DuplicateOrderBy", "FunctionEncounteredUserFacingError", "InvalidUserId", "QueryNotFound", "InvalidAggregationRange", "ParameterObjectNotFound", "QueryMemoryExceededLimit", "InvalidContentLength", "OntologyNotFound", "ActionParameterObjectTypeNotFound", "UnknownParameter", "InvalidSortType", "PropertyFiltersNotSupported", "ActionValidationFailed", "MultipleGroupByOnFieldNotSupported", "LinkedObjectNotFound", "ActionEditedPropertiesNotFound", "InvalidPropertyFilterValue", "QueryEncounteredUserFacingError", "AttachmentSizeExceededLimit", "ObjectNotFound", "PropertyApiNameNotFound", "ParameterTypeNotSupported", "InvalidAggregationRangePropertyType", "MissingParameter"])));
+}
+async function generateOntologyMetadata(fs2, ontologyProviderDir) {
+  await fs2.writeFile(path16.join(ontologyProviderDir, "OntologyMetadata.ts"), await formatTs(reexportTypes(["OntologyMetadata"])));
+}
+async function generateResult(fs2, ontologyProviderDir) {
+  await fs2.writeFile(path16.join(ontologyProviderDir, "Result.ts"), await formatTs(`import {FoundryApiError} from "@osdk/legacy-client";
+        ` + reexportTypes(["Ok", "Err"], "<T>") + reexportTypes(["Result"], "<V, E = FoundryApiError>", "<V,E>") + reexportConsts(["isOk", "isErr", "visitError"]) + reexportTypes(["ErrorVisitor"], "<E extends FoundryApiError, R>", "<E,R>") + reexportTypes(["ExtractKeysWithType"], "<T, K extends keyof T>", "<T,K>")));
+}
+
+// src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateOntologyProviderDir.ts
+async function generateOntologyProviderDir(fs2, runtimeDistDir, importExt = "") {
+  const ontologyProviderDir = path16.join(runtimeDistDir, "ontologyProvider");
+  await fs2.mkdir(ontologyProviderDir, {
+    recursive: true
+  });
+  await generateErrors(fs2, ontologyProviderDir);
+  await generateOntologyMetadata(fs2, ontologyProviderDir);
+  await generateResult(fs2, ontologyProviderDir);
+  await fs2.writeFile(path16.join(ontologyProviderDir, "index.ts"), await formatTs(`
+    ${""}
+      export * from "./Errors${importExt}";
+      export * from "./OntologyMetadata${importExt}";
+      ${""}
+    ${""}
+      // export * from "./Result${importExt}";
+  `));
+}
+async function generatePagingDir(runtimeDistDir, fs2, importExt = "") {
+  const pagingDir = path16.join(runtimeDistDir, "paging");
+  await fs2.mkdir(pagingDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16.join(pagingDir, "index.ts"), await formatTs(`export * from "./Page${importExt}";`));
+  await fs2.writeFile(path16.join(pagingDir, "Page.ts"), await formatTs(reexportTypes(["Page"], "<T>")));
+}
+
+// src/v1.1/backcompat/generateOntologyRuntimeDistDir.ts
+async function generateOntologyRuntimeDistDir(outDir, fs2, importExt = "") {
+  const runtimeDistDir = path16.join(outDir, "internal", "@foundry", "ontology-runtime", "dist");
+  await fs2.mkdir(runtimeDistDir, {
+    recursive: true
+  });
+  await generateOntologyProviderDir(fs2, runtimeDistDir, importExt);
+  await generateAggregationsDir(fs2, runtimeDistDir, importExt);
+  await generatePagingDir(runtimeDistDir, fs2, importExt);
+  await generateBaseTypesDir(runtimeDistDir, fs2, importExt);
+  await generateClientDir(runtimeDistDir, fs2, importExt);
+  await generateFiltersDir(runtimeDistDir, fs2, importExt);
+  await fs2.writeFile(
+    path16.join(runtimeDistDir, "index.ts"),
+    // TRASHFIXME
+    await formatTs(`
+      export * from "./aggregations/index${importExt}";
+      export * from "./baseTypes/index${importExt}";
+      ${""}
+      // export * from "./filters/index${importExt}";
+      ${""}
+      ${""}
+    
+      export * from "./ontologyProvider/index${importExt}";
+      export * from "./paging/index${importExt}";
+`)
+  );
+}
+
+// src/v1.1/generateBackCompatDeprecatedExports.ts
+async function generateBackCompatDeprecatedExports(fs2, outDir, importExt = "") {
+  await generateOntologyRuntimeDistDir(outDir, fs2, importExt);
+  await generateOAuthClientDistDir(outDir, fs2, importExt);
+}
+async function generateBatchActions(ontology, fs2, outDir, importExt = "") {
+  const importedObjects = /* @__PURE__ */ new Set();
+  let actionSignatures = [];
+  for (const action of Object.values(ontology.actionTypes)) {
+    const entries = Object.entries(action.parameters);
+    const modifiedEntityTypes = getModifiedEntityTypes(action);
+    const addedObjects = Array.from(modifiedEntityTypes.addedObjects);
+    const modifiedObjects = Array.from(modifiedEntityTypes.modifiedObjects);
+    addedObjects.forEach(importedObjects.add, importedObjects);
+    modifiedObjects.forEach(importedObjects.add, importedObjects);
+    let jsDocBlock = ["/**"];
+    if (action.description) {
+      jsDocBlock.push(`* ${action.description}`);
+    }
+    let parameterBlock = "";
+    if (entries.length > 0) {
+      parameterBlock = `params: { 
+`;
+      for (const [parameterName, parameterData] of entries) {
+        parameterBlock += `"${parameterName}"`;
+        parameterBlock += parameterData.required ? ": " : "?: ";
+        const typeScriptType = getTypeScriptTypeFromDataType(parameterData.dataType, importedObjects);
+        parameterBlock += `${typeScriptType};
+`;
+        jsDocBlock.push(`* @param {${typeScriptType}} params.${parameterName}`);
+      }
+      parameterBlock += "}[], ";
+    } else {
+      parameterBlock = `params: Record<string,never>[], `;
+    }
+    jsDocBlock.push(`*/`);
+    actionSignatures.push(`
+      ${jsDocBlock.join("\n")}
+      ${action.apiName}<O extends BatchActionExecutionOptions>(${parameterBlock}options?: O): 
+        Promise<Result<BatchActionResponseFromOptions<O, Edits<${addedObjects.length > 0 ? addedObjects.join(" | ") : "void"}, ${modifiedObjects.length > 0 ? modifiedObjects.join(" | ") : "void"}>>, ActionError>>;
+      `);
+  }
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__default.join(outDir, "BatchActions.ts"), await formatTs(`
+    import type { ObjectSet, LocalDate, Timestamp, Attachment, Edits, ActionExecutionOptions, BatchActionExecutionOptions, ActionError, Result, ActionResponseFromOptions, BatchActionResponseFromOptions } from "@osdk/legacy-client";
+    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
+    export interface BatchActions {
+    ${actionSignatures.join("\n")}
+    }
+  `));
+}
+async function generateBulkActions(ontology, fs2, outDir, importExt = "") {
+  const importedObjects = /* @__PURE__ */ new Set();
+  let actionSignatures = [];
+  for (const action of Object.values(ontology.actionTypes)) {
+    const entries = Object.entries(action.parameters);
+    const modifiedEntityTypes = getModifiedEntityTypes(action);
+    const addedObjects = Array.from(modifiedEntityTypes.addedObjects);
+    const modifiedObjects = Array.from(modifiedEntityTypes.modifiedObjects);
+    addedObjects.forEach(importedObjects.add, importedObjects);
+    modifiedObjects.forEach(importedObjects.add, importedObjects);
+    let jsDocBlock = ["/**"];
+    if (action.description) {
+      jsDocBlock.push(`* ${action.description}`);
+    }
+    let parameterBlock = "";
+    if (entries.length > 0) {
+      parameterBlock = `params: { 
+`;
+      for (const [parameterName, parameterData] of entries) {
+        parameterBlock += `"${parameterName}"`;
+        parameterBlock += parameterData.required ? ": " : "?: ";
+        const typeScriptType = getTypeScriptTypeFromDataType(parameterData.dataType, importedObjects);
+        parameterBlock += `${typeScriptType};
+`;
+        jsDocBlock.push(`* @param {${typeScriptType}} params.${parameterName}`);
+      }
+      parameterBlock += "}[], ";
+    } else {
+      parameterBlock = `params: Record<string,never>[], `;
+    }
+    jsDocBlock.push(`*/`);
+    actionSignatures.push(`
+      ${jsDocBlock.join("\n")}
+      ${action.apiName}<O extends BulkActionExecutionOptions>(${parameterBlock}options?: O): 
+        Promise<Result<BulkActionResponseFromOptions<O, Edits<${addedObjects.length > 0 ? addedObjects.join(" | ") : "void"}, ${modifiedObjects.length > 0 ? modifiedObjects.join(" | ") : "void"}>>, ActionError>>;
+      `);
+  }
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__default.join(outDir, "BulkActions.ts"), await formatTs(`
+    import type { ObjectSet, LocalDate, Timestamp, Attachment, Edits, ActionExecutionOptions, BulkActionExecutionOptions, ActionError, Result, ActionResponseFromOptions, BulkActionResponseFromOptions } from "@osdk/legacy-client";
+    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
+    export interface BulkActions {
+    ${actionSignatures.join("\n")}
+    }
+  `));
+}
+async function generateFoundryClientFile(fs2, outDir, importExt = "") {
+  await fs2.writeFile(path16__default.join(outDir, "FoundryClient.ts"), await formatTs(`
+    import { BaseFoundryClient } from "@osdk/legacy-client";
+    import type { Auth, FoundryClientOptions } from "@osdk/legacy-client";
+    import { Ontology } from "./Ontology${importExt}";
+
+    export class FoundryClient<TAuth extends Auth = Auth> extends BaseFoundryClient<typeof Ontology, TAuth> {
+        constructor(options: FoundryClientOptions<TAuth>) {
+          super(options, Ontology);
+        }
+
+        get ontology(): Ontology {
+          return super.ontology;
+        }
+    }`));
+}
+async function generateIndexFile(fs2, outDir, importExt) {
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16.join(outDir, "index.ts"), await formatTs(`
+    export * from "@osdk/legacy-client";
+    export type { Ontology } from "./Ontology${importExt}";
+    export { FoundryClient } from "./FoundryClient${importExt}";
+    `));
+}
+
+// src/util/commaSeparatedIdentifiers.ts
+function commaSeparatedIdentifiers(identifiers, alternateNames) {
+  return identifiers.map((i) => {
+    const alt = alternateNames?.get(i);
+    if (alt) {
+      return `${i}: ${alt}`;
+    }
+    return i;
+  }).join(",");
+}
+
+// src/util/commaSeparatedTypeIdentifiers.ts
+function commaSeparatedTypeIdentifiers(identifiers, altNames) {
+  return identifiers.map((i) => `${i}: typeof ${altNames?.get(i) ?? i}`).join(",");
+}
+
+// src/v1.1/generateMetadataFile.ts
+async function generateMetadataFile(ontology, userAgent, fs2, outDir, importExt = "") {
+  const objectNames = Object.keys(ontology.objectTypes);
+  const actionNames = Object.keys(ontology.actionTypes);
+  const queryNames = Object.keys(ontology.queryTypes);
+  const actionAltNames = /* @__PURE__ */ new Map();
+  const queryAltNames = /* @__PURE__ */ new Map();
+  const seenIdentifiers = new Set(objectNames);
+  for (const actionName of actionNames) {
+    if (seenIdentifiers.has(actionName)) {
+      actionAltNames.set(actionName, `${actionName}Action`);
+    } else {
+      seenIdentifiers.add(actionName);
+    }
+  }
+  for (const queryName of queryNames) {
+    if (seenIdentifiers.has(queryName)) {
+      queryAltNames.set(queryName, `${queryName}Query`);
+    }
+  }
+  const getImportClause = (name, altNames) => {
+    const alt = altNames.get(name);
+    if (alt) {
+      return `${name} as ${alt}`;
+    } else {
+      return name;
+    }
+  };
+  await fs2.writeFile(path16__default.join(outDir, "Ontology.ts"), await formatTs(`
+  import type { OntologyDefinition } from "@osdk/api";
+  import type { Ontology as ClientOntology } from "@osdk/legacy-client";
+  import type { Objects } from "./ontology/objects/Objects${importExt}";
+  import type { Actions } from "./ontology/actions/Actions${importExt}";
+  import type { Queries } from "./ontology/queries/Queries${importExt}";
+  import type { BatchActions } from "./ontology/actions/BatchActions${importExt}";
+  import type { BulkActions } from "./ontology/actions/BulkActions${importExt}";
+  ${objectNames.map((name) => `import {${name}} from "./ontology/objects/${name}${importExt}";`).join("\n")}
+  ${actionNames.map((name) => `import {${getImportClause(name, actionAltNames)}} from "./ontology/actions/${name}${importExt}";`).join("\n")}
+  ${queryNames.map((name) => `import {${getImportClause(name, queryAltNames)}} from "./ontology/queries/${name}${importExt}";`).join("\n")}
+
+  export const Ontology : {
+    metadata: {
+      ontologyRid: "${ontology.ontology.rid}",
+      ontologyApiName: "${ontology.ontology.apiName}",
+      userAgent: "${userAgent}",
+    },
+    objects: {
+      ${commaSeparatedTypeIdentifiers(objectNames)}
+    },
+    actions: {
+      ${commaSeparatedTypeIdentifiers(actionNames, actionAltNames)}
+    },
+    queries: {
+      ${commaSeparatedTypeIdentifiers(queryNames, queryAltNames)}
+    },
+  } = {
+    metadata: {
+        ontologyRid: "${ontology.ontology.rid}" as const,
+        ontologyApiName: "${ontology.ontology.apiName}" as const,
+        userAgent: "${userAgent}" as const,
+    },
+    objects: {
+        ${commaSeparatedIdentifiers(objectNames)}
+    },
+    actions: {
+        ${commaSeparatedIdentifiers(actionNames, actionAltNames)}
+    },
+    queries: {
+        ${commaSeparatedIdentifiers(queryNames, queryAltNames)}
+    }
+  } satisfies OntologyDefinition<
+      ${stringUnionFrom(objectNames)},
+      ${stringUnionFrom(Object.values(ontology.actionTypes).map((actionType) => actionType.apiName))},
+      ${stringUnionFrom(Object.values(ontology.queryTypes).map((queryType) => queryType.apiName))}>;
+    
+export interface Ontology extends ClientOntology<typeof Ontology> {
+    objects: Objects;
+    actions: Actions;
+    /** @deprecated use batchActions */
+    bulkActions: BulkActions;
+    batchActions: BatchActions;
+    queries: Queries;
+}`));
+}
+function stringUnionFrom(values) {
+  if (values.length === 0) {
+    return "never";
+  }
+  return values.map((n) => `"${n}"`).join("|");
+}
+async function generateObjectsInterfaceFile(ontology, fs2, outDir, importExt = "") {
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__default.join(outDir, "Objects.ts"), await formatTs(`
+    import { BaseObjectSet } from "@osdk/legacy-client";
+    ${Array.from(Object.keys(ontology.objectTypes)).map((importedObject) => `import type { ${importedObject} } from "./${importedObject}${importExt}";`).join("\n")}
+    
+    export interface Objects {
+      ${Object.keys(ontology.objectTypes).map((apiName) => `${apiName} : BaseObjectSet<${apiName}>;`).join("\n")}
+    }
+    ;`));
+}
+async function generateObjectsInterfaceSupportFiles(ontology, fs2, outDir, importExt = "") {
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  for (const {
+    objectType: {
+      apiName
+    }
+  } of Object.values(ontology.objectTypes)) {
+    const fileName = join(outDir, `${apiName}.ts`);
+    const localApiName = `OG_${apiName}`;
+    const contents = [];
+    contents.push(`import { ObjectSetAggregateArg, ObjectSetFilterArg, ObjectSetGroupByArg, ObjectSetMultipleAggregateArg, ObjectSetOrderByArg } from "@osdk/legacy-client";`);
+    contents.push(`import { ${apiName} as ${localApiName} } from "../${apiName}${importExt}";`);
+    contents.push("");
+    contents.push(`/** @deprecated Use ${apiName} from ontology/objects instead */`, `export type ${apiName} = ${localApiName};`);
+    contents.push(`/** @deprecated Use ObjectSetFilterArg<${apiName}> instead */`, `export type ${apiName}Filter = ObjectSetFilterArg<${localApiName}>;`);
+    contents.push(`/** @deprecated Use ObjectSetOrderByArg<${apiName}> instead */`, `export type ${apiName}OrderBy = ObjectSetOrderByArg<${localApiName}>;`);
+    contents.push(`/** @deprecated Use ObjectSetGroupByArg<${apiName}> instead */`, `export type ${apiName}GroupByProperties = ObjectSetGroupByArg<${localApiName}>;`);
+    contents.push(`
+      /**
+        * Aggregation properties for ${apiName}
+        * @deprecated Use ObjectSetAggregateArg<${apiName}> instead
+        */`, `export type ${apiName}AggregationProperties = ObjectSetAggregateArg<${localApiName}>;`);
+    contents.push(`
+      /**
+        * Multiple aggregation properties for ${apiName}.
+        * @deprecated Use ObjectSetMultipleAggregateArg<${apiName}> instead
+        */`, `export type ${apiName}MultipleAggregationProperties = ObjectSetMultipleAggregateArg<${localApiName}>;`);
+    await fs2.writeFile(fileName, contents.join("\n"));
+  }
+}
+async function generateOntologyIndexFile(fs2, outDir) {
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16.join(outDir, "index.ts"), await formatTs(`
+        export type { ObjectSet } from "@osdk/legacy-client";
+    `));
+}
+async function generatePerObjectInterfaceAndDataFiles(ontology, fs2, outDir, importExt = "") {
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await Promise.all(Object.values(ontology.objectTypes).map(async (object) => {
+    object.linkTypes;
+    await fs2.writeFile(path16__default.join(outDir, `${object.objectType.apiName}.ts`), await formatTs(`
+        import type { ObjectTypeDefinition, ObjectTypeLinkDefinition, PropertyDef } from "@osdk/api";
+        ${wireObjectTypeV2ToObjectInterfaceStringV1(object, importExt)}
+
+        ${wireObjectTypeV2ToSdkObjectConst(object, importExt)}
+        `));
+  }));
+  await fs2.writeFile(path16__default.join(outDir, "index.ts"), await formatTs(`
+    ${Object.keys(ontology.objectTypes).map((apiName) => `export * from "./${apiName}${importExt}";`).join("\n")}
+      export type { ObjectSet } from "@osdk/legacy-client";
+
+    `));
+}
+
+// src/shared/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 {
+    type: "query",
+    apiName: input.apiName,
+    description: input.description,
+    displayName: input.displayName,
+    version: input.version,
+    parameters: Object.fromEntries(Object.entries(input.parameters).map(([name, parameter]) => [name, wireQueryParameterV2ToQueryParameterDefinition(parameter)])),
+    output: wireQueryDataTypeToQueryDataTypeDefinition(input.output)
+  };
+}
+function wireQueryParameterV2ToQueryParameterDefinition(parameter) {
+  return {
+    description: parameter.description,
+    ...wireQueryDataTypeToQueryDataTypeDefinition(parameter.dataType)
+  };
+}
+
+// src/v1.1/generatePerQueryDataFiles.ts
+async function generatePerQueryDataFiles(ontology, fs2, outDir, importExt = "") {
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await Promise.all(Object.values(ontology.queryTypes).map(async (query) => {
+    const objectTypes = getObjectTypesFromQuery(query);
+    await fs2.writeFile(path16__default.join(outDir, `${query.apiName}.ts`), await formatTs(`
+        import { QueryDefinition } from "@osdk/api";
+
+        export const ${query.apiName} = ${JSON.stringify(wireQueryTypeV2ToSdkQueryDefinition(query))} satisfies QueryDefinition<"${query.apiName}", ${objectTypes.length > 0 ? objectTypes.map((apiName) => `"${apiName}"`).join("|") : "never"}>;`));
+  }));
+  await fs2.writeFile(path16__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, fs2, outDir, importExt = "") {
+  const importedObjects = /* @__PURE__ */ new Set();
+  const signatures = [];
+  for (const query of Object.values(ontology.queryTypes)) {
+    const jsDocBlock = ["/**"];
+    if (query.description) {
+      jsDocBlock.push(`* ${query.description}`);
+    }
+    const outputType = handleQueryDataType(query.output, importedObjects, true);
+    const paramEntries = [];
+    for (const [name, parameter] of Object.entries(query.parameters)) {
+      const nullable = isNullableQueryDataType(parameter.dataType);
+      const type = handleQueryDataType(parameter.dataType, importedObjects, false);
+      paramEntries.push(`"${name}"${nullable ? "?" : ""}: ${type}`);
+      jsDocBlock.push(`* @param {${sanitizeDocTypeName(type)}} params.${name}${parameter.description ? ` - ${parameter.description}` : ""}`);
+    }
+    const param = paramEntries.length === 0 ? "" : `params: { ${paramEntries.join("; ")} }`;
+    jsDocBlock.push(`* @returns ${sanitizeDocTypeName(outputType)}`, "*/");
+    signatures.push(`
+      ${jsDocBlock.join("\n")}
+      ${query.apiName}(${param}): Promise<Result<QueryResponse<${outputType}>, QueryError>>;
+      `);
+  }
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  await fs2.writeFile(path16__default.join(outDir, "Queries.ts"), await formatTs(`
+    import type { QueryResponse, QueryError, Result, Timestamp, LocalDate, Range, Attachment, ObjectSet, TwoDimensionalAggregation, ThreeDimensionalAggregation  } from "@osdk/legacy-client";
+    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
+
+    export interface Queries {
+    ${signatures.join("\n")}
+    }
+  `));
+}
+function handleQueryDataType(dataType, importedObjects, isReturnValue) {
+  switch (dataType.type) {
+    case "boolean":
+      return "boolean";
+    case "string":
+      return "string";
+    case "double":
+    case "float":
+    case "integer":
+      return "number";
+    case "long":
+      return isReturnValue ? "string" : "string | number";
+    case "date":
+      return "LocalDate";
+    case "timestamp":
+      return "Timestamp";
+    case "attachment":
+      return "Attachment";
+    case "array":
+      return `Array<${handleQueryDataType(dataType.subType, importedObjects, isReturnValue)}>`;
+    case "object": {
+      const objectType = dataType.objectTypeApiName;
+      importedObjects.add(objectType);
+      return isReturnValue ? objectType : `${objectType} | ${objectType}["__primaryKey"]`;
+    }
+    case "objectSet": {
+      const objectType = dataType.objectTypeApiName;
+      importedObjects.add(objectType);
+      return `ObjectSet<${objectType}>`;
+    }
+    case "set":
+      return `Set<${handleQueryDataType(dataType.subType, importedObjects, isReturnValue)}>`;
+    case "struct":
+      const properties = dataType.fields.map((field) => {
+        const isNullable = isNullableQueryDataType(field.fieldType);
+        return `${field.name}${isNullable ? "?" : ""}: ${handleQueryDataType(field.fieldType, importedObjects, isReturnValue)}`;
+      });
+      return `{ ${properties.join(",\n")} }`;
+    case "union":
+      return dataType.unionTypes.map((type) => handleQueryDataType(type, importedObjects, isReturnValue)).filter((type) => type !== "null").join("|");
+    case "twoDimensionalAggregation":
+      dataType.valueType;
+      return `TwoDimensionalAggregation<
+        ${aggregationKeyToTypescriptType(dataType.keyType)},
+        ${aggregationValueToTypescriptType(dataType.valueType)}
+      >`;
+    case "threeDimensionalAggregation":
+      return `ThreeDimensionalAggregation<
+        ${aggregationKeyToTypescriptType(dataType.keyType)},
+        ${aggregationKeyToTypescriptType(dataType.valueType.keyType)},
+        ${aggregationValueToTypescriptType(dataType.valueType.valueType)}
+      >`;
+    case "null":
+      return "null";
+    case "unsupported":
+      throw new Error("Cannot generate queries for unsupported type");
+    default:
+      throw new Error(`Cannot generate queries for type ${dataType.type}`);
+  }
+}
+function aggregationKeyToTypescriptType(keyType) {
+  switch (keyType.type) {
+    case "boolean":
+      return "boolean";
+    case "double":
+    case "integer":
+      return "number";
+    case "string":
+      return "string";
+    case "date":
+      return "LocalDate";
+    case "timestamp":
+      return "Timestamp";
+    case "range":
+      return `Range<${aggregationRangeToTypescriptType(keyType.subType)}>`;
+    default:
+      throw new Error(`Unknown TwoDimensionalAggregation keyType ${keyType.type}`);
+  }
+}
+function aggregationRangeToTypescriptType(subType) {
+  switch (subType.type) {
+    case "date":
+      return "LocalDate";
+    case "double":
+    case "integer":
+      return "number";
+    case "timestamp":
+      return "Timestamp";
+    default:
+      throw new Error(`Unsupported QueryAggregationRangeSubType ${subType.type}`);
+  }
+}
+function aggregationValueToTypescriptType(valueType) {
+  switch (valueType.type) {
+    case "date":
+      return "LocalDate";
+    case "double":
+      return "number";
+    case "timestamp":
+      return "Timestamp";
+    default:
+      throw new Error(`Unsupported QueryAggregationValueType ${valueType.type}`);
+  }
+}
+function sanitizeDocTypeName(type) {
+  return type.replace(/\s/g, "");
+}
+
+// src/v1.1/generateClientSdkVersionOneDotOne.ts
+async function generateClientSdkVersionOneDotOne(ontology, userAgent, fs2, outDir, packageType = "commonjs") {
+  const importExt = packageType === "module" ? ".js" : "";
+  const objectsDir = path16.join(outDir, "ontology", "objects");
+  const actionsDir = path16.join(outDir, "ontology", "actions");
+  const queriesDir = path16.join(outDir, "ontology", "queries");
+  await verifyOutdir(outDir, fs2);
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  const sanitizedOntology = sanitizeMetadata(ontology);
+  await generateFoundryClientFile(fs2, outDir, importExt);
+  await generateMetadataFile(sanitizedOntology, userAgent, fs2, outDir, importExt);
+  await generateOntologyIndexFile(fs2, path16.join(outDir, "ontology"));
+  await generateObjectsInterfaceFile(sanitizedOntology, fs2, objectsDir, importExt);
+  await generateObjectsInterfaceSupportFiles(sanitizedOntology, fs2, path16.join(objectsDir, "objects-api"), importExt);
+  await generatePerObjectInterfaceAndDataFiles(sanitizedOntology, fs2, objectsDir, importExt);
+  await generateActions(sanitizedOntology, fs2, actionsDir, importExt);
+  await generateBatchActions(sanitizedOntology, fs2, actionsDir, importExt);
+  await generateBulkActions(sanitizedOntology, fs2, actionsDir, importExt);
+  await generatePerActionDataFiles(sanitizedOntology, fs2, actionsDir, importExt, false);
+  await generateQueries(sanitizedOntology, fs2, queriesDir, importExt);
+  await generatePerQueryDataFiles(sanitizedOntology, fs2, queriesDir, importExt);
+  await generateIndexFile(fs2, outDir, importExt);
+  await generateBackCompatDeprecatedExports(fs2, outDir, importExt);
+}
+function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, v2 = false) {
+  const definition = deleteUndefineds(__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(interfaceDef, v2));
+  const objectDefIdentifier = getObjectDefIdentifier(interfaceDef.apiName, v2);
+  function getV2Types() {
+    return `
+  export interface ${objectDefIdentifier} extends InterfaceDefinition<"${interfaceDef.apiName}", ${interfaceDef.apiName}>, VersionBound<$ExpectedClientVersion> {
+    osdkMetadata: typeof $osdkMetadata;
+    ${stringify(definition, {
+      osdkMetadata: () => void 0,
+      type: () => void 0,
+      apiName: () => void 0,
+      links: (_value) => `{
+      ${stringify(definition.links, {
+        "*": (definition2) => `ObjectTypeLinkDefinition<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
+      })}
+    }`,
+      properties: (_value) => `{
+      ${stringify(definition.properties, {
+        "*": (propertyDefinition) => `PropertyDef<"${propertyDefinition.type}", "${propertyDefinition.nullable ? "nullable" : "non-nullable"}", "${propertyDefinition.multiplicity ? "array" : "single"}">`
+      })}
+    }`
+    })}
+  }
+
+`;
+  }
+  const imports = [];
+  return `${imports.join("\n")}
+
+    ${v2 ? getV2Types() : ""}
+
+    export const ${definition.apiName}: ${objectDefIdentifier} = {
+      osdkMetadata: $osdkMetadata,
+      ${stringify(definition, {
+    osdkMetadata: () => void 0
+  })}
+      
+    };`;
+}
+var ExpectedOsdkVersion = "0.19.0";
+async function generateOntologyMetadataFile(ontology, userAgent, fs2, outDir) {
+  fs2.writeFile(path16__default.join(outDir, "OntologyMetadata.ts"), await formatTs(`
+      import { OntologyMetadata as OM } from "@osdk/api";
+
+      export type $ExpectedClientVersion = "${ExpectedOsdkVersion}";
+      export const $osdkMetadata = { extraUserAgent: "${userAgent}" };
+
+      export interface OntologyMetadata extends OM<$ExpectedClientVersion> {};
+
+      export const OntologyMetadata: OntologyMetadata = {
+        expectsClientVersion: "${ExpectedOsdkVersion}",
+        ontologyRid: "${ontology.ontology.rid}",
+        ontologyApiName: "${ontology.ontology.apiName}",
+        userAgent: "${userAgent}",
+      };
+      `));
+}
+
+// src/v2.0/generateClientSdkVersionTwoPointZero.ts
+async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs2, outDir, packageType = "commonjs") {
+  await verifyOutdir(outDir, fs2);
+  const sanitizedOntology = sanitizeMetadata(ontology);
+  const objectNames = Object.keys(sanitizedOntology.objectTypes).sort((a, b) => a.localeCompare(b));
+  const actionNames = Object.keys(sanitizedOntology.actionTypes).sort((a, b) => a.localeCompare(b));
+  Object.keys(sanitizedOntology.queryTypes).sort((a, b) => a.localeCompare(b));
+  const interfaceNames = Object.keys(sanitizedOntology.interfaceTypes ?? {}).sort((a, b) => a.localeCompare(b));
+  const importExt = packageType === "module" ? ".js" : "";
+  await fs2.mkdir(outDir, {
+    recursive: true
+  });
+  fs2.writeFile(path16__default.join(outDir, "index.ts"), await formatTs(`
+        export { Ontology } from "./Ontology${importExt}";
+        export * from "./ontology/actions/index${importExt}";
+        export * from "./ontology/objects${importExt}";
+        export * from "./ontology/interfaces${importExt}";
+    `));
+  await generateOntologyMetadataFile(sanitizedOntology, userAgent, fs2, outDir);
+  await fs2.writeFile(path16__default.join(outDir, "Ontology.ts"), await formatTs(`
+      import type { OntologyDefinition } from "@osdk/api";
+      import * as Actions from "./ontology/actions/index${importExt}";
+      import * as Objects from "./ontology/objects${importExt}";
+      import * as Interfaces from "./ontology/interfaces${importExt}";
+      import { OntologyMetadata } from "./OntologyMetadata${importExt}";
+      
+      const _Ontology = {
+        metadata: OntologyMetadata,
+        objects: {
+          ${objectNames.map((objectName) => {
+    return `${objectName}: Objects.${objectName}`;
+  }).join(",\n")}
+          
+        },
+        actions: {
+          ${actionNames.map((actionName) => {
+    return `${actionName}: Actions.${actionName}`;
+  }).join(",\n")}
+        },
+        queries: {
+          // TODO
+        },
+        interfaces: {
+          ${interfaceNames.map((objectName) => {
+    return `${objectName}: Interfaces.${objectName}`;
+  }).join(",\n")}
+              
+        }
+      } satisfies OntologyDefinition<${stringUnionFrom2(objectNames)}>;
+
+      type _Ontology = typeof _Ontology;
+      export interface Ontology extends _Ontology {}
+      export const Ontology = _Ontology as Ontology;
+    `));
+  await fs2.mkdir(path16__default.join(outDir, "ontology", "objects"), {
+    recursive: true
+  });
+  for (const name of objectNames) {
+    const obj = ontology.objectTypes[name];
+    await fs2.writeFile(path16__default.join(outDir, "ontology", `objects`, `${name}.ts`), await formatTs(`
+        import type { ObjectTypeDefinition, VersionBound, ObjectTypeLinkDefinition, PropertyDef } from "@osdk/api";
+        import { Osdk } from "@osdk/client";
+        import { $osdkMetadata } from "../../OntologyMetadata${importExt}";
+        import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
+
+        ${wireObjectTypeV2ToSdkObjectConst(obj, importExt, true)}
+      `));
+  }
+  await generateOntologyInterfaces(fs2, outDir, interfaceNames, ontology, importExt);
+  const actionsDir = path16__default.join(outDir, "ontology", "actions");
+  await fs2.mkdir(actionsDir, {
+    recursive: true
+  });
+  await generatePerActionDataFiles(sanitizedOntology, fs2, actionsDir, importExt, true);
+  await fs2.writeFile(path16__default.join(outDir, "ontology", "objects.ts"), await formatTs(`
+    ${Object.keys(ontology.objectTypes).sort((a, b) => a.localeCompare(b)).map((apiName) => `export * from "./objects/${apiName}${importExt}";`).join("\n")}
+    ${Object.keys(ontology.objectTypes).length === 0 ? "export {};" : ""}
+    `));
+}
+function stringUnionFrom2(values) {
+  if (values.length === 0) {
+    return "never";
+  } else {
+    return values.map((v) => `"${v}"`).join("|");
+  }
+}
+async function generateOntologyInterfaces(fs2, outDir, interfaceNames, ontology, importExt) {
+  const interfacesDir = path16__default.join(outDir, "ontology", "interfaces");
+  await fs2.mkdir(interfacesDir, {
+    recursive: true
+  });
+  for (const name of interfaceNames) {
+    const obj = ontology.interfaceTypes[name];
+    await fs2.writeFile(path16__default.join(interfacesDir, `${name}.ts`), await formatTs(`
+    
+      import type { InterfaceDefinition, PropertyDef, VersionBound } from "@osdk/api";
+      import { $osdkMetadata, $expectedClientVersion } from "../../OntologyMetadata${importExt}";
+      import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
+
+      ${__UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(obj, true)}
+    `));
+  }
+  await fs2.writeFile(interfacesDir + ".ts", await formatTs(`
+    ${Object.keys(ontology.interfaceTypes ?? {}).map((apiName) => `export * from "./interfaces/${apiName}${importExt}";`).join("\n")}
+    ${Object.keys(ontology.interfaceTypes ?? {}).length === 0 ? "export {}" : ""}
+    `));
+}
+
+// src/generateClientSdkPackage.ts
+async function generateClientSdkPackage(packageName, packageVersion, sdkVersion, baseOutDir, ontology, minimalFs, dependencyVersions, cliVersion) {
+  if (!packageName)
+    throw new Error("Package name is require");
+  for (const packageType of ["module", "commonjs"]) {
+    const outDir = path16.join(baseOutDir, "dist", packageType);
+    await (sdkVersion === "1.1" ? generateClientSdkVersionOneDotOne : sdkVersion === "2.0" ? generateClientSdkVersionTwoPointZero : void 0)(ontology, `typescript-sdk/${packageVersion} osdk-cli/${cliVersion}`, minimalFs, outDir, packageType);
+    await fs.promises.mkdir(outDir, {
+      recursive: true
+    });
+    await writeJson(minimalFs, path16.join(outDir, "package.json"), {
+      type: packageType
+    });
+    await writeJson(minimalFs, path16.join(outDir, `tsconfig.json`), {
+      compilerOptions: getTsCompilerOptions(packageType)
+    });
+  }
+  await writeJson(minimalFs, path16.join(baseOutDir, "package.json"), await getPackageJsonContents(packageName, packageVersion, sdkVersion, dependencyVersions));
+  await minimalFs.mkdir(path16.join(baseOutDir, "ontology"), {
+    recursive: true
+  });
+  await minimalFs.writeFile(path16.join(baseOutDir, "ontology", "objects.js"), `module.exports = require("../../dist/module/ontology/objects")`);
+  await minimalFs.writeFile(path16.join(baseOutDir, "ontology", "objects.d.ts"), `export * from "../dist/module/ontology/objects"`);
+}
+function getTsCompilerOptions(packageType) {
+  const commonTsconfig = {
+    importHelpers: true,
+    declaration: true,
+    isolatedModules: true,
+    esModuleInterop: true,
+    forceConsistentCasingInFileNames: true,
+    strict: true,
+    skipLibCheck: true
+  };
+  const compilerOptions = packageType === "commonjs" ? {
+    ...commonTsconfig,
+    module: "commonjs",
+    target: "es2018"
+  } : {
+    ...commonTsconfig,
+    module: "NodeNext",
+    target: "ES2020"
+  };
+  return compilerOptions;
+}
+function getPackageJsonContents(name, version, sdkVersion, {
+  typescriptVersion,
+  tslibVersion,
+  areTheTypesWrongVersion,
+  osdkApiVersion,
+  osdkClientVersion,
+  osdkLegacyClientVersion
+}) {
+  const esmPrefix = "./dist/module";
+  const commonjsPrefix = "./dist/commonjs";
+  return {
+    name,
+    version,
+    main: `${commonjsPrefix}/index.js`,
+    module: `${esmPrefix}/index.js`,
+    exports: {
+      ".": {
+        import: `${esmPrefix}/index.js`,
+        require: `${commonjsPrefix}/index.js`
+      },
+      "./ontology/objects": {
+        import: `${esmPrefix}/ontology/objects${sdkVersion === "2.0" ? "" : "/index"}.js`,
+        require: `${commonjsPrefix}/ontology/objects${sdkVersion === "2.0" ? "" : "/index"}.js`
+      }
+    },
+    scripts: {
+      prepack: `tsc -p ${esmPrefix}/tsconfig.json && tsc -p ${commonjsPrefix}/tsconfig.json`,
+      check: "npm exec attw $(npm pack)"
+    },
+    devDependencies: {
+      "typescript": typescriptVersion,
+      "tslib": tslibVersion,
+      "@arethetypeswrong/cli": areTheTypesWrongVersion,
+      "@osdk/api": osdkApiVersion,
+      ...sdkVersion === "2.0" ? {
+        "@osdk/client": osdkClientVersion
+      } : {
+        "@osdk/legacy-client": osdkLegacyClientVersion
+      }
+    },
+    peerDependencies: {
+      "@osdk/api": osdkApiVersion,
+      ...sdkVersion === "2.0" ? {
+        "@osdk/client": osdkClientVersion
+      } : {
+        "@osdk/legacy-client": osdkLegacyClientVersion
+      }
+    },
+    files: ["**/*.js", "**/*.d.ts", "dist/**/package.json"]
+  };
+}
+async function writeJson(minimalFs, filePath, body) {
+  return await minimalFs.writeFile(filePath, JSON.stringify(body, void 0, 2) + "\n");
+}
+
+export { generateClientSdkPackage as __UNSTABLE_generateClientSdkPackage, generateClientSdkVersionOneDotOne, generateClientSdkVersionTwoPointZero };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.browser.mjs.map