@osdk/generator 1.14.0-beta.4 → 2.0.0-beta.11

package/build/cjs/index.cjs

@@ -1,2928 +0,0 @@
-'use strict';
-
-var fs = require('fs');
-var path16 = require('path');
-var generatorConverters = require('@osdk/generator-converters');
-var prettier = require('prettier');
-var organizeImports = require('prettier-plugin-organize-imports');
-var fastDeepEqual = require('fast-deep-equal');
-var invariant = require('tiny-invariant');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-var path16__namespace = /*#__PURE__*/_interopNamespace(path16);
-var organizeImports__default = /*#__PURE__*/_interopDefault(organizeImports);
-var fastDeepEqual__default = /*#__PURE__*/_interopDefault(fastDeepEqual);
-var invariant__default = /*#__PURE__*/_interopDefault(invariant);
-
-// src/generateClientSdkPackage.ts
-var AbstractImportable = class {
-  /**
-   * Either a path relative to the ourDir (e.g. "./ontology/objects/foo.js") or a normal
-   * module import (e.g. "@something/foo")/
-   */
-  constructor(common, fullApiName, basePath) {
-    this._common = common;
-    this.fullApiName = fullApiName;
-    [this.apiNamespace, this.shortApiName] = extractNamespace(this.fullApiName);
-    const {
-      ontologyApiNamespace,
-      apiNamespacePackageMap,
-      importExt
-    } = common;
-    this.isLocal = ontologyApiNamespace === this.apiNamespace;
-    this.sourcePackage = this.apiNamespace && !this.isLocal ? apiNamespacePackageMap.get(this.apiNamespace) : void 0;
-    this.importPath = this.isLocal ? `${basePath}/${this.shortApiName}${importExt}` : this.sourcePackage;
-    this.uniqueImportName = this.shortApiName;
-  }
-  getImportPathRelTo = (filePath) => {
-    if (this.importPath.startsWith(".")) {
-      const result = path16__namespace.relative(path16__namespace.dirname(filePath), this.importPath);
-      if (result.startsWith(".")) {
-        return result;
-      } else {
-        return `./${result}`;
-      }
-    } else {
-      return this.importPath;
-    }
-  };
-};
-var EnhancedBase = class extends AbstractImportable {
-  constructor(common, og, fullApiName, basePath) {
-    super(common, fullApiName, basePath);
-    this.og = og;
-    if (!this.isLocal && !this.sourcePackage) {
-      throw new Error(`Expected { ns:'${this.apiNamespace}', shortName: '${this.shortApiName}'} to be in namespace '${common.ontologyApiNamespace}' or in a provided package mapping`);
-    }
-  }
-};
-function extractNamespace(fqApiName) {
-  const last = fqApiName.lastIndexOf(".");
-  if (last === -1) return [void 0, fqApiName];
-  return [fqApiName.slice(0, last), fqApiName.slice(last + 1)];
-}
-
-// src/GenerateContext/EnhancedAction.ts
-var EnhancedAction = class extends EnhancedBase {
-  constructor(common, og) {
-    super(common, og, og.apiName, "./ontology/actions");
-    this.og = og;
-  }
-  get description() {
-    return this.og.description;
-  }
-  get parameters() {
-    return this.og.parameters;
-  }
-  get operations() {
-    return this.og.operations;
-  }
-  get paramsIdentifier() {
-    return `${this.shortApiName}.Params`;
-  }
-  get definitionIdentifier() {
-    return `${this.shortApiName}.Definition`;
-  }
-  get definitionParamsIdentifier() {
-    return `${this.shortApiName}.ParamsDefinition`;
-  }
-};
-
-// src/util/deleteUndefineds.ts
-function deleteUndefineds(obj) {
-  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== void 0));
-}
-
-// src/GenerateContext/EnhancedInterfaceType.ts
-var EnhancedInterfaceType = class extends EnhancedBase {
-  constructor(common, og) {
-    super(common, og, og.apiName, "./ontology/interfaces");
-    this.og = og;
-  }
-  getDefinitionIdentifier(v2) {
-    return v2 ? this.shortApiName : `${this.shortApiName}Def`;
-  }
-  getImportedDefinitionIdentifier(v2) {
-    return this.getDefinitionIdentifier(v2);
-  }
-  get properties() {
-    return this.og.properties;
-  }
-  getCleanedUpDefinition(v2) {
-    return deleteUndefineds(generatorConverters.__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(this.og, v2));
-  }
-};
-var EnhancedObjectType = class extends EnhancedBase {
-  constructor(common, og) {
-    super(common, og, og.objectType.apiName, "./ontology/objects");
-    this.og = og;
-  }
-  getDefinitionIdentifier(v2) {
-    return v2 ? `${this.shortApiName}` : `${this.shortApiName}Def`;
-  }
-  getImportedDefinitionIdentifier(v2) {
-    return this.getDefinitionIdentifier(v2);
-  }
-  getCleanedUpDefinition(v2) {
-    return deleteUndefineds(generatorConverters.wireObjectTypeFullMetadataToSdkObjectTypeDefinition(this.og, v2));
-  }
-};
-
-// src/GenerateContext/EnhancedQuery.ts
-var EnhancedQuery = class extends EnhancedBase {
-  constructor(common, og) {
-    super(common, og, og.apiName, "./ontology/queries");
-    this.og = og;
-  }
-  get description() {
-    return this.og.description;
-  }
-  get parameters() {
-    return this.og.parameters;
-  }
-  get output() {
-    return this.og.output;
-  }
-  get paramsIdentifier() {
-    return `${this.shortApiName}.Parameters`;
-  }
-  get definitionIdentifier() {
-    return `${this.shortApiName}.Definition`;
-  }
-  get definitionParamsIdentifier() {
-    return `${this.definitionIdentifier}$Params`;
-  }
-};
-
-// src/GenerateContext/EnhancedSharedPropertyType.ts
-var EnhancedSharedPropertyType = class extends EnhancedBase {
-  constructor(common, og) {
-    super(common, og, og.apiName, "./ontology/interfaces");
-    this.og = og;
-  }
-};
-
-// src/GenerateContext/ForeignType.ts
-var ForeignType = class extends AbstractImportable {
-  constructor(_common, type, apiNamespace, shortApiName) {
-    super(_common, `${apiNamespace}.${shortApiName}`, _common.apiNamespacePackageMap.get(apiNamespace));
-    this._common = _common;
-    this.type = type;
-  }
-  getImportedDefinitionIdentifier(v2) {
-    return `$Imported$${this.type}$${this.apiNamespace.replace(/\./g, "$")}$${this.shortApiName}`;
-  }
-  getDefinitionIdentifier(v2) {
-    if (this.type === "objectTypes") {
-      return v2 ? this.uniqueImportName : `${this.uniqueImportName}Def`;
-    } else {
-      return this.uniqueImportName;
-    }
-  }
-};
-
-// src/GenerateContext/EnhancedOntologyDefinition.ts
-var EnhancedOntologyDefinition = class {
-  constructor(original, ontologyApiNamespace, apiNamespacePackageMap, importExt) {
-    this.common = {
-      apiNamespacePackageMap,
-      enhancedOntology: this,
-      importExt,
-      ontologyApiNamespace
-    };
-    this.og = original;
-    this.ontology = original.ontology;
-    this.objectTypes = remap(original.objectTypes, this.common, EnhancedObjectType);
-    this.actionTypes = remap(original.actionTypes, this.common, EnhancedAction);
-    this.queryTypes = remap(original.queryTypes, this.common, EnhancedQuery);
-    this.interfaceTypes = remap(original.interfaceTypes, this.common, EnhancedInterfaceType);
-    this.sharedPropertyTypes = remap(original.sharedPropertyTypes, this.common, EnhancedSharedPropertyType);
-  }
-  #createRequireType = (type) => {
-    return (fullApiName, localOnly) => {
-      const ret = this[type][fullApiName];
-      if (!ret) {
-        const [apiNamespace, shortApiName] = extractNamespace(fullApiName);
-        if (localOnly || !apiNamespace) {
-          throw new Error(`Unable to find ${type}: No entry for '${fullApiName}`);
-        }
-        if (!this.common.apiNamespacePackageMap.has(apiNamespace)) {
-          throw new Error(`Unable to find ${type}: Unknown namespace '${apiNamespace}'`);
-        }
-        return new ForeignType(this.common, type, apiNamespace, shortApiName);
-      }
-      return ret;
-    };
-  };
-  requireObjectType = this.#createRequireType("objectTypes");
-  requireInterfaceType = this.#createRequireType("interfaceTypes");
-  requireActionType = this.#createRequireType("actionTypes");
-  requireQueryType = this.#createRequireType("queryTypes");
-  requireSharedPropertyType = this.#createRequireType("sharedPropertyTypes");
-};
-function remap(r, common, Constructor) {
-  return Object.fromEntries(Object.entries(r ?? {}).map(([fullApiName, v]) => {
-    return [fullApiName, new Constructor(common, v)];
-  }).sort((a, b) => a[0].localeCompare(b[0])));
-}
-
-// src/GenerateContext/enhanceOntology.ts
-function enhanceOntology(sanitized, ontologyApiNamespace, apiNamespacePackageMap, importExt) {
-  return new EnhancedOntologyDefinition(sanitized, ontologyApiNamespace, apiNamespacePackageMap, importExt);
-}
-
-// src/shared/sanitizeMetadata.ts
-function sanitizeMetadata(ontology) {
-  return {
-    ...ontology,
-    actionTypes: Object.fromEntries(Object.values(ontology.actionTypes).map((actionType) => {
-      return [camelize(actionType.apiName), {
-        ...actionType,
-        apiName: camelize(actionType.apiName)
-      }];
-    }))
-  };
-}
-function camelize(name) {
-  return name.replace(/-./g, (segment) => segment[1].toUpperCase());
-}
-
-// src/util/verifyOutDir.ts
-async function verifyOutDir(outDir, fs2) {
-  try {
-    const contents = await fs2.readdir(outDir);
-    if (contents.length !== 0) {
-      throw new Error(`outDir ${outDir} is not empty, please delete its contents and try again`);
-    }
-  } catch (e) {
-    if (e.code === "ENOENT") ; else {
-      throw e;
-    }
-  }
-}
-
-// src/shared/getEditedEntities.ts
-function getModifiedEntityTypes(action) {
-  const addedObjects = /* @__PURE__ */ new Set();
-  const modifiedObjects = /* @__PURE__ */ new Set();
-  for (const operation of action.operations) {
-    switch (operation.type) {
-      case "createObject":
-        addedObjects.add(operation.objectTypeApiName);
-        break;
-      case "modifyObject":
-        modifiedObjects.add(operation.objectTypeApiName);
-        break;
-    }
-  }
-  return {
-    addedObjects,
-    modifiedObjects
-  };
-}
-function formatTs(contents) {
-  try {
-    return prettier.format(contents, {
-      parser: "typescript",
-      singleQuote: true,
-      trailingComma: "all",
-      plugins: [organizeImports__default.default],
-      tabWidth: 2,
-      printWidth: 120
-    });
-  } catch (e) {
-    console.error("Failed to format file", e);
-    console.log(contents);
-    return contents;
-  }
-}
-
-// src/v1.1/generateActions.ts
-async function generateActions(ontology, fs2, outDir, importExt = "") {
-  const importedObjects = /* @__PURE__ */ new Set();
-  let actionSignatures = [];
-  for (const action of Object.values(ontology.actionTypes)) {
-    const entries = Object.entries(action.parameters);
-    const modifiedEntityTypes = getModifiedEntityTypes(action);
-    const addedObjects = Array.from(modifiedEntityTypes.addedObjects);
-    const modifiedObjects = Array.from(modifiedEntityTypes.modifiedObjects);
-    addedObjects.forEach(importedObjects.add, importedObjects);
-    modifiedObjects.forEach(importedObjects.add, importedObjects);
-    let jsDocBlock = ["/**"];
-    if (action.description) {
-      jsDocBlock.push(`* ${action.description}`);
-    }
-    let parameterBlock = "";
-    if (entries.length > 0) {
-      parameterBlock = `params: { 
-`;
-      for (const [parameterName, parameterData] of entries) {
-        parameterBlock += `"${parameterName}"`;
-        parameterBlock += parameterData.required ? ": " : "?: ";
-        const typeScriptType = getTypeScriptTypeFromDataType(parameterData.dataType, importedObjects);
-        parameterBlock += `${typeScriptType};
-`;
-        jsDocBlock.push(`* @param {${typeScriptType}} params.${parameterName}`);
-      }
-      parameterBlock += "}, ";
-    }
-    jsDocBlock.push(`*/`);
-    actionSignatures.push(`
-      ${jsDocBlock.join("\n")}
-      ${action.apiName}<O extends ActionExecutionOptions>(${parameterBlock}options?: O): 
-        Promise<Result<ActionResponseFromOptions<O, Edits<${addedObjects.length > 0 ? addedObjects.join(" | ") : "void"}, ${modifiedObjects.length > 0 ? modifiedObjects.join(" | ") : "void"}>>, ActionError>>;`);
-  }
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.default.join(outDir, "Actions.ts"), await formatTs(`
-    import type { ObjectSet, LocalDate, Timestamp, Attachment, Edits, ActionExecutionOptions, ActionError, Result, ActionResponseFromOptions } from "@osdk/legacy-client";
-    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
-    export interface Actions {
-    ${actionSignatures.join("\n")}
-    }
-  `));
-}
-function getTypeScriptTypeFromDataType(actionParameter, importedObjects) {
-  switch (actionParameter.type) {
-    case "objectSet": {
-      const objectType = actionParameter.objectTypeApiName;
-      importedObjects.add(objectType);
-      return `ObjectSet<${objectType}>`;
-    }
-    case "object": {
-      const objectType = actionParameter.objectTypeApiName;
-      importedObjects.add(objectType);
-      return `${objectType} | ${objectType}["__primaryKey"]`;
-    }
-    case "array":
-      return `Array<${getTypeScriptTypeFromDataType(actionParameter.subType, importedObjects)}>`;
-    case "string":
-      return `string`;
-    case "boolean":
-      return `boolean`;
-    case "attachment":
-      return `Attachment`;
-    case "date":
-      return `LocalDate`;
-    case "double":
-    case "integer":
-    case "long":
-      return `number`;
-    case "timestamp":
-      return `Timestamp`;
-    case "marking":
-      return "string";
-    default:
-      throw new Error(`Unsupported action parameter type: ${actionParameter}`);
-  }
-}
-
-// src/v1.1/backcompat/util/reexportConsts.ts
-function reexportConsts(typesToExport) {
-  return `
-          import  { ${typesToExport.map((q) => `${q} as OG_${q}`).join(", ")}} from "@osdk/legacy-client";
-      
-          ${typesToExport.map((q) => `
-      /** @deprecated submodule imports aren't public api **/
-              export const ${q} = OG_${q};
-          `).join("\n\n")}
-      `;
-}
-
-// src/v1.1/backcompat/internal-foundry-oauth-dist/generateConfidentialClientDir.ts
-async function generateConfidentialClientDir(fs2, oauthDistDir, importExt = "") {
-  const confidentialClientDistDir = path16__namespace.default.join(oauthDistDir, "ConfidentialClient");
-  await fs2.mkdir(confidentialClientDistDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.default.join(confidentialClientDistDir, "index.ts"), await formatTs(`
-    export * from "./ConfidentialClientAuth${importExt}";
-  `));
-  await fs2.writeFile(path16__namespace.default.join(confidentialClientDistDir, "ConfidentialClientAuth.ts"), await formatTs(`
-        ${reexportConsts(["ConfidentialClientAuth"])}
-    `));
-}
-async function generatePublicClientDir(fs2, oauthDistDir, importExt = "") {
-  const publicClientDistDir = path16__namespace.default.join(oauthDistDir, "PublicClient");
-  await fs2.mkdir(publicClientDistDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.default.join(publicClientDistDir, "index.ts"), await formatTs(`
-    export * from "./PublicClientAuth${importExt}";
-  `));
-  await fs2.writeFile(path16__namespace.default.join(publicClientDistDir, "PublicClientAuth.ts"), await formatTs(`
-        ${reexportConsts(["PublicClientAuth"])}
-    `));
-}
-async function generateUserTokenDir(fs2, oauthDistDir, importExt = "") {
-  const userTokenDistDir = path16__namespace.default.join(oauthDistDir, "UserToken");
-  await fs2.mkdir(userTokenDistDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.default.join(userTokenDistDir, "index.ts"), await formatTs(`
-    export * from "./UserTokenAuth${importExt}";
-  `));
-  await fs2.writeFile(path16__namespace.default.join(userTokenDistDir, "UserTokenAuth.ts"), await formatTs(`
-        ${reexportConsts(["UserTokenAuth"])}
-    `));
-}
-
-// src/v1.1/backcompat/util/reexportTypes.ts
-function reexportTypes(typesToExport, genericArgsLeft = "", genericArgsRight = cleanup(genericArgsLeft)) {
-  return `
-    import type { ${typesToExport.map((q) => `${q} as OG_${q}`).join(", ")}} from "@osdk/legacy-client";
-    
-        ${typesToExport.map((q) => `
-      /** @deprecated submodule imports aren't public api **/
-      export type ${q}${genericArgsLeft} = OG_${q}${genericArgsRight};
-    `).join("\n\n")}
-    `;
-}
-var captureInBracketsRegex = /<(.*?)>/;
-var captureGenericParamNameRegex = /^\s?(.+?)( extends .*?)?( = .*?)?\s?$/;
-function cleanup(s) {
-  if (s.length === 0) return "";
-  const genericParameterNames = captureInBracketsRegex.exec(s)?.[1]?.split(",")?.map((a) => {
-    return captureGenericParamNameRegex.exec(a)?.[1] ?? a;
-  });
-  return `<${genericParameterNames?.join(",")}>`;
-}
-
-// src/v1.1/backcompat/generateOAuthDistDir.ts
-async function generateOAuthClientDistDir(outDir, fs2, importExt = "") {
-  const oauthDistDir = path16__namespace.join(outDir, "internal", "@foundry", "oauth-client", "dist");
-  await fs2.mkdir(oauthDistDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.join(oauthDistDir, "index.ts"), await formatTs(`
-    export * from "./Auth${importExt}";
-    export * from "./ConfidentialClient/index${importExt}";
-    export * from "./OAuthClient${importExt}";
-    export * from "./PublicClient/index${importExt}";
-    export * from "./Token${importExt}";
-    export * from "./UserToken/index${importExt}";
-`));
-  await fs2.writeFile(path16__namespace.join(oauthDistDir, "Auth.ts"), await formatTs(reexportTypes(["Auth"])));
-  await fs2.writeFile(path16__namespace.join(oauthDistDir, "Token.ts"), await formatTs(reexportTypes(["Token", "TokenValue"])));
-  await fs2.writeFile(path16__namespace.join(oauthDistDir, "OAuthClient.ts"), await formatTs(reexportTypes(["AuthSubscription", "UnsubscribeFunction", "SignInResponse", "RefreshResponse", "SignOutResponse"])));
-  await fs2.writeFile(path16__namespace.join(oauthDistDir, "OAuthToken.ts"), await formatTs(reexportConsts(["OAuthToken"])));
-  await fs2.writeFile(path16__namespace.join(oauthDistDir, "Auth.ts"), await formatTs(reexportTypes(["Auth"])));
-  await generateConfidentialClientDir(fs2, oauthDistDir, importExt);
-  await generatePublicClientDir(fs2, oauthDistDir, importExt);
-  await generateUserTokenDir(fs2, oauthDistDir, importExt);
-}
-async function generateAggregationsAggregations(fs2, aggregationsDir) {
-  await fs2.writeFile(path16__namespace.join(aggregationsDir, "Aggregations.ts"), await formatTs(`
-      import { LocalDate, Timestamp } from "@osdk/legacy-client";
-      ` + reexportTypes(["Double", "Rangeable", "MetricValue", "Date", "BucketKey", "BucketValue", "TimeUnit", "BucketGroup", "Metrics", "AggregatableProperties", "AggregationClause"]) + reexportTypes(["Range"], "<T extends Rangeable>", "<T>") + reexportTypes(["BaseGroupBy"], "<_T extends BucketValue = BucketValue>") + reexportTypes(["Duration"], "<_T extends Timestamp | LocalDate = Timestamp | LocalDate>") + reexportTypes(["AggregatableProperty", "MultipleAggregationsOperations"], "<_T extends MetricValue = MetricValue>") + reexportTypes(["AggregationGroup"], "<TMetrics extends Metrics | MetricValue, TBucketGroup extends BucketGroup>") + reexportTypes(["Bucketing"], "<_T extends string , _X extends BucketValue>") + reexportTypes(["AggregationResult"], "<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue>") + reexportTypes(["BaseBucketing"], "<TBucketKey extends BucketKey, TBucketValue extends BucketValue, Kind extends string>") + reexportTypes(["ExactValueBucketing", "InternalBucketing"], `<TBucketKey extends BucketKey, TBucketValue extends BucketValue>`) + reexportTypes(["RangeBucketing", "FixedWidthBucketing"], `<TBucketKey extends BucketKey, TBucketValue extends Range<Rangeable>>`) + reexportTypes(["DurationBucketing"], `<TBucketKey extends BucketKey, TBucketValue extends Date>`) + reexportTypes(["InternalBucketingVisitor"], "<TBucketKey extends BucketKey, T extends BucketValue, R>") + reexportTypes(["AggregationBuilderResult"], "<T, TMultipleAggregationProperties>") + reexportTypes(["AggregatablePropertiesForResult", "AggregatablePropertyNamesForResult"], "<TAggregatableProperties, TResult extends MetricValue>") + reexportConsts(["assertBucketingInternal", "visitInternalBucketing"]) + reexportTypes(["AggregatableObjectSetStep"], "<TAggregatableProperties, TMultipleAggregationProperties, TBucketableProperties, TBucketGroup extends BucketGroup = {}>") + reexportTypes(["GroupedTerminalAggregationOperations"], "<TAggregatableProperties, TMultipleAggregationProperties, TBucketGroup extends BucketGroup = {}>")));
-}
-async function generateGroupBy(fs2, aggregationsDir, importExt = "") {
-  await fs2.mkdir(path16__namespace.join(aggregationsDir, "groupBy"), {
-    recursive: true
-  });
-  const groupBys = ["BooleanGroupBy", "LocalDateGroupBy", "NumericGroupBy", "StringGroupBy", "TimestampGroupBy"];
-  const reexportFiles = [...groupBys, "GroupKeyType"];
-  for (const key of reexportFiles) {
-    await fs2.writeFile(path16__namespace.join(aggregationsDir, "groupBy", `${key}.ts`), await formatTs(`export {${key}} from "./index${importExt}";`));
-  }
-  await fs2.writeFile(path16__namespace.join(aggregationsDir, "groupBy", "index.ts"), await formatTs(`import { Bucketing, BucketKey, Duration, Range, Rangeable } from "../Aggregations${importExt}";` + reexportConsts(groupBys) + reexportTypes(groupBys, "<T extends BucketKey>") + `export {GroupKeyType} from "@osdk/legacy-client";
-          `));
-}
-async function generateMetrics(fs2, aggregationsDir, importExt = "") {
-  const metricsDir = path16__namespace.join(aggregationsDir, "metrics");
-  await fs2.mkdir(metricsDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.join(metricsDir, "metrics.ts"), await formatTs(`export {MetricValueType} from "@osdk/legacy-client";`));
-  await fs2.writeFile(path16__namespace.join(metricsDir, "ApproximateDistinctCountAggregatableProperty.ts"), await formatTs(reexportConsts(["ApproximateDistinctCountAggregatableProperty"]) + reexportTypes(["ApproximateDistinctCountAggregatableProperty"])));
-  await fs2.writeFile(path16__namespace.join(metricsDir, "MultipleAggregatableProperty.ts"), await formatTs(`
-        import { Double, MetricValue, MultipleAggregationsOperations } from "../Aggregations${importExt}";
-        import { MetricValueType } from "./metrics/index${importExt}";
-      ` + reexportConsts(["MultipleAggregatableProperty"]) + reexportTypes(["MultipleAggregatableProperty"], "<TResult extends MetricValue = Double>")));
-  for (const typeName of ["DefaultAggregatableProperty", "LocalDatePropertyMetric", "NumericPropertyMetric", "TimestampPropertyMetric"]) {
-    await fs2.writeFile(path16__namespace.join(metricsDir, `${typeName}.ts`), await formatTs(`
-          import { MultipleAggregatableProperty } from "./MultipleAggregatableProperty${importExt}";
-        ` + reexportConsts([typeName])));
-  }
-  await fs2.writeFile(path16__namespace.join(metricsDir, "index.ts"), await formatTs(`
-      export * from "./ApproximateDistinctCountAggregatableProperty${importExt}";
-      export * from "./DefaultAggregatableProperty${importExt}";
-      export * from "./LocalDatePropertyMetric${importExt}";
-      export * from "./metrics${importExt}";
-      export * from "./MultipleAggregatableProperty${importExt}";
-      export * from "./NumericPropertyMetric${importExt}";
-      export * from "./TimestampPropertyMetric${importExt}";
-      `));
-}
-
-// src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateAggregationsDir.ts
-async function generateAggregationsDir(fs2, runtimeDistDir, importExt = "") {
-  const aggregationsDir = path16__namespace.join(runtimeDistDir, "aggregations");
-  await fs2.mkdir(aggregationsDir, {
-    recursive: true
-  });
-  await generateGroupBy(fs2, aggregationsDir, importExt);
-  await generateAggregationsAggregations(fs2, aggregationsDir);
-  await generateMetrics(fs2, aggregationsDir, importExt);
-  await fs2.writeFile(path16__namespace.join(aggregationsDir, "index.ts"), await formatTs(`
-    ${""}
-    ${""}
-    
-    export * from "./Aggregations${importExt}";
-    export * from "./ComputeStep${importExt}";
-    export * from "./CountOperation${importExt}";
-    export * from "./groupBy/index${importExt}";
-    export * from "./internalAggregationRequest${importExt}";
-    export * from "./metrics/index${importExt}";
-  `));
-  await fs2.writeFile(path16__namespace.join(aggregationsDir, "ComputeStep.ts"), await formatTs(`
-      import { ObjectSetDefinition } from "../baseTypes/index${importExt}";
-      import { FoundryClientOptions } from "../client/${importExt}";
-      import { AggregateObjectsError, OntologyMetadata, Result } from "../ontologyProvider/index${importExt}";
-      import { AggregationClause, AggregationResult, BucketGroup, BucketValue, InternalBucketing, Metrics, MetricValue } from "./Aggregations${importExt}";
-      ` + reexportConsts(["ComputeStep"]) + reexportTypes(["ComputeStep"], "<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue> ") + reexportTypes(["AggregationComputeStep"], "<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue>") + `
-    
-    `));
-  await fs2.writeFile(path16__namespace.join(aggregationsDir, "CountOperation.ts"), await formatTs(`` + reexportConsts(["CountOperation", "isCountOperation"]) + reexportTypes(["CountOperation"])));
-  await fs2.writeFile(path16__namespace.join(aggregationsDir, "internalAggregationRequest.ts"), await formatTs(reexportTypes(["InternalAggregationRequest"])));
-}
-async function generateAttachmentsDir(attachmentsDir, fs2, importExt = "") {
-  await fs2.mkdir(attachmentsDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.default.join(attachmentsDir, "index.ts"), await formatTs(`export * from "./Attachment${importExt}";
-       export * from "./Attachments${importExt}";
-    `));
-  await fs2.writeFile(path16__namespace.default.join(attachmentsDir, "Attachment.ts"), await formatTs(reexportTypes(["Attachment", "AttachmentMetadata"])));
-  await fs2.writeFile(path16__namespace.default.join(attachmentsDir, "Attachments.ts"), await formatTs(reexportTypes(["Attachments"])));
-}
-async function generateGeoshapesDir(runtimeDistDir, fs2, importExt = "") {
-  await fs2.mkdir(runtimeDistDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "index.ts"), await formatTs(`export * from "./Distance${importExt}";
-       export * from "./GeoJson${importExt}";
-       export * from "./GeometryCollection${importExt}";
-       export * from "./GeoPoint${importExt}";
-       export * from "./GeoShape${importExt}";
-       export * from "./LineString${importExt}";
-       export * from "./MultiGeoPoint${importExt}";
-       export * from "./MultiLineString${importExt}";
-       export * from "./MultiPolygon${importExt}";
-       export * from "./Polygon${importExt}";`));
-  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "Distance.ts"), await formatTs(`` + reexportConsts(["Distance", "DistanceUnit"]) + reexportTypes(["Distance", "DistanceUnit"])));
-  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "GeoJson.ts"), await formatTs(reexportTypes(["GeoJsonPoint", "GeoJsonPolygon", "GeoJsonLineString", "GeoJsonMultiPoint", "GeoJsonMultiPolygon", "GeoJsonMultiLineString", "GeoJsonGeometryCollection", "GeoJsonGeometry", "GeoJson"])));
-  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "GeometryCollection.ts"), await formatTs(reexportConsts(["GeometryCollection"])));
-  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "GeoPoint.ts"), await formatTs(`` + reexportConsts(["isGeoPoint", "GeoPoint", "mapCoordinatesToGeoPoint"]) + reexportTypes(["GeoHash", "Coordinates", "GeoPoint"])));
-  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "GeoShape.ts"), await formatTs(reexportConsts(["GeoShape"]) + reexportTypes(["GeoShape"])));
-  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "LineString.ts"), await formatTs(reexportConsts(["LineString"]) + reexportTypes(["LineString"])));
-  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "MultiGeoPoint.ts"), await formatTs(reexportConsts(["MultiGeoPoint"]) + reexportTypes(["MultiGeoPoint"])));
-  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "MultiLineString.ts"), await formatTs(reexportConsts(["MultiLineString"]) + reexportTypes(["MultiLineString"])));
-  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "MultiPolygon.ts"), await formatTs(reexportConsts(["MultiPolygon"]) + reexportTypes(["MultiPolygon"])));
-  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "Polygon.ts"), await formatTs(reexportConsts(["Polygon"]) + reexportTypes(["LinearRing", "Polygon"])));
-}
-async function generateObjectSetDir(objectSetDir, fs2, importExt = "") {
-  await fs2.mkdir(objectSetDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.default.join(objectSetDir, "index.ts"), await formatTs(`
-    export * from "./ObjectSetDefinition${importExt}";
-    export * from "./OntologyObjectSet${importExt}";
-    `));
-  await fs2.writeFile(path16__namespace.default.join(objectSetDir, "ObjectSetDefinition.ts"), await formatTs(reexportTypes(["BaseObjectSetDefinition", "ReferenceObjectSetDefinition", "StaticObjectSetDefinition", "IntersectObjectSetDefinition", "SubtractObjectSetDefinition", "SearchAroundObjectSetDefinition", "FilterObjectSetDefinition", "ObjectSetDefinition"])));
-  await fs2.writeFile(path16__namespace.default.join(objectSetDir, "OntologyObjectSet.ts"), await formatTs(reexportTypes(["OntologyObjectSet"])));
-}
-async function generateSharedObjectCodeDir(sharedObjectCodeDir, fs2, importExt = "") {
-  await fs2.mkdir(sharedObjectCodeDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.default.join(sharedObjectCodeDir, "index.ts"), await formatTs(`
-    export * from "./FilteredPropertiesTerminalOperations${importExt}";
-    `));
-  await fs2.writeFile(path16__namespace.default.join(sharedObjectCodeDir, "FilteredPropertiesTerminalOperations.ts"), await formatTs(`import { OntologyObject } from "../OntologyObject${importExt}` + reexportTypes(["FilteredPropertiesTerminalOperations", "FilteredPropertiesTerminalOperationsWithGet"], "<T extends OntologyObject, V extends Array<keyof T>>")));
-}
-async function generateTimeSeriesDir(timeseriesDir, fs2, importExt = "") {
-  await fs2.mkdir(timeseriesDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.join(timeseriesDir, "index.ts"), await formatTs(`
-    export * from "./TimeSeries${importExt}";
-    export * from "./TimeSeriesDuration${importExt}";
-    export * from "./TimeSeriesPoint${importExt}";
-    ${""}
-    export * from "./TimeSeriesQuery${importExt}";
-    export * from "./TimeSeriesTerminalOperations${importExt}";
-  `));
-  await fs2.writeFile(path16__namespace.join(timeseriesDir, "TimeSeries.ts"), await formatTs(reexportTypes(["TimeSeries"], `<T extends number | string>`)));
-  await fs2.writeFile(path16__namespace.join(timeseriesDir, "TimeSeriesDuration.ts"), await formatTs(reexportTypes([`WhenUnit`, `DurationUnit`, `TimeSeriesDuration`])));
-  await fs2.writeFile(path16__namespace.join(timeseriesDir, "TimeSeriesPoint.ts"), await formatTs(reexportTypes(["TimeSeriesPoint"], `<T extends number | string>`)));
-  await fs2.writeFile(path16__namespace.join(timeseriesDir, "TimeSeriesQuery.ts"), await formatTs(reexportTypes(["TimeSeriesQuery"], `<T extends number | string>`)));
-  await fs2.writeFile(path16__namespace.join(timeseriesDir, "TimeSeriesTerminalOperations.ts"), await formatTs(reexportTypes(["TimeSeriesTerminalOperations", "TimeSeriesIterator"], `<T extends number | string>`)));
-}
-
-// src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateBaseTypesDir.ts
-async function generateBaseTypesDir(runtimeDistDir, fs2, importExt = "") {
-  const baseTypesDir = path16__namespace.join(runtimeDistDir, "baseTypes");
-  await fs2.mkdir(baseTypesDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.join(baseTypesDir, "index.ts"), await formatTs(`export * from "./ActionType${importExt}";
-      export * from "./attachments/index${importExt}";
-      export * from "./geoshapes/index${importExt}";
-      export * from "./links${importExt}";
-      export * from "./localDate${importExt}";
-      export * from "./objectset/index${importExt}";
-      export * from "./ObjectType${importExt}";
-      export * from "./OntologyObject${importExt}";
-      export * from "./Queries${importExt}";
-      export * from "./timeseries/index${importExt}";
-      export * from "./timestamp${importExt}";`));
-  const geoshapesDir = path16__namespace.join(baseTypesDir, "geoshapes");
-  await generateGeoshapesDir(geoshapesDir, fs2, importExt);
-  const timeseriesDir = path16__namespace.join(baseTypesDir, "timeseries");
-  await generateTimeSeriesDir(timeseriesDir, fs2, importExt);
-  const attachmentsDir = path16__namespace.join(baseTypesDir, "attachments");
-  await generateAttachmentsDir(attachmentsDir, fs2, importExt);
-  const objectSetDir = path16__namespace.join(baseTypesDir, "objectset");
-  await generateObjectSetDir(objectSetDir, fs2, importExt);
-  const sharedObjectCodeDir = path16__namespace.join(baseTypesDir, "sharedObjectCode");
-  await generateSharedObjectCodeDir(sharedObjectCodeDir, fs2, importExt);
-  await fs2.writeFile(path16__namespace.join(baseTypesDir, "ActionType.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject${importExt}";
-      ` + reexportConsts(["ActionExecutionMode", "ReturnEditsMode", "ActionValidationResult"]) + reexportTypes(["ActionExecutionOptions", "ValidationResponse", "BulkEdits"]) + reexportTypes(["CreatedObjectEdits", "ModifiedObjectEdits"], "<T extends OntologyObject>") + reexportTypes(["Edits"], "<TAddedObjects extends OntologyObject | void, TModifiedObjects extends OntologyObject | void>") + reexportTypes(["ActionResponse"], "<TEdits extends Edits<any, any> | undefined = undefined>", "<TEdits>") + reexportTypes(["ActionResponseFromOptions"], "<TOptions extends ActionExecutionOptions | undefined = undefined, TEdits extends Edits<any, any> | undefined = undefined>", "<TOptions, TEdits>")));
-  await fs2.writeFile(path16__namespace.join(baseTypesDir, "OntologyObject.ts"), await formatTs(reexportTypes(["OntologyObject"]) + reexportConsts(["isOntologyObject"])));
-  await fs2.writeFile(path16__namespace.join(baseTypesDir, "links.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject${importExt}` + reexportTypes(["SingleLink", "MultiLink"], "<T extends OntologyObject = OntologyObject>")));
-  await fs2.writeFile(path16__namespace.join(baseTypesDir, "localDate.ts"), await formatTs(reexportConsts(["LocalDate"]) + reexportTypes(["LocalDate"])));
-  await fs2.writeFile(path16__namespace.join(baseTypesDir, "timestamp.ts"), await formatTs(reexportConsts(["Timestamp"]) + reexportTypes(["Timestamp"])));
-  await fs2.writeFile(path16__namespace.join(baseTypesDir, "Queries.ts"), await formatTs(`import { BucketValue, Range, Rangeable } from "../aggregations/index${importExt}";
-      ` + reexportTypes(["QueryResponse"], "<T>") + reexportTypes(["BaseBucket"], "<K, V>") + reexportTypes(["NestedBucket"], "<TGroupKey, TSegmentKey, TValue extends BucketValue>") + reexportTypes(["TwoDimensionalAggregation"], "<TGroupKey extends QueryBucketKey, TValue extends BucketValue = number>") + reexportTypes(["ThreeDimensionalAggregation"], "<TGroupKey extends QueryBucketKey, TSegmentKey extends QueryBucketKey, TValue extends BucketValue = number>") + reexportTypes(["QueryBucketKey"])));
-  await fs2.writeFile(path16__namespace.join(baseTypesDir, "ObjectType.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject${importExt}";` + reexportTypes(["BaseType", "StringType", "IntegerType", "DateType", "BooleanType", "ByteType", "DecimalType", "FloatType", "TimestampType", "ShortType", "LongType", "DoubleType", "GeoPointType", "GeoShapeType", "AttachmentType", "ObjectType", "StructField", "QueryBucketRangeableType", "QueryBucketKeyType", "QueryBucketValueType", "AllValueTypes", "OntologyType", "ObjectTypeProperties", "StructType"]) + reexportTypes(["TimeSeriesType", "ArrayType", "SetType"], "<T extends BaseType>") + reexportTypes(["Property"], "<TType extends OntologyType = OntologyType>") + reexportTypes(["BaseObjectType"], "<TOntologyObject extends OntologyObject = OntologyObject>") + reexportTypes(["ObjectSetType"], "<T extends ObjectType>") + reexportTypes(["RangeType"], "<T extends QueryBucketRangeableType>") + reexportTypes(["TwoDimensionalAggregationType"], "<TGroupKey extends QueryBucketKeyType, TValue extends QueryBucketValueType>") + reexportTypes(["ThreeDimensionalAggregationType"], "<TGroupKey extends QueryBucketKeyType, TSegmentKey extends QueryBucketKeyType, TValue extends QueryBucketValueType>")));
-}
-async function generateClientDir(runtimeDistDir, fs2, importExt = "") {
-  const pagingDir = path16__namespace.default.join(runtimeDistDir, "client");
-  await fs2.mkdir(pagingDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.default.join(pagingDir, "index.ts"), await formatTs(`export * from "./clientOptions${importExt}";`));
-  await fs2.writeFile(path16__namespace.default.join(pagingDir, "clientOptions.ts"), await formatTs(`import {Auth} from "@osdk/legacy-client";` + reexportTypes(["FoundryClientOptions"], "<TAuth extends Auth = Auth>")));
-}
-async function generateFiltersDir(runtimeDistDir, fs2, importExt = "") {
-  const pagingDir = path16__namespace.default.join(runtimeDistDir, "filters");
-  await fs2.mkdir(pagingDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.default.join(pagingDir, "index.ts"), await formatTs(`export * from "./ArrayFilter${importExt}";
-      export * from "./AttachmentFilter${importExt}";
-      export * from "./BooleanFilter${importExt}";
-      export * from "./DateTimeFilters${importExt}";
-      export * from "./Filters${importExt}";
-      export * from "./GeoPointFilter${importExt}";
-      export * from "./GeoShapeFilter${importExt}";
-      export * from "./NumericFilter${importExt}";
-      export * from "./Op${importExt}";
-      export * from "./OrderByOption${importExt}";
-      export * from "./StringFilter${importExt}";`));
-  await fs2.writeFile(path16__namespace.default.join(pagingDir, "ArrayFilter.ts"), await formatTs(`import { Attachment, GeoPoint, GeoShape, LocalDate, Timestamp } from "../baseTypes/index${importExt}";` + reexportConsts(["ArrayFilter"]) + reexportTypes(["ArrayFilter"], "<T extends string | number | Timestamp | LocalDate | boolean | GeoShape | GeoPoint | Attachment>")));
-  await fs2.writeFile(path16__namespace.default.join(pagingDir, "AttachmentFilter.ts"), await formatTs(reexportConsts(["AttachmentFilter"]) + reexportTypes(["AttachmentFilter"])));
-  await fs2.writeFile(path16__namespace.default.join(pagingDir, "BooleanFilter.ts"), await formatTs(reexportConsts(["BooleanFilter"]) + reexportTypes(["BooleanFilter"])));
-  await fs2.writeFile(path16__namespace.default.join(pagingDir, "GeoPointFilter.ts"), await formatTs(reexportConsts(["GeoPointFilter"]) + reexportTypes(["GeoPointFilter", "BoundingBox"])));
-  await fs2.writeFile(path16__namespace.default.join(pagingDir, "DateTimeFilters.ts"), await formatTs(reexportConsts(["TimestampFilter", "LocalDateFilter"]) + reexportTypes(["TimestampFilter", "LocalDateFilter"])));
-  await fs2.writeFile(path16__namespace.default.join(pagingDir, "GeoShapeFilter.ts"), await formatTs(reexportConsts(["GeoShapeFilter"]) + reexportTypes(["GeoShapeFilter"])));
-  await fs2.writeFile(path16__namespace.default.join(pagingDir, "NumericFilter.ts"), await formatTs(reexportConsts(["NumericFilter"]) + reexportTypes(["NumericFilter"])));
-  await fs2.writeFile(path16__namespace.default.join(pagingDir, "Op.ts"), await formatTs(reexportConsts(["Op"])));
-  await fs2.writeFile(path16__namespace.default.join(pagingDir, "OrderByOption.ts"), await formatTs(reexportConsts(["OrderByOption"]) + reexportTypes(["OrderByOption"])));
-  await fs2.writeFile(path16__namespace.default.join(pagingDir, "StringFilter.ts"), await formatTs(reexportConsts(["StringFilter"]) + reexportTypes(["StringFilter"])));
-  await fs2.writeFile(path16__namespace.default.join(pagingDir, "Filters.ts"), await formatTs(`import { OntologyObject } from "@osdk/legacy-client";` + reexportTypes(["ObjectTypeFilterFunction", "ObjectTypeOrderByFunction"], "<T extends OntologyObject>") + reexportTypes(["BoundingBoxFilter", "DistanceOf", "SearchClause", "LtWhereClause", "GtWhereClause", "LteWhereClause", "GteWhereClause", "EqWhereClause", "IsNullWhereClause", "ContainsWhereClause", "StartsWithWhereClause", "ContainsAllTermsInOrderWhereClause", "ContainsAnyTermWhereClause", "ContainsAllTermsWhereClause", "WithinDistanceOfWhereClause", "WithinBoundingBoxWhereClause", "IntersectsBoundingBoxWhereClause", "DoesNotIntersectBoundingBoxWhereClause", "WithinPolygonWhereClause", "IntersectsPolygonWhereClause", "DoesNotIntersectPolygonWhereClause", "AndWhereClause", "OrWhereClause", "NotWhereClause", "WhereClause", "OrderByClause"]) + reexportTypes(["FilterType"], "<T extends string | number>")));
-}
-async function generateErrors(fs2, ontologyProviderDir) {
-  await fs2.writeFile(path16__namespace.join(ontologyProviderDir, "Errors.ts"), await formatTs(reexportTypes(["PermissionDenied", "Unauthorized", "InvalidAggregationRangeValue", "MalformedPropertyFilters", "PropertiesNotFilterable", "ParametersNotFound", "ApplyActionFailed", "PropertyTypesSearchNotSupported", "InvalidParameterValue", "QueryTimeExceededLimit", "CompositePrimaryKeyNotSupported", "PropertyBaseTypeNotSupported", "PropertiesNotSearchable", "AttachmentNotFound", "ObjectTypeNotFound", "InvalidGroupId", "OntologySyncing", "ActionNotFound", "ParameterObjectSetRidNotFound", "LinkTypeNotFound", "InvalidRangeQuery", "ActionParameterObjectNotFound", "InvalidPropertyValue", "PropertiesNotSortable", "FunctionExecutionTimedOut", "InvalidFields", "ActionTypeNotFound", "ObjectTypeNotSynced", "OntologyEditsExceededLimit", "AggregationGroupCountExceededLimit", "InvalidContentType", "PropertiesNotFound", "FunctionInvalidInput", "InvalidSortOrder", "QueryDepthExceededLimit", "InvalidPropertyFiltersCombination", "ObjectsExceededLimit", "DuplicateOrderBy", "FunctionEncounteredUserFacingError", "InvalidUserId", "QueryNotFound", "InvalidAggregationRange", "ParameterObjectNotFound", "QueryMemoryExceededLimit", "InvalidContentLength", "OntologyNotFound", "ActionParameterObjectTypeNotFound", "UnknownParameter", "InvalidSortType", "PropertyFiltersNotSupported", "ActionValidationFailed", "MultipleGroupByOnFieldNotSupported", "LinkedObjectNotFound", "ActionEditedPropertiesNotFound", "InvalidPropertyFilterValue", "QueryEncounteredUserFacingError", "AttachmentSizeExceededLimit", "ObjectNotFound", "PropertyApiNameNotFound", "ParameterTypeNotSupported", "InvalidAggregationRangePropertyType", "MissingParameter"])));
-}
-async function generateOntologyMetadata(fs2, ontologyProviderDir) {
-  await fs2.writeFile(path16__namespace.join(ontologyProviderDir, "OntologyMetadata.ts"), await formatTs(reexportTypes(["OntologyMetadata"])));
-}
-async function generateResult(fs2, ontologyProviderDir) {
-  await fs2.writeFile(path16__namespace.join(ontologyProviderDir, "Result.ts"), await formatTs(`import {FoundryApiError} from "@osdk/legacy-client";
-        ` + reexportTypes(["Ok", "Err"], "<T>") + reexportTypes(["Result"], "<V, E = FoundryApiError>", "<V,E>") + reexportConsts(["isOk", "isErr", "visitError"]) + reexportTypes(["ErrorVisitor"], "<E extends FoundryApiError, R>", "<E,R>") + reexportTypes(["ExtractKeysWithType"], "<T, K extends keyof T>", "<T,K>")));
-}
-
-// src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateOntologyProviderDir.ts
-async function generateOntologyProviderDir(fs2, runtimeDistDir, importExt = "") {
-  const ontologyProviderDir = path16__namespace.join(runtimeDistDir, "ontologyProvider");
-  await fs2.mkdir(ontologyProviderDir, {
-    recursive: true
-  });
-  await generateErrors(fs2, ontologyProviderDir);
-  await generateOntologyMetadata(fs2, ontologyProviderDir);
-  await generateResult(fs2, ontologyProviderDir);
-  await fs2.writeFile(path16__namespace.join(ontologyProviderDir, "index.ts"), await formatTs(`
-    ${""}
-      export * from "./Errors${importExt}";
-      export * from "./OntologyMetadata${importExt}";
-      ${""}
-    ${""}
-      // export * from "./Result${importExt}";
-  `));
-}
-async function generatePagingDir(runtimeDistDir, fs2, importExt = "") {
-  const pagingDir = path16__namespace.join(runtimeDistDir, "paging");
-  await fs2.mkdir(pagingDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.join(pagingDir, "index.ts"), await formatTs(`export * from "./Page${importExt}";`));
-  await fs2.writeFile(path16__namespace.join(pagingDir, "Page.ts"), await formatTs(reexportTypes(["Page"], "<T>")));
-}
-
-// src/v1.1/backcompat/generateOntologyRuntimeDistDir.ts
-async function generateOntologyRuntimeDistDir(outDir, fs2, importExt = "") {
-  const runtimeDistDir = path16__namespace.join(outDir, "internal", "@foundry", "ontology-runtime", "dist");
-  await fs2.mkdir(runtimeDistDir, {
-    recursive: true
-  });
-  await generateOntologyProviderDir(fs2, runtimeDistDir, importExt);
-  await generateAggregationsDir(fs2, runtimeDistDir, importExt);
-  await generatePagingDir(runtimeDistDir, fs2, importExt);
-  await generateBaseTypesDir(runtimeDistDir, fs2, importExt);
-  await generateClientDir(runtimeDistDir, fs2, importExt);
-  await generateFiltersDir(runtimeDistDir, fs2, importExt);
-  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "index.ts"), 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__namespace.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__namespace.default.join(outDir, "BulkActions.ts"), await formatTs(`
-    import type { ObjectSet, LocalDate, Timestamp, Attachment, Edits, ActionExecutionOptions, BulkActionExecutionOptions, ActionError, Result, ActionResponseFromOptions, BulkActionResponseFromOptions } from "@osdk/legacy-client";
-    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
-    export interface BulkActions {
-    ${actionSignatures.join("\n")}
-    }
-  `));
-}
-async function generateFoundryClientFile(fs2, outDir, importExt = "") {
-  await fs2.writeFile(path16__namespace.default.join(outDir, "FoundryClient.ts"), await formatTs(`
-    import { BaseFoundryClient } from "@osdk/legacy-client";
-    import type { Auth, FoundryClientOptions } from "@osdk/legacy-client";
-    import { Ontology } from "./Ontology${importExt}";
-
-    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__namespace.join(outDir, "index.ts"), await formatTs(`
-    export * from "@osdk/legacy-client";
-    export type { Ontology } from "./Ontology${importExt}";
-    export { FoundryClient } from "./FoundryClient${importExt}";
-    `));
-}
-
-// src/util/commaSeparatedIdentifiers.ts
-function commaSeparatedIdentifiers(identifiers, alternateNames) {
-  return identifiers.map((i) => {
-    const alt = alternateNames?.get(i);
-    if (alt) {
-      return `${i}: ${alt}`;
-    }
-    return i;
-  }).join(",");
-}
-
-// src/util/commaSeparatedTypeIdentifiers.ts
-function commaSeparatedTypeIdentifiers(identifiers, altNames) {
-  return identifiers.map((i) => `${i}: typeof ${altNames?.get(i) ?? i}`).join(",");
-}
-
-// src/v1.1/generateMetadataFile.ts
-async function generateMetadataFile(ontology, userAgent, 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__namespace.default.join(outDir, "Ontology.ts"), await formatTs(`
-  import type { OntologyDefinition } from "@osdk/api";
-  import type { Ontology as ClientOntology } from "@osdk/legacy-client";
-  import type { Objects } from "./ontology/objects/Objects${importExt}";
-  import type { Actions } from "./ontology/actions/Actions${importExt}";
-  import type { Queries } from "./ontology/queries/Queries${importExt}";
-  import type { 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__namespace.default.join(outDir, "Objects.ts"), await formatTs(`
-    import { BaseObjectSet } from "@osdk/legacy-client";
-    ${Array.from(Object.keys(ontology.objectTypes)).map((importedObject) => `import type { ${importedObject} } from "./${importedObject}${importExt}";`).join("\n")}
-    
-    export interface Objects {
-      ${Object.keys(ontology.objectTypes).map((apiName) => `${apiName} : BaseObjectSet<${apiName}>;`).join("\n")}
-    }
-    ;`));
-}
-async function generateObjectsInterfaceSupportFiles(ontology, fs2, outDir, importExt = "") {
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  for (const {
-    objectType: {
-      apiName
-    }
-  } of Object.values(ontology.objectTypes)) {
-    const fileName = path16.join(outDir, `${apiName}.ts`);
-    const localApiName = `OG_${apiName}`;
-    const contents = [];
-    contents.push(`import { ObjectSetAggregateArg, ObjectSetFilterArg, ObjectSetGroupByArg, ObjectSetMultipleAggregateArg, ObjectSetOrderByArg } from "@osdk/legacy-client";`);
-    contents.push(`import { ${apiName} as ${localApiName} } from "../${apiName}${importExt}";`);
-    contents.push("");
-    contents.push(`/** @deprecated Use ${apiName} from ontology/objects instead */`, `export type ${apiName} = ${localApiName};`);
-    contents.push(`/** @deprecated Use ObjectSetFilterArg<${apiName}> instead */`, `export type ${apiName}Filter = ObjectSetFilterArg<${localApiName}>;`);
-    contents.push(`/** @deprecated Use ObjectSetOrderByArg<${apiName}> instead */`, `export type ${apiName}OrderBy = ObjectSetOrderByArg<${localApiName}>;`);
-    contents.push(`/** @deprecated Use ObjectSetGroupByArg<${apiName}> instead */`, `export type ${apiName}GroupByProperties = ObjectSetGroupByArg<${localApiName}>;`);
-    contents.push(`
-      /**
-        * Aggregation properties for ${apiName}
-        * @deprecated Use ObjectSetAggregateArg<${apiName}> instead
-        */`, `export type ${apiName}AggregationProperties = ObjectSetAggregateArg<${localApiName}>;`);
-    contents.push(`
-      /**
-        * Multiple aggregation properties for ${apiName}.
-        * @deprecated Use ObjectSetMultipleAggregateArg<${apiName}> instead
-        */`, `export type ${apiName}MultipleAggregationProperties = ObjectSetMultipleAggregateArg<${localApiName}>;`);
-    await fs2.writeFile(fileName, contents.join("\n"));
-  }
-}
-async function generateOntologyIndexFile(fs2, outDir) {
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.join(outDir, "index.ts"), await formatTs(`
-        export type { ObjectSet } from "@osdk/legacy-client";
-    `));
-}
-
-// src/shared/getObjectImports.ts
-function getObjectImports(objects, curApiName, currentFilePath, v2) {
-  return Array.from(objects).filter((obj) => obj.fullApiName !== curApiName).map((obj) => {
-    return `import type { ${obj.getDefinitionIdentifier(v2)} as ${obj.getImportedDefinitionIdentifier(v2)} } from "${obj.getImportPathRelTo("./" + currentFilePath)}";`;
-  }).join("\n");
-}
-
-// src/shared/wireActionTypeV2ToSdkActionDefinition.ts
-function wireActionTypeV2ToSdkActionDefinition(input) {
-  const modifiedEntityTypes = getModifiedEntityTypes(input);
-  return {
-    type: "action",
-    apiName: input.apiName,
-    parameters: Object.fromEntries(Object.entries(input.parameters).map(([key, value]) => [key, wireActionParameterV2ToSdkParameterDefinition(value)])),
-    displayName: input.displayName,
-    description: input.description,
-    modifiedEntities: createModifiedEntities(modifiedEntityTypes.addedObjects, modifiedEntityTypes.modifiedObjects)
-  };
-}
-function wireActionParameterV2ToSdkParameterDefinition(value) {
-  return {
-    multiplicity: value.dataType.type === "array",
-    type: actionPropertyToSdkPropertyDefinition(value.dataType.type === "array" ? value.dataType.subType : value.dataType),
-    nullable: !value.required,
-    description: value.description
-  };
-}
-function actionPropertyToSdkPropertyDefinition(parameterType) {
-  switch (parameterType.type) {
-    case "string":
-    case "boolean":
-    case "attachment":
-    case "double":
-    case "integer":
-    case "long":
-    case "timestamp":
-    case "marking":
-      return parameterType.type;
-    case "date":
-      return "datetime";
-    case "objectSet":
-      return {
-        type: "objectSet",
-        objectSet: parameterType.objectTypeApiName
-      };
-    case "object":
-      return {
-        type: "object",
-        object: parameterType.objectTypeApiName
-      };
-    case "array":
-      return actionPropertyToSdkPropertyDefinition(parameterType.subType);
-  }
-}
-function createModifiedEntities(addedObjects, modifiedObjects) {
-  let entities = {};
-  for (const key of addedObjects) {
-    entities[key] = {
-      created: true,
-      modified: false
-    };
-  }
-  for (const key of modifiedObjects) {
-    if (entities[key]) {
-      entities[key].modified = true;
-    } else {
-      entities[key] = {
-        created: false,
-        modified: true
-      };
-    }
-  }
-  return entities;
-}
-
-// src/util/stringUnionFrom.ts
-function stringUnionFrom2(values) {
-  if (values.length === 0) {
-    return "never";
-  } else {
-    return values.map((v) => `"${v}"`).join("|");
-  }
-}
-
-// src/v1.1/generatePerActionDataFilesV1.ts
-async function generatePerActionDataFilesV1({
-  sanitizedOntology: ontology,
-  fs: fs2,
-  outDir: rootOutDir,
-  importExt = "",
-  ontology: enhancedOntology
-}) {
-  const outDir = path16__namespace.default.join(rootOutDir, "ontology", "actions");
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await Promise.all(Object.values(enhancedOntology.actionTypes).map(async (action) => {
-    const currentFilePath = `${path16__namespace.default.join("ontology", "actions", `${action.shortApiName}.ts`)}`;
-    const uniqueApiNamesArray = extractReferencedObjectsFromAction(action.og);
-    const uniqueApiNames = new Set(uniqueApiNamesArray);
-    const uniqueApiNamesString = stringUnionFrom2([...uniqueApiNames]);
-    const fullActionDef = deleteUndefineds(wireActionTypeV2ToSdkActionDefinition(action.og));
-    function createV1Object() {
-      return `  export const ${action.shortApiName} = ${JSON.stringify(fullActionDef, null, 2)} satisfies ActionDefinition<"${action.shortApiName}", ${uniqueApiNamesString}>;`;
-    }
-    const referencedObjectDefs = /* @__PURE__ */ new Set();
-    for (const p of Object.values(action.parameters)) {
-      if (p.dataType.type === "object" || p.dataType.type === "objectSet") {
-        if (p.dataType.objectApiName) {
-          referencedObjectDefs.add(enhancedOntology.requireObjectType(p.dataType.objectApiName));
-        }
-        if (p.dataType.objectTypeApiName) {
-          referencedObjectDefs.add(enhancedOntology.requireObjectType(p.dataType.objectTypeApiName));
-        }
-      }
-      if (p.dataType.type === "array" && (p.dataType.subType.type === "object" || p.dataType.subType.type === "objectSet")) {
-        if (p.dataType.subType.objectApiName) {
-          referencedObjectDefs.add(enhancedOntology.requireObjectType(p.dataType.subType.objectApiName));
-        }
-        if (p.dataType.subType.objectTypeApiName) {
-          referencedObjectDefs.add(enhancedOntology.requireObjectType(p.dataType.subType.objectTypeApiName));
-        }
-      }
-    }
-    const imports = getObjectImports(referencedObjectDefs, void 0, currentFilePath, false);
-    await fs2.writeFile(path16__namespace.default.join(rootOutDir, currentFilePath), await formatTs(`
-          import type { ActionDefinition, ObjectActionDataType, ObjectSetActionDataType, VersionBound} from "@osdk/api";
-          import type { ApplyActionOptions, ApplyBatchActionOptions, ActionReturnTypeForOptions, ActionParam } from '@osdk/client.api';
-          import { $osdkMetadata} from "../../OntologyMetadata${importExt}";
-          import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
-          ${imports}
-
-          ${createV1Object()}
-        `));
-  }));
-  const indexFileRelPath = path16__namespace.default.join("ontology", "actions", `index.ts`);
-  await fs2.writeFile(path16__namespace.default.join(rootOutDir, indexFileRelPath), await formatTs(`
-      ${Object.values(enhancedOntology.actionTypes).map((action) => {
-    const exportConstLine = `export {${action.shortApiName} } from "${action.getImportPathRelTo(indexFileRelPath)}";`;
-    `export type { ${action.paramsIdentifier} } from "${action.getImportPathRelTo(indexFileRelPath)}";`;
-    return exportConstLine;
-  }).join("\n")}
-    ${Object.keys(ontology.actionTypes).length === 0 ? "export {};" : ""}
-      `));
-}
-function extractReferencedObjectsFromAction(actionType) {
-  const referencedObjectsInParameters = Object.values(actionType.parameters).flatMap(({
-    dataType
-  }) => {
-    const objectTypeReference = extractReferencedObjectsFromActionParameter(dataType);
-    return objectTypeReference ? [objectTypeReference] : [];
-  });
-  const referenceObjectsInEdits = actionType.operations.flatMap((value) => {
-    switch (value.type) {
-      case "createObject":
-        return [value.objectTypeApiName];
-      case "modifyObject":
-        return [value.objectTypeApiName];
-      case "deleteObject":
-      case "createLink":
-      case "deleteLink":
-        return [];
-    }
-  });
-  return [...referenceObjectsInEdits, ...referencedObjectsInParameters];
-}
-function extractReferencedObjectsFromActionParameter(actionParameter) {
-  switch (actionParameter.type) {
-    case "objectSet":
-    case "object":
-      return actionParameter.objectTypeApiName;
-    case "array":
-      return extractReferencedObjectsFromActionParameter(actionParameter.subType);
-    case "string":
-    case "boolean":
-    case "attachment":
-    case "date":
-    case "double":
-    case "integer":
-    case "long":
-    case "timestamp":
-      return void 0;
-  }
-}
-
-// src/util/stringify.ts
-var defaultCustomizer = (value, defaultValueFormatter, key, defaultKeyFormatter) => {
-  return [defaultKeyFormatter(key), defaultValueFormatter(value)];
-};
-function stringify(obj, customizer = {}, separator = ",\n") {
-  const defaultKeyFormatter = (key) => `${JSON.stringify(key)}`;
-  const entries = [];
-  const sortedKeys = Object.keys(obj).sort((a, b) => a.localeCompare(b));
-  for (const key of sortedKeys) {
-    const value = obj[key];
-    const res = (customizer[key] ?? customizer["*"] ?? defaultCustomizer)(value, (value2) => JSON.stringify(value2, null, 2), key, defaultKeyFormatter);
-    if (res) {
-      if (typeof res === "string") {
-        entries.push(`${defaultKeyFormatter(key)}: ${res}`);
-      } else {
-        entries.push(`${res[0]}: ${res[1]}`);
-      }
-    }
-  }
-  return entries.join(separator);
-}
-
-// src/v1.1/wireObjectTypeV2ToSdkObjectConstV1.ts
-function wireObjectTypeV2ToSdkObjectConstV1(wireObject, {
-  ontology
-}, currentFilePath) {
-  const object = ontology.requireObjectType(wireObject.objectType.apiName, true);
-  const uniqueLinkTargetTypes = new Set(wireObject.linkTypes.map((a) => ontology.requireObjectType(a.objectTypeApiName, false)));
-  const definition = deleteUndefineds(generatorConverters.wireObjectTypeFullMetadataToSdkObjectTypeDefinition(object.og, false));
-  const objectDefIdentifier = object.getDefinitionIdentifier(false);
-  function getV1Types() {
-    return `
-      export interface ${objectDefIdentifier} extends ObjectTypeDefinition<"${object.fullApiName}", ${object.uniqueImportName}> {
-        ${stringify(definition, {
-      osdkMetadata: () => void 0,
-      // not used in v1
-      links: (_value) => `{
-          ${stringify(definition.links, {
-        "*": (definition2) => `ObjectTypeLinkDefinition<${ontology.requireObjectType(definition2.targetType).getImportedDefinitionIdentifier(false)}, ${definition2.multiplicity}>`
-      })}
-        }`
-    })}
-      }
-    `;
-  }
-  const imports = getObjectImports(uniqueLinkTargetTypes, definition.apiName, currentFilePath, false);
-  return `${imports}${getV1Types()}
-
-    export const ${object.shortApiName}: ${objectDefIdentifier} = {
-      ${stringify(definition, {
-    osdkMetadata: (value) => void 0
-  })}
-    
-    };`;
-}
-
-// src/util/reservedKeywords.ts
-var reservedKeywords = /* @__PURE__ */ new Set(["break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do", "else", "enum", "export", "extends", "false", "finally", "for", "function", "if", "import", "in", "instanceof", "new", "null", "return", "super", "switch", "this", "throw", "true", "try", "typeof", "var", "void", "while", "with", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"]);
-function isReservedKeyword(name) {
-  return reservedKeywords.has(name);
-}
-
-// src/v1.1/wireObjectTypeV2ToV1ObjectInterfaceString.ts
-function wireObjectTypeV2ToObjectInterfaceStringV1(objectTypeWithLinks, importExt = "") {
-  const uniqueLinkTargets = new Set(objectTypeWithLinks.linkTypes.map((a) => a.objectTypeApiName).filter((a) => a !== objectTypeWithLinks.objectType.apiName));
-  return `import type { OntologyObject, LocalDate, Timestamp, GeoShape, GeoPoint, Attachment, TimeSeries, MultiLink, SingleLink, StringLong } from "@osdk/legacy-client";
-${Array.from(uniqueLinkTargets).map((linkTarget) => `import type { ${linkTarget} } from "./${linkTarget}${importExt}";`).join("\n")}
-
-  ${getDescriptionIfPresent(objectTypeWithLinks.objectType.description)}
-  export interface ${objectTypeWithLinks.objectType.apiName} extends OntologyObject {
-  /** @deprecated please migrate to $apiName instead */
-  readonly __apiName: "${objectTypeWithLinks.objectType.apiName}" & {${objectTypeWithLinks.linkTypes.map((linkType) => {
-    return `/** @deprecated please migrate to pivotTo(${linkType.apiName}) instead */ searchAround${linkType.apiName.charAt(0).toUpperCase() + linkType.apiName.slice(1)}?: never`;
-  })}};
-  /** @deprecated please migrate to $primaryKey instead */
-  readonly __primaryKey: ${wirePropertyTypeV2ToTypeScriptType(objectTypeWithLinks.objectType.properties[objectTypeWithLinks.objectType.primaryKey].dataType)};
-  readonly $apiName: "${objectTypeWithLinks.objectType.apiName}";
-  readonly $primaryKey: ${wirePropertyTypeV2ToTypeScriptType(objectTypeWithLinks.objectType.properties[objectTypeWithLinks.objectType.primaryKey].dataType)};
-${Object.entries(objectTypeWithLinks.objectType.properties).sort((a, b) => a[0].localeCompare(b[0])).flatMap(([propertyName, propertyDefinition]) => {
-    const propertyType = wirePropertyTypeV2ToTypeScriptType(propertyDefinition.dataType);
-    const entries = [`${getDescriptionIfPresent(propertyDefinition.description, true)}readonly ${propertyName}: ${propertyType} | undefined`];
-    if (isReservedKeyword(propertyName)) {
-      entries.push(`/** @deprecated please migrate to '${propertyName}' instead */
-          readonly ${propertyName}_: ${propertyType} | undefined`);
-    }
-    return entries;
-  }).join(";\n")}
-${objectTypeWithLinks.linkTypes.flatMap((linkType) => {
-    const entries = [`readonly ${linkType.apiName}: ${linkType.cardinality === "MANY" ? "MultiLink" : "SingleLink"}<${linkType.objectTypeApiName}>`];
-    return entries;
-  }).join(";\n")}
-}
-  `;
-}
-function wirePropertyTypeV2ToTypeScriptType(property) {
-  switch (property.type) {
-    case "string":
-      return "string";
-    case "boolean":
-      return "boolean";
-    case "array":
-      return wirePropertyTypeV2ToTypeScriptType(property.subType) + "[]";
-    case "integer":
-      return "number";
-    case "attachment":
-      return "Attachment";
-    case "byte":
-      return "number";
-    case "date":
-      return "LocalDate";
-    case "decimal":
-      return "string";
-    case "double":
-      return "number";
-    case "float":
-      return "number";
-    case "geopoint":
-      return "GeoPoint";
-    case "geoshape":
-      return "GeoShape";
-    case "long":
-      return "StringLong";
-    case "short":
-      return "number";
-    case "timestamp":
-      return "Timestamp";
-    case "timeseries":
-      return property.itemType.type === "string" ? `TimeSeries<string>` : `TimeSeries<number>`;
-    case "marking":
-      return "string";
-    default:
-      throw new Error(`Unknown property type ${property}`);
-  }
-}
-function getDescriptionIfPresent(description, includeNewline) {
-  if (description) {
-    return `/**
- * ${description}
- */${includeNewline ? "\n" : ""}`;
-  }
-  return "";
-}
-
-// src/v1.1/generatePerObjectInterfaceAndDataFiles.ts
-async function generatePerObjectInterfaceAndDataFiles(ontology, fs2, outDir, importExt = "") {
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await Promise.all(Object.values(ontology.og.objectTypes).map(async (object) => {
-    const relPath = path16__namespace.default.join(".", "ontology", `objects`, `${object.objectType.apiName}.ts`);
-    await fs2.writeFile(path16__namespace.default.join(outDir, `${object.objectType.apiName}.ts`), await formatTs(`
-        import type { ObjectTypeDefinition, ObjectTypeLinkDefinition, PropertyDef } from "@osdk/api";
-        ${wireObjectTypeV2ToObjectInterfaceStringV1(object, importExt)}
-
-        ${wireObjectTypeV2ToSdkObjectConstV1(object, {
-      ontology
-    }, relPath)}
-        `));
-  }));
-  await fs2.writeFile(path16__namespace.default.join(outDir, "index.ts"), await formatTs(`
-    ${Object.keys(ontology.og.objectTypes).map((apiName) => `export * from "./${apiName}${importExt}";`).join("\n")}
-      export type { ObjectSet } from "@osdk/legacy-client";
-
-    `));
-}
-
-// src/shared/getObjectTypesFromQueryDataType.ts
-function getObjectTypesFromQueryDataType(dataType, types) {
-  switch (dataType.type) {
-    case "array":
-    case "set":
-      getObjectTypesFromQueryDataType(dataType.subType, types);
-      return;
-    case "object":
-      types.add(dataType.objectTypeApiName);
-      return;
-    case "objectSet":
-      types.add(dataType.objectTypeApiName);
-      return;
-    case "struct":
-      for (const prop of Object.values(dataType.fields)) {
-        getObjectTypesFromQueryDataType(prop.fieldType, types);
-      }
-      return;
-    case "union":
-      for (const type of dataType.unionTypes) {
-        getObjectTypesFromQueryDataType(type, types);
-      }
-      return;
-    case "attachment":
-    case "boolean":
-    case "date":
-    case "double":
-    case "float":
-    case "integer":
-    case "long":
-    case "null":
-    case "string":
-    case "threeDimensionalAggregation":
-    case "timestamp":
-    case "twoDimensionalAggregation":
-    case "unsupported":
-      return;
-    default:
-      throw new Error(`Cannot find object types from unsupported QueryDataType ${dataType.type}`);
-  }
-}
-
-// src/shared/getObjectTypeApiNamesFromQuery.ts
-function getObjectTypeApiNamesFromQuery(query) {
-  const types = /* @__PURE__ */ new Set();
-  for (const {
-    dataType
-  } of Object.values(query.parameters)) {
-    getObjectTypesFromQueryDataType(dataType, types);
-  }
-  getObjectTypesFromQueryDataType(query.output, types);
-  return Array.from(types);
-}
-
-// src/shared/isNullableQueryDataType.ts
-function isNullableQueryDataType(input) {
-  if (input.type === "null") {
-    return true;
-  }
-  if (input.type === "union") {
-    return input.unionTypes.some((t) => isNullableQueryDataType(t));
-  }
-  return false;
-}
-
-// src/shared/wireQueryDataTypeToQueryDataTypeDefinition.ts
-function wireQueryDataTypeToQueryDataTypeDefinition(input) {
-  switch (input.type) {
-    case "double":
-    case "float":
-    case "integer":
-    case "long":
-    case "attachment":
-    case "boolean":
-    case "date":
-    case "string":
-    case "timestamp":
-      return {
-        type: input.type,
-        nullable: false
-      };
-    case "object":
-      return {
-        type: "object",
-        object: input.objectTypeApiName,
-        nullable: false
-      };
-    case "objectSet":
-      return {
-        type: "objectSet",
-        objectSet: input.objectTypeApiName,
-        nullable: false
-      };
-    case "array":
-      return {
-        ...wireQueryDataTypeToQueryDataTypeDefinition(input.subType),
-        multiplicity: true
-      };
-    case "set":
-      return {
-        type: "set",
-        set: wireQueryDataTypeToQueryDataTypeDefinition(input.subType),
-        nullable: false
-      };
-    case "union":
-      const allowNulls = isNullableQueryDataType(input);
-      if (allowNulls && input.unionTypes.length === 2) {
-        const nonNull = input.unionTypes.find((t) => t.type != null);
-        if (nonNull) {
-          return {
-            ...wireQueryDataTypeToQueryDataTypeDefinition(nonNull),
-            nullable: true
-          };
-        }
-      }
-      return {
-        type: "union",
-        union: input.unionTypes.reduce((acc, t) => {
-          if (t.type === "null") {
-            return acc;
-          }
-          acc.push(wireQueryDataTypeToQueryDataTypeDefinition(t));
-          return acc;
-        }, []),
-        nullable: allowNulls
-      };
-    case "struct":
-      return {
-        type: "struct",
-        struct: Object.fromEntries(input.fields.map((f) => [f.name, wireQueryDataTypeToQueryDataTypeDefinition(f.fieldType)])),
-        nullable: false
-      };
-    case "twoDimensionalAggregation":
-      return {
-        type: "twoDimensionalAggregation",
-        twoDimensionalAggregation: get2DQueryAggregationProps(input),
-        nullable: false
-      };
-    case "threeDimensionalAggregation":
-      return {
-        type: "threeDimensionalAggregation",
-        threeDimensionalAggregation: get3DQueryAggregationProps(input),
-        nullable: false
-      };
-    case "null":
-    case "unsupported":
-      throw new Error(`Accidentally tried to handle QueryDataType.type ${input.type}`);
-    default:
-      throw new Error(`Unsupported QueryDataType.type ${input.type}`);
-  }
-}
-function get2DQueryAggregationProps(input) {
-  if (input.keyType.type === "range") {
-    return {
-      keyType: input.keyType.type,
-      keySubtype: input.keyType.subType.type,
-      valueType: input.valueType.type
-    };
-  } else {
-    if (guardInvalidKeyTypes(input.keyType)) {
-      return {
-        keyType: input.keyType.type,
-        valueType: input.valueType.type
-      };
-    }
-    throw new Error(`Cannot create 2D aggregation with ${input.keyType.type} as its type`);
-  }
-}
-function get3DQueryAggregationProps(input) {
-  if (input.keyType.type === "range") {
-    return {
-      keyType: input.keyType.type,
-      keySubtype: input.keyType.subType.type,
-      valueType: get2DQueryAggregationProps(input.valueType)
-    };
-  } else {
-    if (guardInvalidKeyTypes(input.keyType)) {
-      return {
-        keyType: input.keyType.type,
-        valueType: get2DQueryAggregationProps(input.valueType)
-      };
-    }
-    throw new Error(`Cannot create 3D aggregation with ${input.keyType.type} as its type`);
-  }
-}
-function guardInvalidKeyTypes(key) {
-  return key.type === "string" || key.type === "boolean";
-}
-
-// src/shared/wireQueryTypeV2ToSdkQueryDefinition.ts
-function wireQueryTypeV2ToSdkQueryDefinition(input) {
-  return {
-    type: "query",
-    apiName: input.apiName,
-    description: input.description,
-    displayName: input.displayName,
-    version: input.version,
-    parameters: Object.fromEntries(Object.entries(input.parameters).map(([name, parameter]) => [name, wireQueryParameterV2ToQueryParameterDefinition(parameter)])),
-    output: wireQueryDataTypeToQueryDataTypeDefinition(input.output)
-  };
-}
-function wireQueryTypeV2ToSdkQueryDefinitionNoParams(input) {
-  return {
-    type: "query",
-    apiName: input.apiName,
-    description: input.description,
-    displayName: input.displayName,
-    version: input.version
-  };
-}
-function wireQueryParameterV2ToQueryParameterDefinition(parameter) {
-  return {
-    description: parameter.description,
-    ...wireQueryDataTypeToQueryDataTypeDefinition(parameter.dataType)
-  };
-}
-
-// src/v1.1/generatePerQueryDataFiles.ts
-async function generatePerQueryDataFiles({
-  fs: fs2,
-  outDir: rootOutDir,
-  ontology
-}, v2) {
-  const relOutDir = path16__namespace.default.join(".", "ontology", "queries");
-  const outDir = path16__namespace.default.join(rootOutDir, "ontology", "queries");
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await Promise.all(Object.values(ontology.queryTypes).map(async (query) => {
-    await generateV1QueryFile(fs2, outDir, query);
-  }));
-  await fs2.writeFile(path16__namespace.default.join(outDir, "index.ts"), await formatTs(`
-  ${Object.values(ontology.queryTypes).map((query) => `export * from "${query.getImportPathRelTo(path16__namespace.default.join(relOutDir, "index.ts"))}";`).join("\n")}
-    ${Object.keys(ontology.queryTypes).length === 0 ? "export {};" : ""}
-  `));
-}
-async function generateV1QueryFile(fs2, outDir, query) {
-  const objectTypes = getObjectTypeApiNamesFromQuery(query);
-  await fs2.writeFile(path16__namespace.default.join(outDir, `${query.shortApiName}.ts`), await formatTs(`
-      import { QueryDefinition } from "@osdk/api";
-
-      export const ${query.shortApiName} = ${JSON.stringify(wireQueryTypeV2ToSdkQueryDefinition(query.og))} ${getQueryDefSatisfies(query.fullApiName, objectTypes)}`));
-}
-function getQueryDefSatisfies(apiName, objectTypes) {
-  return `satisfies QueryDefinition<"${apiName}", ${objectTypes.length > 0 ? objectTypes.map((apiNameObj) => `"${apiNameObj}"`).join("|") : "never"}>;`;
-}
-async function generateQueries(ontology, fs2, outDir, importExt = "") {
-  const importedObjects = /* @__PURE__ */ new Set();
-  const signatures = [];
-  for (const query of Object.values(ontology.queryTypes)) {
-    const jsDocBlock = ["/**"];
-    if (query.description) {
-      jsDocBlock.push(`* ${query.description}`);
-    }
-    const outputType = handleQueryDataType(query.output, importedObjects, true);
-    const paramEntries = [];
-    for (const [name, parameter] of Object.entries(query.parameters)) {
-      const nullable = isNullableQueryDataType(parameter.dataType);
-      const type = handleQueryDataType(parameter.dataType, importedObjects, false);
-      paramEntries.push(`"${name}"${nullable ? "?" : ""}: ${type}`);
-      jsDocBlock.push(`* @param {${sanitizeDocTypeName(type)}} params.${name}${parameter.description ? ` - ${parameter.description}` : ""}`);
-    }
-    const param = paramEntries.length === 0 ? "" : `params: { ${paramEntries.join("; ")} }`;
-    jsDocBlock.push(`* @returns ${sanitizeDocTypeName(outputType)}`, "*/");
-    signatures.push(`
-      ${jsDocBlock.join("\n")}
-      ${query.apiName}(${param}): Promise<Result<QueryResponse<${outputType}>, QueryError>>;
-      `);
-  }
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await fs2.writeFile(path16__namespace.default.join(outDir, "Queries.ts"), await formatTs(`
-    import type { QueryResponse, QueryError, Result, Timestamp, LocalDate, Range, Attachment, ObjectSet, TwoDimensionalAggregation, ThreeDimensionalAggregation  } from "@osdk/legacy-client";
-    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
-
-    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__namespace.join(outDir, "ontology", "objects");
-  const actionsDir = path16__namespace.join(outDir, "ontology", "actions");
-  const queriesDir = path16__namespace.join(outDir, "ontology", "queries");
-  await verifyOutDir(outDir, fs2);
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  const sanitizedOntology = sanitizeMetadata(ontology);
-  const enhancedOntology = enhanceOntology(sanitizedOntology, void 0, /* @__PURE__ */ new Map(), importExt);
-  await generateFoundryClientFile(fs2, outDir, importExt);
-  await generateMetadataFile(sanitizedOntology, userAgent, fs2, outDir, importExt);
-  await generateOntologyIndexFile(fs2, path16__namespace.join(outDir, "ontology"));
-  await generateObjectsInterfaceFile(sanitizedOntology, fs2, objectsDir, importExt);
-  await generateObjectsInterfaceSupportFiles(sanitizedOntology, fs2, path16__namespace.join(objectsDir, "objects-api"), importExt);
-  await generatePerObjectInterfaceAndDataFiles(enhancedOntology, fs2, objectsDir, importExt);
-  const common = {
-    sanitizedOntology,
-    fs: fs2,
-    outDir,
-    ontology: enhancedOntology
-  };
-  await generateActions(sanitizedOntology, fs2, actionsDir, importExt);
-  await generateBatchActions(sanitizedOntology, fs2, actionsDir, importExt);
-  await generateBulkActions(sanitizedOntology, fs2, actionsDir, importExt);
-  await generatePerActionDataFilesV1(common);
-  await generateQueries(sanitizedOntology, fs2, queriesDir, importExt);
-  await generatePerQueryDataFiles(common);
-  await generateIndexFile(fs2, outDir, importExt);
-  await generateBackCompatDeprecatedExports(fs2, outDir, importExt);
-}
-var ExpectedOsdkVersion = "0.22.0";
-async function generateOntologyMetadataFile({
-  fs: fs2,
-  outDir,
-  ontology,
-  ontologyApiNamespace
-}, userAgent) {
-  fs2.writeFile(path16__namespace.default.join(outDir, "OntologyMetadata.ts"), await formatTs(`
-      export type $ExpectedClientVersion = "${ExpectedOsdkVersion}";
-      export const $osdkMetadata = { extraUserAgent: "${userAgent}" };
-      ${ontologyApiNamespace == null ? `
-        export const $ontologyRid = "${ontology.ontology.rid}";
-        ` : ""}
-      `));
-}
-
-// src/shared/propertyJsdoc.ts
-function propertyJsdoc(property, {
-  isInherited,
-  apiName
-}) {
-  let ret = `/**
-`;
-  const renderDisplayName = property.displayName && property.displayName !== apiName;
-  if (isInherited || renderDisplayName || property.description) {
-    if (isInherited) {
-      ret += ` * (inherited from parent)
-`;
-    }
-    if (renderDisplayName) {
-      ret += ` *   display name: '${property.displayName}'${property.description ? "," : ""}
-`;
-    }
-    if (property.description) {
-      ret += ` *   description: ${property.description}
-`;
-    }
-  } else {
-    ret += ` * (no ontology metadata)
-`;
-  }
-  ret += ` */
-`;
-  return ret;
-}
-
-// src/v2.0/wireObjectTypeV2ToSdkObjectConstV2.ts
-function getObjectDefIdentifier(name, v2) {
-  return v2 ? name : `${name}Def`;
-}
-function wireObjectTypeV2ToSdkObjectConstV2(wireObject, {
-  ontology
-}, currentFilePath) {
-  const object = ontology.requireObjectType(wireObject.objectType.apiName, true);
-  const uniqueLinkTargetTypes = new Set(wireObject.linkTypes.map((a) => ontology.requireObjectType(a.objectTypeApiName, false)));
-  const definition = deleteUndefineds(generatorConverters.wireObjectTypeFullMetadataToSdkObjectTypeDefinition(object.og, true));
-  const objectDefIdentifier = object.getDefinitionIdentifier(true);
-  const objectSetIdentifier = `${object.shortApiName}.ObjectSet`;
-  const propertyKeysIdentifier = `${object.shortApiName}.PropertyKeys`;
-  const osdkObjectPropsIdentifier = `${object.shortApiName}.Props`;
-  const osdkObjectStrictPropsIdentifier = `${object.shortApiName}.StrictProps`;
-  const osdkObjectLinksIdentifier = `${object.shortApiName}.Links`;
-  const osdkObjectIdentifier = `${object.shortApiName}.OsdkObject`;
-  const identifiers = {
-    objectDefIdentifier: `${object.shortApiName}.Definition`,
-    osdkObjectLinksIdentifier,
-    osdkObjectPropsIdentifier,
-    osdkObjectStrictPropsIdentifier,
-    objectSetIdentifier,
-    osdkObjectIdentifier,
-    propertyKeysIdentifier
-  };
-  function getV2Types() {
-    return `import type {
-      AggregateOpts as $AggregateOpts,
-      AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy as $AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy,
-      AggregationsResults as $AggregationsResults, 
-      Augments as $Augments,
-      ConvertProps as $ConvertProps,
-      DefaultToFalse as $DefaultToFalse,
-      FetchPageArgs as $FetchPageArgs,
-      FetchPageResult as $FetchPageResult,
-      IsAny as $IsAny,
-      LinkedType as $LinkedType,
-      LinkNames as $LinkNames,
-      NullabilityAdherence as $NullabilityAdherence,
-      NullabilityAdherenceDefault as $NullabilityAdherenceDefault,
-      ObjectSet as $ObjectSet, 
-      Osdk as $Osdk,
-      OsdkObject as $OsdkObject,
-      OsdkObjectLinksEntry as $OsdkObjectLinksEntry,
-      OsdkObjectLinksObject as $OsdkObjectLinksObject,
-      OsdkObjectPropertyType as $OsdkObjectPropertyType,
-      PageResult as $PageResult,
-      PropertyValueClientToWire as $PropertyValueClientToWire,
-      PropertyValueWireToClient as $PropType,
-      Result as $Result,
-      SelectArg as $SelectArg, 
-      SingleLinkAccessor  as $SingleLinkAccessor,
-      SingleLinkAccessor as $SingleLinkAccessor
-      SingleOsdkResult as $SingleOsdkResult,
-      ValidToFrom as $ValidToFrom,
-      WhereClause as $WhereClause,
-    } from "@osdk/client.api";
-    import type * as $clientApi from "@osdk/client.api";
-    import type {
-      ObjectOrInterfacePropertyKeysFrom2 as $ObjectOrInterfacePropertyKeysFrom2,  
-      ObjectTypeDefinition as $ObjectTypeDefinition,
-      ObjectTypeLinkDefinition as $ObjectTypeLinkDefinition,
-    } from "@osdk/api";
-
-    export namespace ${object.shortApiName} {
-
-      ${createPropertyKeys(object)}
-
-
-      ${createLinks(ontology, object, "Links")}
-
-      ${createProps(object, "Props", false)}
-      ${createProps(object, "StrictProps", true)}
-
-      ${createObjectSet(object, identifiers)}
-
-      ${createDefinition(object, ontology, "Definition", identifiers)}
-      ${createOsdkObject(object, "OsdkObject", identifiers)}
-    }    
-
-
-
-
-  
-  export type ${objectDefIdentifier} = ${object.shortApiName}.Definition;
-
-
-    `;
-  }
-  const imports = getObjectImports(uniqueLinkTargetTypes, definition.apiName, currentFilePath, true);
-  return `${imports}${getV2Types()}
-
-    export const ${object.shortApiName}: ${objectDefIdentifier}  & $VersionBound<$ExpectedClientVersion>
-    = {
-      osdkMetadata: $osdkMetadata,
-      objectSet: undefined as any,
-      props: undefined as any,
-      linksType: undefined as any,
-      strictProps: undefined as any,
-      ${stringify(definition, {
-    osdkMetadata: (value) => void 0
-  })}
-    
-    };`;
-}
-function createOsdkObject(object, identifier, {
-  osdkObjectPropsIdentifier,
-  objectDefIdentifier,
-  osdkObjectStrictPropsIdentifier,
-  osdkObjectLinksIdentifier
-}) {
-  const definition = object.getCleanedUpDefinition(true);
-  return `
-  export type ${identifier}<
-      OPTIONS extends never | "$notStrict" | "$rid" = never,
-      K extends keyof ${osdkObjectPropsIdentifier}= keyof ${osdkObjectPropsIdentifier},
-
-  > 
-    = $Osdk<
-        ${objectDefIdentifier}, 
-        K | OPTIONS
-      > & Pick<
-       [OPTIONS] extends [never]
-        ? ${osdkObjectStrictPropsIdentifier} :
-        OPTIONS extends "$notStrict" ? ${osdkObjectPropsIdentifier} : ${osdkObjectStrictPropsIdentifier}
-        , K
-> & {
-    readonly $link: ${osdkObjectLinksIdentifier};
-    readonly $title: string | undefined; // FIXME
-    readonly $primaryKey: ${"primaryKeyApiName" in definition ? `
-      $OsdkObjectPropertyType<${JSON.stringify(definition.properties[definition.primaryKeyApiName])},${true}>` : "string | number"}
-  ;
-    
-    readonly $as: <NEW_Q extends $ValidToFrom<${objectDefIdentifier}>>(type: NEW_Q | string) => $Osdk<
-  NEW_Q,
-  $ConvertProps<${objectDefIdentifier}, NEW_Q, K>
->;
-} & $OsdkObject<"${object.fullApiName}">;`;
-}
-function createObjectSet(object, {
-  objectDefIdentifier,
-  objectSetIdentifier,
-  propertyKeysIdentifier,
-  osdkObjectIdentifier
-}) {
-  return `
-export interface ObjectSet extends 
-$ObjectSet<${objectDefIdentifier},
-
-${objectSetIdentifier}
->
-{
-readonly aggregate: <const AO extends $AggregateOpts<${objectDefIdentifier}>>(
-  req: $AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy<${objectDefIdentifier}, AO>,
-) => Promise<$AggregationsResults<${objectDefIdentifier}, AO>>;
-
-
-readonly pivotTo: <const L extends $LinkNames<${objectDefIdentifier}>>(type: L) => $LinkedType<${objectDefIdentifier}, L>["objectSet"];
- ${object instanceof EnhancedObjectType ? ` 
-readonly fetchOne: <
-    const L extends ${propertyKeysIdentifier},
-    const R extends boolean,
-    const S extends false | "throw" = $NullabilityAdherenceDefault,
-  >(
-    primaryKey: $PropertyValueClientToWire[${objectDefIdentifier}["primaryKeyType"]],
-    options?: $SelectArg<${objectDefIdentifier}, L, R, S>,
-  ) => Promise<
-   ${osdkObjectIdentifier}<
-    (S extends false ? "$notStrict" : never) | ($DefaultToFalse<R> extends false? never:  "$rid" ),
-    $IsAny<L> extends true ? ${propertyKeysIdentifier} : L
-   >>
-  ;
-
-readonly fetchOneWithErrors: <
-    const L extends ${propertyKeysIdentifier},
-    const R extends boolean,
-    const S extends false | "throw" = $NullabilityAdherenceDefault,
-  >(
-    primaryKey: $PropertyValueClientToWire[${objectDefIdentifier}["primaryKeyType"]],
-    options?: $SelectArg<${objectDefIdentifier}, L, R, S>,
-  ) => Promise<$Result<
-        ${osdkObjectIdentifier}<
-        (S extends false ? "$notStrict" : never) | ($DefaultToFalse<R> extends false?never: "$rid"),
-        $IsAny<L> extends true ? ${propertyKeysIdentifier} : L
-      >
-   >> 
-  
-;
-
-` : ""}
-
-readonly fetchPage: <
-  const L extends ${propertyKeysIdentifier},
-  const R extends boolean,
-  const const A extends $Augments,
-  const S extends $NullabilityAdherence = $NullabilityAdherenceDefault,
->(
-  args?: $FetchPageArgs<${objectDefIdentifier}, L, R, A, S>,
-) => Promise<
-  $PageResult<${osdkObjectIdentifier}<
-    (S extends false ? "$notStrict" : never) | ($DefaultToFalse<R> extends false? never: "$rid"),
-    $IsAny<L> extends true ? ${propertyKeysIdentifier} : L
-  >>
->;
-
-readonly fetchPageWithErrors: <
-  const L extends ${propertyKeysIdentifier},
-  const R extends boolean,
-  const A extends $Augments,
-  const S extends $NullabilityAdherence = $NullabilityAdherenceDefault,
->(
-  args?: $FetchPageArgs<${objectDefIdentifier}, L, R, A, S>,
-) => Promise<$Result<
- $PageResult<${osdkObjectIdentifier}<
- (S extends false ? "$notStrict" : never) | ($DefaultToFalse<R> extends false? never : "$rid"),
- $IsAny<L> extends true ? ${propertyKeysIdentifier} : L
- >>
- >>;
-
-readonly asyncIter: () => AsyncIterableIterator<${osdkObjectIdentifier}>;
-}
-`;
-}
-function maybeStripNamespace(type, q) {
-  if (type.apiNamespace && q.startsWith(`${type.apiNamespace}.`)) {
-    return q.slice(type.apiNamespace.length + 1);
-  } else {
-    return q;
-  }
-}
-function createProps(type, identifier, strict) {
-  const definition = type.getCleanedUpDefinition(true);
-  return `export interface ${identifier} {
-${stringify(definition.properties, {
-    "*": (propertyDefinition, _, apiName) => {
-      return [`readonly "${maybeStripNamespace(type, apiName)}"${// after we convert everything over we can do this:
-      // !strict || propertyDefinition.nullable ? "?" : ""
-      ""}`, `$PropType[${JSON.stringify(propertyDefinition.type)}]${propertyDefinition.multiplicity ? "[]" : ""}${propertyDefinition.nullable || !strict ? `| undefined` : ""}`];
-    }
-  })}
-    }`;
-}
-function createDefinition(object, ontology, identifier, {
-  objectDefIdentifier,
-  objectSetIdentifier,
-  osdkObjectPropsIdentifier,
-  osdkObjectStrictPropsIdentifier,
-  osdkObjectLinksIdentifier
-}) {
-  const definition = object.getCleanedUpDefinition(true);
-  return `
-    export interface ${identifier} extends ${object instanceof EnhancedObjectType ? `$ObjectTypeDefinition` : `$InterfaceDefinition`}<"${object.fullApiName}", ${objectDefIdentifier}>, $VersionBound<$ExpectedClientVersion> {
-      osdkMetadata: typeof $osdkMetadata;
-      objectSet: ${objectSetIdentifier};
-      props: ${osdkObjectPropsIdentifier};
-      linksType: ${osdkObjectLinksIdentifier};
-      strictProps: ${osdkObjectStrictPropsIdentifier};
-      ${stringify(definition, {
-    osdkMetadata: () => void 0,
-    // we are going to reference another object instead
-    type: () => void 0,
-    apiName: () => void 0,
-    links: (_value) => `{
-        ${stringify(definition.links, {
-      "*": (definition2) => `$ObjectTypeLinkDefinition<${ontology.requireObjectType(definition2.targetType).getImportedDefinitionIdentifier(true)}, ${definition2.multiplicity}>`
-    })}
-      }`,
-    properties: (_value) => `{
-        ${stringify(definition.properties, {
-      "*": (propertyDefinition, _, apiName) => [`${propertyJsdoc(propertyDefinition, {
-        apiName
-      })}"${maybeStripNamespace(object, apiName)}"`, `$PropertyDef<"${propertyDefinition.type}", "${propertyDefinition.nullable ? "nullable" : "non-nullable"}", "${propertyDefinition.multiplicity ? "array" : "single"}">`]
-    })}
-      }`
-  })}
-}
-  `;
-}
-function createLinks(ontology, object, identifier) {
-  const definition = object.getCleanedUpDefinition(true);
-  return `
-    ${Object.keys(definition.links).length === 0 ? `export type ${identifier} = {};` : `
-        export interface ${identifier}  {
-${stringify(definition.links, {
-    "*": (definition2, _, key) => {
-      const linkTarget = ontology.requireObjectType(definition2.targetType).getImportedDefinitionIdentifier(true);
-      return [`readonly ${key}`, `${definition2.multiplicity ? `${linkTarget}.ObjectSet` : `$SingleLinkAccessor<${linkTarget}.Definition>`}
-          `];
-    }
-  })}
-    }
-    `}`;
-}
-function createPropertyKeys(type) {
-  return `export type PropertyKeys = ${Object.keys(type.getCleanedUpDefinition(true).properties).map((a) => maybeStripNamespace(type, a)).map((a) => `"${a}"`).join("|")};`;
-}
-
-// src/v2.0/generatePerActionDataFiles.ts
-async function generatePerActionDataFiles({
-  sanitizedOntology: ontology,
-  fs: fs2,
-  outDir: rootOutDir,
-  importExt = "",
-  ontology: enhancedOntology
-}) {
-  const outDir = path16__namespace.default.join(rootOutDir, "ontology", "actions");
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await Promise.all(Object.values(enhancedOntology.actionTypes).map(async (action) => {
-    const currentFilePath = `${path16__namespace.default.join("ontology", "actions", `${action.shortApiName}.ts`)}`;
-    const uniqueApiNamesArray = extractReferencedObjectsFromAction2(action.og);
-    const uniqueApiNames = new Set(uniqueApiNamesArray);
-    const uniqueApiNamesString = stringUnionFrom2([...uniqueApiNames]);
-    const fullActionDef = deleteUndefineds(wireActionTypeV2ToSdkActionDefinition(action.og));
-    const {
-      parameters,
-      ...actionDefSansParameters
-    } = fullActionDef;
-    function createParamsDef() {
-      const entries = Object.entries(parameters);
-      entries.sort((a, b) => a[0].localeCompare(b[0]));
-      if (entries.length === 0) {
-        return `// Represents the definition of the parameters for the action
-          export type ParamsDefinition = Record<string, never>;`;
-      }
-      return `// Represents the definition of the parameters for the action
-        export type ParamsDefinition = {
-          ${entries.map(([key, value]) => {
-        return `"${key}": {
-                ${stringify(value, {
-          description: (value2, d) => value2 ? d(value2) : void 0,
-          // trick to remove undefineds
-          type: (type) => {
-            if (typeof type === "string") {
-              return JSON.stringify(type);
-            } else if (type.type === "object") {
-              const obj = enhancedOntology.requireObjectType(type.object);
-              return `ObjectActionDataType<"${obj.fullApiName}", ${obj.getImportedDefinitionIdentifier(true)}.Definition>`;
-            } else if (type.type === "objectSet") {
-              return `ObjectSetActionDataType<"${type.objectSet}", ${getObjectDefIdentifier(type.objectSet, true)}.Definition>`;
-            }
-            return void 0;
-          }
-        })}
-            }`;
-      }).join(";\n")}
-        }`;
-    }
-    function getActionParamType(input) {
-      if (typeof input === "string") {
-        return `ActionParam.PrimitiveType<${JSON.stringify(input)}>`;
-      } else if (input.type === "object") {
-        return `ActionParam.ObjectType<${enhancedOntology.requireObjectType(input.object).getImportedDefinitionIdentifier(true)}.Definition>`;
-      } else if (input.type === "objectSet") {
-        return `ActionParam.ObjectSetType<${enhancedOntology.requireObjectType(input.objectSet).getImportedDefinitionIdentifier(true)}.Definition>`;
-      }
-    }
-    function createV2Types() {
-      const oldParamsIdentifier = `${action.shortApiName}$Params`;
-      return `
-        
-          export namespace ${action.shortApiName}{
-            ${createParamsDef()}
-
-            ${getDescriptionIfPresent(action.description)}
-            export interface Params {
-              ${stringify(parameters, {
-        "*": (ogValue, _, ogKey) => {
-          const key = `${getDescriptionIfPresent(ogValue.description)}
-                  readonly "${ogKey}"${ogValue.nullable ? "?" : ""}`;
-          const value = ogValue.multiplicity ? `ReadonlyArray<${getActionParamType(ogValue.type)}>` : `${getActionParamType(ogValue.type)}`;
-          return [key, value];
-        }
-      })}
-            }
-            /** @deprecated **/
-            export type Parameters = Params;
-
-
-              // Represents the definition of the action
-              export interface Definition extends ActionDefinition<"${action.shortApiName}", ${uniqueApiNamesString}, ${action.shortApiName}.Signatures>, VersionBound<$ExpectedClientVersion> {
-              ${Object.entries(actionDefSansParameters).sort((a, b) => a[0].localeCompare(b[0])).map(([key, value]) => {
-        return `${key}: ${JSON.stringify(value)};`;
-      }).join("\n")}
-              parameters: ${action.definitionParamsIdentifier};
-              osdkMetadata: typeof $osdkMetadata;
-            }
-
-            // Represents a fqn of the action
-            export interface Signatures {
-              ${getDescriptionIfPresent(action.description)}
-              applyAction<P extends ${action.paramsIdentifier}, OP extends ApplyActionOptions>(args: P, options?: OP): Promise<ActionReturnTypeForOptions<OP>>;
-           
-              batchApplyAction<P extends ReadonlyArray<${action.paramsIdentifier}>, OP extends ApplyBatchActionOptions>(args: P, options?: OP): Promise<ActionReturnTypeForOptions<OP>>;
-            }
-  
-          }
-
-          /**
-           * @deprecated Use \`${action.paramsIdentifier}\`
-           */
-          export type ${oldParamsIdentifier} = ${action.paramsIdentifier} | ReadonlyArray<${action.paramsIdentifier}>;
-
-          /** @deprecated Use \`${action.definitionIdentifier}\` **/
-          export type ${action.shortApiName} = ${action.shortApiName}.Signatures;
-          `;
-    }
-    function createV2Object() {
-      return `  export const ${action.shortApiName}: ${action.definitionIdentifier} = 
-        {
-          ${stringify(fullActionDef)},
-          osdkMetadata: $osdkMetadata
-        }
-        `;
-    }
-    const referencedObjectDefs = /* @__PURE__ */ new Set();
-    for (const p of Object.values(action.parameters)) {
-      if (p.dataType.type === "object" || p.dataType.type === "objectSet") {
-        if (p.dataType.objectApiName) {
-          referencedObjectDefs.add(enhancedOntology.requireObjectType(p.dataType.objectApiName));
-        }
-        if (p.dataType.objectTypeApiName) {
-          referencedObjectDefs.add(enhancedOntology.requireObjectType(p.dataType.objectTypeApiName));
-        }
-      }
-      if (p.dataType.type === "array" && (p.dataType.subType.type === "object" || p.dataType.subType.type === "objectSet")) {
-        if (p.dataType.subType.objectApiName) {
-          referencedObjectDefs.add(enhancedOntology.requireObjectType(p.dataType.subType.objectApiName));
-        }
-        if (p.dataType.subType.objectTypeApiName) {
-          referencedObjectDefs.add(enhancedOntology.requireObjectType(p.dataType.subType.objectTypeApiName));
-        }
-      }
-    }
-    const imports = getObjectImports(referencedObjectDefs, void 0, currentFilePath, true);
-    await fs2.writeFile(path16__namespace.default.join(rootOutDir, currentFilePath), await formatTs(`
-          import type { ActionDefinition, ObjectActionDataType, ObjectSetActionDataType, VersionBound} from "@osdk/api";
-          import type { ApplyActionOptions, ApplyBatchActionOptions, ActionReturnTypeForOptions, ActionParam } from '@osdk/client.api';
-          import { $osdkMetadata} from "../../OntologyMetadata${importExt}";
-          import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
-          ${imports}
-
-        
-          ${createV2Types()}
-
-          ${createV2Object()}
-        `));
-  }));
-  const indexFileRelPath = path16__namespace.default.join("ontology", "actions.ts");
-  await fs2.writeFile(path16__namespace.default.join(rootOutDir, indexFileRelPath), await formatTs(`
-      ${Object.values(enhancedOntology.actionTypes).map((action) => {
-    const exportConstLine = `export {${action.shortApiName} } from "${action.getImportPathRelTo(indexFileRelPath)}";`;
-    return exportConstLine;
-  }).join("\n")}
-    ${Object.keys(ontology.actionTypes).length === 0 ? "export {};" : ""}
-      `));
-}
-function extractReferencedObjectsFromAction2(actionType) {
-  const referencedObjectsInParameters = Object.values(actionType.parameters).flatMap(({
-    dataType
-  }) => {
-    const objectTypeReference = extractReferencedObjectsFromActionParameter2(dataType);
-    return objectTypeReference ? [objectTypeReference] : [];
-  });
-  const referenceObjectsInEdits = actionType.operations.flatMap((value) => {
-    switch (value.type) {
-      case "createObject":
-        return [value.objectTypeApiName];
-      case "modifyObject":
-        return [value.objectTypeApiName];
-      case "deleteObject":
-      case "createLink":
-      case "deleteLink":
-        return [];
-    }
-  });
-  return [...referenceObjectsInEdits, ...referencedObjectsInParameters];
-}
-function extractReferencedObjectsFromActionParameter2(actionParameter) {
-  switch (actionParameter.type) {
-    case "objectSet":
-    case "object":
-      return actionParameter.objectTypeApiName;
-    case "array":
-      return extractReferencedObjectsFromActionParameter2(actionParameter.subType);
-    case "string":
-    case "boolean":
-    case "attachment":
-    case "date":
-    case "double":
-    case "integer":
-    case "long":
-    case "timestamp":
-      return void 0;
-  }
-}
-async function generatePerQueryDataFilesV2({
-  fs: fs2,
-  outDir: rootOutDir,
-  ontology,
-  importExt = ""
-}, v2) {
-  const relOutDir = path16__namespace.default.join(".", "ontology", "queries");
-  const outDir = path16__namespace.default.join(rootOutDir, "ontology", "queries");
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  await Promise.all(Object.values(ontology.queryTypes).map(async (query) => {
-    await generateV2QueryFile(fs2, outDir, relOutDir, query, importExt, ontology);
-  }));
-  const indexFilePath = `${outDir}.ts`;
-  await fs2.writeFile(indexFilePath, await formatTs(`
-    ${Object.values(ontology.queryTypes).map((query) => `export * from "${query.getImportPathRelTo(relOutDir)}";`).join("\n")}
-      ${Object.keys(ontology.queryTypes).length === 0 ? "export {};" : ""}
-    `));
-}
-async function generateV2QueryFile(fs2, outDir, relOutDir, query, importExt, ontology) {
-  const relFilePath = path16__namespace.default.join(relOutDir, `${query.shortApiName}.ts`);
-  const objectTypes = getObjectTypeApiNamesFromQuery(query);
-  const importObjects = getObjectImports2(ontology, objectTypes, relFilePath);
-  const baseProps = deleteUndefineds(wireQueryTypeV2ToSdkQueryDefinitionNoParams(query.og));
-  const outputBase = deleteUndefineds(wireQueryDataTypeToQueryDataTypeDefinition(query.output));
-  const referencedObjectTypes = objectTypes.length > 0 ? objectTypes.map((apiNameObj) => `"${apiNameObj}"`).join("|") : "never";
-  await fs2.writeFile(path16__namespace.default.join(outDir, `${query.shortApiName}.ts`), await formatTs(`
-        import type { QueryDefinition , VersionBound} from "@osdk/api";
-        import type { QueryParam, QueryResult } from "@osdk/client.api";
-        import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
-        ${importObjects}
-
-        export namespace ${query.shortApiName} {
-          export interface Signature {
-            ${getDescriptionIfPresent(query.description)}
-            (${Object.keys(query.parameters).length > 0 ? `query: ${query.paramsIdentifier}` : ""}): Promise<${getQueryParamType(ontology, wireQueryParameterV2ToQueryParameterDefinition({
-    dataType: query.output
-  }), "Result")}>
-          }
-
-        ${Object.keys(query.parameters).length > 0 ? `
-            export interface Parameters {
-            ${stringify(query.parameters, {
-    "*": (parameter, formatter, apiName) => {
-      const q = wireQueryParameterV2ToQueryParameterDefinition(parameter);
-      return [`
-                ${queryParamJsDoc(wireQueryParameterV2ToQueryParameterDefinition(parameter), {
-        apiName
-      })}readonly "${apiName}"${q.nullable ? "?" : ""}`, `${getQueryParamType(ontology, q, "Param")}`];
-    }
-  })}
-            }
-    
-            ` : ""}
-
-        export interface Definition extends QueryDefinition<
-          "${query.fullApiName}", 
-          ${referencedObjectTypes},
-          ${query.shortApiName}.Signature
-        >, VersionBound<$ExpectedClientVersion>{
-            ${stringify(baseProps)},
-            parameters: {
-            ${parameterDefsForType(ontology, query)}
-            };
-            output: {
-            ${stringify(outputBase)},
-            ${getLineFor__OsdkTargetType(ontology, query.output)}
-            };
-        }
-
-        }
-
-        /** @deprecated use \`${query.shortApiName}.Signature' instead */
-        export type ${query.shortApiName} = ${query.shortApiName}.Signature;
-
-
-
-
-
-        export const ${query.shortApiName}: ${query.definitionIdentifier} = {
-            ${stringify(baseProps)},
-            parameters: {
-            ${parametersForConst(query)}
-            },
-            output: {
-            ${stringify(outputBase)},
-            }
-        };
-        `));
-}
-function parametersForConst(query) {
-  return stringify(query.parameters, {
-    "*": (parameter, formatter) => formatter(deleteUndefineds(wireQueryParameterV2ToQueryParameterDefinition(parameter)))
-  });
-}
-function parameterDefsForType(ontology, query) {
-  return stringify(query.parameters, {
-    "*": (parameter, valueFormatter, apiName) => [`${queryParamJsDoc(wireQueryParameterV2ToQueryParameterDefinition(parameter), {
-      apiName
-    })} ${apiName}`, ` {
-          ${stringify(deleteUndefineds(wireQueryParameterV2ToQueryParameterDefinition(parameter)))},
-          ${getLineFor__OsdkTargetType(ontology, parameter.dataType)}
-        }`]
-  });
-}
-function getLineFor__OsdkTargetType(ontology, qdt) {
-  if (qdt.type === "object" || qdt.type === "objectSet") {
-    return `__OsdkTargetType?: ${ontology.requireObjectType(qdt.objectTypeApiName).getImportedDefinitionIdentifier(true)}`;
-  }
-  return "";
-}
-function queryParamJsDoc(param, {
-  apiName
-}) {
-  let ret = `/**
-`;
-  if (param.description) {
-    if (param.description) {
-      ret += ` *   description: ${param.description}
-`;
-    }
-  } else {
-    ret += ` * (no ontology metadata)
-`;
-  }
-  ret += ` */
-`;
-  return ret;
-}
-function getObjectImports2(enhancedOntology, objectTypes, filePath) {
-  let ret = "";
-  for (const fqObjectApiName of objectTypes) {
-    const obj = enhancedOntology.requireObjectType(fqObjectApiName);
-    ret += `import type { ${obj.getDefinitionIdentifier(true)} as ${obj.getImportedDefinitionIdentifier(true)} } from "${obj.getImportPathRelTo(filePath)}";
-`;
-  }
-  return ret;
-}
-function getQueryParamType(enhancedOntology, input, type) {
-  let inner = `unknown /* ${input.type} */`;
-  switch (input.type) {
-    case "date":
-      inner = `Query${type}.PrimitiveType<${JSON.stringify("datetime")}>`;
-      break;
-    case "attachment":
-    case "boolean":
-    case "double":
-    case "float":
-    case "integer":
-    case "long":
-    case "string":
-    case "struct":
-    case "threeDimensionalAggregation":
-    case "timestamp":
-    case "twoDimensionalAggregation":
-      inner = `Query${type}.PrimitiveType<${JSON.stringify(input.type)}>`;
-      break;
-    case "object":
-      inner = `Query${type}.ObjectType<${enhancedOntology.requireObjectType(input.object).getImportedDefinitionIdentifier(true)}>`;
-      break;
-    case "objectSet":
-      inner = `Query${type}.ObjectSetType<${enhancedOntology.requireObjectType(input.objectSet).getImportedDefinitionIdentifier(true)}>`;
-      break;
-    case "set":
-      inner = `${type === "Param" ? "Readonly" : ""}Set<${getQueryParamType(enhancedOntology, input.set, type)}>`;
-      break;
-    case "union":
-      inner = input.union.map((u) => getQueryParamType(enhancedOntology, u, type)).join(" | ");
-      break;
-  }
-  if (input.multiplicity && type === "Param") {
-    return `ReadonlyArray<${inner}>`;
-  } else if (input.multiplicity) {
-    return `Array<${inner}>`;
-  }
-  return inner;
-}
-function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, ontology, v2 = false) {
-  const definition = deleteUndefineds(generatorConverters.__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(interfaceDef.og, v2));
-  const objectDefIdentifier = interfaceDef.getDefinitionIdentifier(v2);
-  const parents = definition.implements?.map((p) => {
-    !(ontology.interfaceTypes[p] != null) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Expected to find a parent interface named ${p} in the ontology and did not.`) : invariant__default.default(false) : void 0;
-    const it = deleteUndefineds(generatorConverters.__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(ontology.requireInterfaceType(p, true).og, v2));
-    return it;
-  }) ?? [];
-  const mergedProperties = {
-    ...definition.properties
-  };
-  for (const parent of parents) {
-    for (const apiName of Object.keys(parent.properties)) {
-      if (definition.properties[apiName] != null) {
-        !fastDeepEqual__default.default(definition.properties[apiName], parent.properties[apiName]) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Interface ${definition.apiName} redefines property '${apiName}' from parent '${parent.apiName}' but the properties do not match`) : invariant__default.default(false) : void 0;
-      } else if (mergedProperties[apiName] != null) {
-        !fastDeepEqual__default.default(mergedProperties[apiName], parent.properties[apiName]) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Some interface defines a conflicting property '${apiName}' that does not match property from parent '${parent.apiName}'`) : invariant__default.default(false) : void 0;
-      }
-      mergedProperties[apiName] = parent.properties[apiName];
-    }
-  }
-  definition.properties;
-  definition.properties = mergedProperties;
-  function maybeStripNamespace2(q) {
-    if (interfaceDef.apiNamespace && q.startsWith(`${interfaceDef.apiNamespace}.`)) {
-      return q.slice(interfaceDef.apiNamespace.length + 1);
-    } else {
-      return q;
-    }
-  }
-  const objectSetIdentifier = `${interfaceDef.shortApiName}.ObjectSet`;
-  const propertyKeysIdentifier = `${interfaceDef.shortApiName}.PropertyKeys`;
-  const osdkObjectPropsIdentifier = `${interfaceDef.shortApiName}.Props`;
-  const osdkObjectStrictPropsIdentifier = `${interfaceDef.shortApiName}.StrictProps`;
-  const osdkObjectLinksIdentifier = `OsdkObjectLinks$${objectDefIdentifier}`;
-  const osdkObjectIdentifier = `${interfaceDef.shortApiName}.OsdkObject`;
-  const ids = {
-    objectDefIdentifier: `${interfaceDef.shortApiName}.Definition`,
-    osdkObjectLinksIdentifier,
-    osdkObjectPropsIdentifier,
-    osdkObjectStrictPropsIdentifier,
-    objectSetIdentifier,
-    osdkObjectIdentifier,
-    propertyKeysIdentifier
-  };
-  function getV2Types() {
-    return `import type {
-      AggregateOpts as $AggregateOpts,
-      AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy as $AggregateOptsThatErrorsAndDisallowsOrderingWithMultipleGroupBy,
-      AggregationsResults as $AggregationsResults, 
-      Augments as $Augments,
-      ConvertProps as $ConvertProps,
-      DefaultToFalse as $DefaultToFalse,
-      FetchPageArgs as $FetchPageArgs,
-      FetchPageResult as $FetchPageResult,
-      IsAny as $IsAny,
-      LinkedType as $LinkedType,
-      LinkNames as $LinkNames,
-      NullabilityAdherence as $NullabilityAdherence,
-      NullabilityAdherenceDefault as $NullabilityAdherenceDefault,
-      ObjectSet as $ObjectSet, 
-      Osdk as $Osdk,
-      OsdkObject as $OsdkObject,
-      OsdkObjectLinksEntry as $OsdkObjectLinksEntry,
-      OsdkObjectLinksObject as $OsdkObjectLinksObject,
-      OsdkObjectPropertyType as $OsdkObjectPropertyType,
-      PageResult as $PageResult,
-      PropertyValueClientToWire as $PropertyValueClientToWire,
-      PropertyValueWireToClient as $PropType,
-      Result as $Result,
-      SelectArg as $SelectArg, 
-      SingleLinkAccessor  as $SingleLinkAccessor,
-      SingleOsdkResult as $SingleOsdkResult,
-      ValidToFrom as $ValidToFrom,
-      WhereClause as $WhereClause,
-    } from "@osdk/client.api";
-    import type * as $clientApi from "@osdk/client.api";
-    import type {
-      ObjectOrInterfacePropertyKeysFrom2 as $ObjectOrInterfacePropertyKeysFrom2, 
-      ObjectTypeLinkDefinition as $ObjectTypeLinkDefinition,
-      ObjectTypeDefinition as $ObjectTypeDefinition,
-      InterfaceDefinition as $InterfaceDefinition,
-    } from "@osdk/api";
-
-    
-
-        ${Object.keys(definition.links).length === 0 ? `export type ${osdkObjectLinksIdentifier} = {};` : `
-        export interface ${osdkObjectLinksIdentifier}  {
-${stringify(definition.links, {
-      "*": (definition2) => {
-        const linkTarget = ontology.requireObjectType(definition2.targetType).getImportedDefinitionIdentifier(v2);
-        return `${definition2.multiplicity ? `${linkTarget}["objectSet"]` : `SingleLinkAccessor<${linkTarget}>`}
-          `;
-      }
-    })}
-    }
-    `}
-
-    export namespace ${interfaceDef.shortApiName} {
-
-      ${createPropertyKeys(interfaceDef)}
-
-
-      ${createProps(interfaceDef, "Props", false)}
-      ${createProps(interfaceDef, "StrictProps", true)}
-
-
-      ${createObjectSet(interfaceDef, ids)}
-
-      ${createDefinition(interfaceDef, ontology, "Definition", ids)}
-
-      ${createOsdkObject(interfaceDef, "OsdkObject", ids)}
-      
-    }    
-
-
-
-
-  /** @deprecated use ${interfaceDef.shortApiName}.Definition **/
-  export type ${objectDefIdentifier} = ${interfaceDef.shortApiName}.Definition;
-
-
-
-
-`;
-  }
-  const imports = [];
-  return `${imports.join("\n")}
-    ${v2 ? getV2Types() : ""}
-
-    export const ${interfaceDef.shortApiName}: ${interfaceDef.shortApiName}.Definition = {
-      osdkMetadata: $osdkMetadata,
-      objectSet: undefined as any,
-      props: undefined as any,
-      linksType: undefined as any,
-      strictProps: undefined as any,
-      ${stringify(definition, {
-    osdkMetadata: () => void 0,
-    properties: (properties) => `{
-        ${stringify(properties, {
-      "*": (propertyDefinition, _, key) => [`"${maybeStripNamespace2(key)}"`, _(propertyDefinition)]
-    })}
-      }`
-  })}
-      
-    };`;
-}
-
-// src/v2.0/generateClientSdkVersionTwoPointZero.ts
-async function generateRootIndexTsFile({
-  fs: fs2,
-  outDir,
-  importExt,
-  ontologyApiNamespace
-}) {
-  fs2.writeFile(path16__namespace.default.join(outDir, "index.ts"), await formatTs(`${ontologyApiNamespace == null ? `export { $ontologyRid } from "./OntologyMetadata${importExt}";` : ``}
-        export * from "./ontology/actions${importExt}";
-        export * from "./ontology/objects${importExt}";
-        export * from "./ontology/interfaces${importExt}";
-        export * from "./ontology/queries${importExt}";
-    `));
-}
-async function generateEachObjectFile(ctx) {
-  const {
-    fs: fs2,
-    outDir,
-    ontology,
-    importExt
-  } = ctx;
-  await fs2.mkdir(path16__namespace.default.join(outDir, "ontology", "objects"), {
-    recursive: true
-  });
-  for (const obj of Object.values(ontology.objectTypes)) {
-    const relPath = path16__namespace.default.join(".", "ontology", `objects`, `${obj.shortApiName}.ts`);
-    const outFilePath = path16__namespace.default.join(outDir, relPath);
-    await fs2.writeFile(outFilePath, await formatTs(`
-        import type {  VersionBound as $VersionBound, PropertyDef as $PropertyDef } from "@osdk/api";
-        import type { Osdk } from "@osdk/client.api";
-        import { $osdkMetadata } from "../../OntologyMetadata${importExt}";
-        import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
-        ${wireObjectTypeV2ToSdkObjectConstV2(obj.og, ctx, relPath)}
-      `));
-  }
-}
-async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs2, outDir, packageType = "commonjs", ontologyApiNamespace, apiNamespacePackageMap = /* @__PURE__ */ new Map()) {
-  const importExt = packageType === "module" ? ".js" : "";
-  await verifyOutDir(outDir, fs2);
-  const sanitizedOntology = sanitizeMetadata(ontology);
-  await fs2.mkdir(outDir, {
-    recursive: true
-  });
-  const enhancedOntology = enhanceOntology(sanitizedOntology, ontologyApiNamespace, apiNamespacePackageMap, importExt);
-  const ctx = {
-    sanitizedOntology,
-    ontology: enhancedOntology,
-    importExt,
-    fs: fs2,
-    outDir,
-    ontologyApiNamespace,
-    apiNamespacePackageMap
-  };
-  await generateRootIndexTsFile(ctx);
-  await generateOntologyMetadataFile(ctx, userAgent);
-  await generateEachObjectFile(ctx);
-  await generateOntologyInterfaces(ctx);
-  const actionsDir = path16__namespace.default.join(outDir, "ontology", "actions");
-  await fs2.mkdir(actionsDir, {
-    recursive: true
-  });
-  await generatePerActionDataFiles(ctx);
-  await fs2.writeFile(path16__namespace.default.join(outDir, "ontology", "objects.ts"), await formatTs(`
-    ${Object.values(enhancedOntology.objectTypes).map((objType) => `export * from "./objects/${objType.shortApiName}${importExt}";`).join("\n")}
-    ${Object.keys(ontology.objectTypes).length === 0 ? "export {};" : ""}
-    `));
-  await generatePerQueryDataFilesV2(ctx);
-}
-async function generateOntologyInterfaces({
-  fs: fs2,
-  outDir,
-  ontology,
-  importExt
-}) {
-  const interfacesDir = path16__namespace.default.join(outDir, "ontology", "interfaces");
-  await fs2.mkdir(interfacesDir, {
-    recursive: true
-  });
-  for (const obj of Object.values(ontology.interfaceTypes)) {
-    await fs2.writeFile(path16__namespace.default.join(interfacesDir, `${obj.shortApiName}.ts`), await formatTs(`
-    
-      import type { PropertyDef as $PropertyDef, VersionBound as $VersionBound } from "@osdk/api";
-      import { $osdkMetadata, $expectedClientVersion } from "../../OntologyMetadata${importExt}";
-      import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
-      ${__UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(obj, ontology, true)}
-    `));
-  }
-  await fs2.writeFile(interfacesDir + ".ts", await formatTs(`
-    ${Object.values(ontology.interfaceTypes).map((interfaceType) => `export * from "./interfaces/${interfaceType.shortApiName}${importExt}";`).join("\n")}
-    ${Object.keys(ontology.interfaceTypes).length === 0 ? "export {}" : ""}
-    `));
-}
-
-// src/generateClientSdkPackage.ts
-async function generateClientSdkPackage(packageName, packageVersion, sdkVersion, baseOutDir, ontology, minimalFs, dependencyVersions, cliVersion, ontologyApiNamespace, apiNamespacePackageMap) {
-  if (!packageName) throw new Error("Package name is require");
-  for (const packageType of ["module", "commonjs"]) {
-    const outDir = path16__namespace.join(baseOutDir, "dist", packageType);
-    await (sdkVersion === "1.1" ? generateClientSdkVersionOneDotOne : sdkVersion === "2.0" ? generateClientSdkVersionTwoPointZero : void 0)(ontology, `typescript-sdk/${packageVersion} osdk-cli/${cliVersion}`, minimalFs, outDir, packageType, ontologyApiNamespace, apiNamespacePackageMap);
-    await fs__namespace.promises.mkdir(outDir, {
-      recursive: true
-    });
-    await writeJson(minimalFs, path16__namespace.join(outDir, "package.json"), {
-      type: packageType
-    });
-    await writeJson(minimalFs, path16__namespace.join(outDir, `tsconfig.json`), {
-      compilerOptions: getTsCompilerOptions(packageType)
-    });
-  }
-  await writeJson(minimalFs, path16__namespace.join(baseOutDir, "package.json"), await getPackageJsonContents(packageName, packageVersion, sdkVersion, dependencyVersions));
-  await minimalFs.mkdir(path16__namespace.join(baseOutDir, "ontology"), {
-    recursive: true
-  });
-  await minimalFs.writeFile(path16__namespace.join(baseOutDir, "ontology", "objects.js"), `module.exports = require("../../dist/module/ontology/objects")`);
-  await minimalFs.writeFile(path16__namespace.join(baseOutDir, "ontology", "objects.d.ts"), `export * from "../dist/module/ontology/objects"`);
-}
-function getTsCompilerOptions(packageType) {
-  const commonTsconfig = {
-    importHelpers: true,
-    declaration: true,
-    isolatedModules: true,
-    esModuleInterop: true,
-    forceConsistentCasingInFileNames: true,
-    strict: true,
-    skipLibCheck: true
-  };
-  const compilerOptions = packageType === "commonjs" ? {
-    ...commonTsconfig,
-    module: "commonjs",
-    target: "es2018"
-  } : {
-    ...commonTsconfig,
-    module: "NodeNext",
-    target: "ES2020"
-  };
-  return compilerOptions;
-}
-function getExpectedDependencies(sdkVersion, {
-  osdkApiVersion,
-  osdkClientVersion,
-  osdkClientApiVersion,
-  osdkLegacyClientVersion
-}) {
-  return {
-    devDependencies: {
-      "@osdk/api": osdkApiVersion,
-      ...sdkVersion === "2.0" ? {
-        "@osdk/client.api": osdkClientApiVersion
-      } : {
-        "@osdk/legacy-client": osdkLegacyClientVersion
-      }
-    },
-    peerDependencies: {
-      "@osdk/api": osdkApiVersion,
-      ...sdkVersion === "2.0" ? {
-        "@osdk/client.api": osdkClientApiVersion,
-        "@osdk/client": osdkClientVersion
-      } : {
-        "@osdk/legacy-client": osdkLegacyClientVersion
-      }
-    }
-  };
-}
-function getExpectedDependenciesFull(sdkVersion, dependencyVersions) {
-  const {
-    typescriptVersion,
-    tslibVersion,
-    areTheTypesWrongVersion
-  } = dependencyVersions;
-  const base = getExpectedDependencies(sdkVersion, dependencyVersions);
-  return {
-    devDependencies: {
-      ...base.devDependencies,
-      "typescript": typescriptVersion,
-      "tslib": tslibVersion,
-      "@arethetypeswrong/cli": areTheTypesWrongVersion
-    },
-    peerDependencies: {
-      ...base.peerDependencies
-    }
-  };
-}
-function getPackageJsonContents(name, version, sdkVersion, dependencyVersions) {
-  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)"
-    },
-    ...getExpectedDependenciesFull(sdkVersion, dependencyVersions),
-    files: ["**/*.js", "**/*.d.ts", "dist/**/package.json"]
-  };
-}
-async function writeJson(minimalFs, filePath, body) {
-  return await minimalFs.writeFile(filePath, JSON.stringify(body, void 0, 2) + "\n");
-}
-
-exports.__UNSTABLE_generateClientSdkPackage = generateClientSdkPackage;
-exports.generateClientSdkVersionOneDotOne = generateClientSdkVersionOneDotOne;
-exports.generateClientSdkVersionTwoPointZero = generateClientSdkVersionTwoPointZero;
-exports.getExpectedDependencies = getExpectedDependencies;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map