@osdk/foundry-sdk-generator 2.2.0-beta.9 → 2.2.0-rc.25

package/build/esm/index.js

@@ -1,5 +1,5 @@
 import { fileURLToPath as fileURLToPath$1 } from 'url';
-import path, { join, dirname, isAbsolute, normalize } from 'path';
+import path, { join, dirname, isAbsolute } from 'path';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { exit } from 'process';
@@ -8,6 +8,7 @@ import { generateClientSdkVersionTwoPointZero } from '@osdk/generator';
 import { mkdir, writeFile, readdir, readFile } from 'fs/promises';
 import * as path2 from 'node:path';
 import path2__default from 'node:path';
+import { normalize } from 'node:path/posix';
 import { fileURLToPath } from 'node:url';
 import commonjs from '@rollup/plugin-commonjs';
 import { nodeResolve } from '@rollup/plugin-node-resolve';
@@ -15,9 +16,9 @@ import { rollup } from 'rollup';
 import nodePolyfill from 'rollup-plugin-polyfill-node';
 import { Project, Node } from 'ts-morph';
 import * as fs from 'node:fs';
-import { ModuleKind, ScriptTarget, createCompilerHost, createSourceFile, createProgram } from 'typescript';
+import { ScriptTarget, ModuleKind, createCompilerHost, createSourceFile, createProgram } from 'typescript';
 
-// ../../node_modules/.pnpm/tsup@8.2.3_@microsoft+api-extractor@7.49.1_@types+node@18.19.74__@swc+core@1.7.39_jiti@2.4.2__ujeti7sjay3i2ioyyyu7uezhje/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@8.4.0_@microsoft+api-extractor@7.52.7_@types+node@18.19.97__@swc+core@1.7.39_jiti@2.4.2__2dta44cza7xfoposuc4x3z55ly/node_modules/tsup/assets/esm_shims.js
 var getFilename = () => fileURLToPath$1(import.meta.url);
 var getDirname = () => path.dirname(getFilename());
 var __dirname = /* @__PURE__ */ getDirname();
@@ -225,7 +226,7 @@ var OntologyMetadataResolver = class {
       objectType.linkTypes = objectType.linkTypes.filter((linkType) => linkTypesToKeep.has(linkType.apiName));
     });
     const filteredActionTypes = Object.fromEntries(Object.entries(ontologyFullMetadata.actionTypes).filter(([actionApiName]) => {
-      if (expectedEntities.actionTypes.has(this.camelize(actionApiName))) {
+      if (expectedEntities.actionTypes.has(actionApiName)) {
         return true;
       }
       return false;
@@ -268,71 +269,129 @@ var OntologyMetadataResolver = class {
     } catch (e) {
       return Result.err([`Unable to load the specified Ontology with network error: ${JSON.stringify(e)}`]);
     }
-    const ontologyFullMetadata = await OntologiesV2.getFullMetadata(this.getClientContext(), ontology.rid);
-    if (ontologyFullMetadata.errorName != null) {
-      return Result.err([`Unable to load the specified Ontology metadata.
+    if (extPackageInfo.size > 0) {
+      const ontologyFullMetadata = await OntologiesV2.getFullMetadata(this.getClientContext(), ontology.rid);
+      if (ontologyFullMetadata.errorName != null) {
+        return Result.err([`Unable to load the specified Ontology metadata.
 ${JSON.stringify(ontologyFullMetadata, null, 2)}`]);
-    }
-    const externalObjects = /* @__PURE__ */ new Map();
-    const externalInterfaces = /* @__PURE__ */ new Map();
-    for (const {
-      sdk
-    } of extPackageInfo.values()) {
-      if (sdk.npm?.npmPackageName == null) {
-        throw new Error("External package is not generated as an npm package");
       }
-      const dataScope = sdk.inputs.dataScope.ontologyV2;
-      for (const rid of dataScope.objectTypes) {
-        const ot = Object.values(ontologyFullMetadata.objectTypes).find((ot2) => ot2.objectType.rid === rid);
-        if (!ot) {
-          throw new Error(`Could not find external object type with rid ${rid}`);
+      const externalObjects = /* @__PURE__ */ new Map();
+      const externalInterfaces = /* @__PURE__ */ new Map();
+      for (const {
+        sdk
+      } of extPackageInfo.values()) {
+        if (sdk.npm?.npmPackageName == null) {
+          throw new Error("External package is not generated as an npm package");
+        }
+        const dataScope = sdk.inputs.dataScope.ontologyV2;
+        for (const rid of dataScope.objectTypes) {
+          const ot = Object.values(ontologyFullMetadata.objectTypes).find((ot2) => ot2.objectType.rid === rid);
+          if (!ot) {
+            throw new Error(`Could not find external object type with rid ${rid}`);
+          }
+          externalObjects.set(ot.objectType.apiName, sdk.npm.npmPackageName);
+        }
+        for (const rid of dataScope.interfaceTypes) {
+          const it = Object.values(ontologyFullMetadata.interfaceTypes).find((it2) => it2.rid === rid);
+          if (!it) {
+            throw new Error(`Could not find external interface type with rid ${rid}`);
+          }
+          externalInterfaces.set(it.apiName, sdk.npm.npmPackageName);
         }
-        externalObjects.set(ot.objectType.apiName, sdk.npm.npmPackageName);
       }
-      for (const rid of dataScope.interfaceTypes) {
-        const it = Object.values(ontologyFullMetadata.interfaceTypes).find((it2) => it2.rid === rid);
-        if (!it) {
-          throw new Error(`Could not find external interface type with rid ${rid}`);
+      const linkTypes = /* @__PURE__ */ new Map();
+      const objectTypes = new Set(entities.objectTypesApiNamesToLoad);
+      const queryTypes = new Set(entities.queryTypesApiNamesToLoad);
+      for (const queryType of entities.queryTypesApiNamesToLoad ?? []) {
+        if (queryType.includes(":")) {
+          throw new Error(`Query types with fixed versions are not supported with external packages: ${queryType}`);
         }
-        externalInterfaces.set(it.apiName, sdk.npm.npmPackageName);
       }
-    }
-    const linkTypes = /* @__PURE__ */ new Map();
-    const objectTypes = new Set(entities.objectTypesApiNamesToLoad);
-    const queryTypes = new Set(entities.queryTypesApiNamesToLoad);
-    const actionTypes = new Set(entities.actionTypesApiNamesToLoad?.map((action) => this.camelize(action)));
-    const interfaceTypes = new Set(entities.interfaceTypesApiNamesToLoad);
-    for (const linkType of entities.linkTypesApiNamesToLoad ?? []) {
-      const [objectTypeApiName, linkTypeApiName] = linkType.split(".");
-      if (!linkTypes.has(objectTypeApiName)) {
-        linkTypes.set(objectTypeApiName, /* @__PURE__ */ new Set());
+      const actionTypes = new Set(entities.actionTypesApiNamesToLoad);
+      const interfaceTypes = new Set(entities.interfaceTypesApiNamesToLoad);
+      for (const linkType of entities.linkTypesApiNamesToLoad ?? []) {
+        const [objectTypeApiName, linkTypeApiName] = linkType.split(".");
+        if (!linkTypes.has(objectTypeApiName)) {
+          linkTypes.set(objectTypeApiName, /* @__PURE__ */ new Set());
+        }
+        linkTypes.get(objectTypeApiName)?.add(linkTypeApiName);
       }
-      linkTypes.get(objectTypeApiName)?.add(linkTypeApiName);
-    }
-    const filteredFullMetadata = this.filterMetadataByApiName(ontologyFullMetadata, {
-      objectTypes,
-      linkTypes,
-      actionTypes,
-      queryTypes,
-      interfaceTypes
-    }, extPackageInfo);
-    const validData = this.validateLoadedOntologyMetadata(filteredFullMetadata, {
-      objectTypes,
-      linkTypes,
-      actionTypes,
-      queryTypes,
-      interfaceTypes
-    }, ontologyFullMetadata, extPackageInfo);
-    if (validData.isErr()) {
-      return Result.err(validData.error);
+      const filteredFullMetadata = this.filterMetadataByApiName(ontologyFullMetadata, {
+        objectTypes,
+        linkTypes,
+        actionTypes,
+        queryTypes,
+        interfaceTypes
+      }, extPackageInfo);
+      const validData = this.validateLoadedOntologyMetadata(filteredFullMetadata, {
+        objectTypes,
+        linkTypes,
+        actionTypes,
+        queryTypes,
+        interfaceTypes
+      }, extPackageInfo, ontologyFullMetadata);
+      if (validData.isErr()) {
+        return Result.err(validData.error);
+      }
+      return Result.ok({
+        requestedMetadata: filteredFullMetadata,
+        externalInterfaces,
+        externalObjects,
+        fixedVersionQueryTypes: []
+      });
+    } else {
+      const objectTypes = new Set(entities.objectTypesApiNamesToLoad);
+      const interfaceTypes = new Set(entities.interfaceTypesApiNamesToLoad);
+      const actionTypes = new Set(entities.actionTypesApiNamesToLoad);
+      const linkTypes = /* @__PURE__ */ new Map();
+      for (const linkType of entities.linkTypesApiNamesToLoad ?? []) {
+        const [objectTypeApiName, linkTypeApiName] = linkType.split(".");
+        if (!linkTypes.has(objectTypeApiName)) {
+          linkTypes.set(objectTypeApiName, /* @__PURE__ */ new Set());
+        }
+        linkTypes.get(objectTypeApiName)?.add(linkTypeApiName);
+      }
+      const queryTypes = /* @__PURE__ */ new Set();
+      const fixedVersionQueryTypes = [];
+      for (const queryType of entities.queryTypesApiNamesToLoad ?? []) {
+        if (queryTypes.has(queryType)) {
+          return Result.err([`Query type ${queryType} was specified multiple times.`]);
+        }
+        const lastColonIndex = queryType.lastIndexOf(":");
+        if (lastColonIndex !== -1) {
+          const queryTypeApiName = queryType.substring(0, lastColonIndex);
+          fixedVersionQueryTypes.push(queryTypeApiName);
+        }
+        queryTypes.add(queryType);
+      }
+      const requestedMetadata = await OntologiesV2.loadMetadata(this.getClientContext(), ontology.rid, {
+        actionTypes: [...actionTypes],
+        objectTypes: [...objectTypes],
+        queryTypes: [...queryTypes],
+        interfaceTypes: [...interfaceTypes],
+        linkTypes: Array.from(linkTypes.entries()).flatMap(([_, linkTypeApiNames]) => [...linkTypeApiNames])
+      }, {
+        preview: true
+      });
+      const validData = this.validateLoadedOntologyMetadata(requestedMetadata, {
+        objectTypes,
+        linkTypes,
+        actionTypes,
+        queryTypes,
+        interfaceTypes
+      }, extPackageInfo);
+      if (validData.isErr()) {
+        return Result.err(validData.error);
+      }
+      return Result.ok({
+        requestedMetadata,
+        externalInterfaces: /* @__PURE__ */ new Map(),
+        externalObjects: /* @__PURE__ */ new Map(),
+        fixedVersionQueryTypes
+      });
     }
-    return Result.ok({
-      filteredFullMetadata,
-      externalInterfaces,
-      externalObjects
-    });
   }
-  validateLoadedOntologyMetadata(filteredFullMetadata, expectedEntities, fullOntology, packageInfo) {
+  validateLoadedOntologyMetadata(filteredFullMetadata, expectedEntities, packageInfo, fullMetadata) {
     const errors = [];
     const loadedObjectTypes = Object.fromEntries(Object.values(filteredFullMetadata.objectTypes).map((object) => [object.objectType.apiName, object]));
     const loadedLinkTypes = Object.fromEntries(Object.values(filteredFullMetadata.objectTypes).map((object) => [object.objectType.apiName, Object.fromEntries(object.linkTypes.map((link) => [link.apiName, link]))]));
@@ -350,7 +409,7 @@ ${JSON.stringify(ontologyFullMetadata, null, 2)}`]);
       }
       for (const [, link] of Object.entries(loadedLinkTypes[object])) {
         if (!expectedEntities.objectTypes.has(link.objectTypeApiName)) {
-          const fromFull = fullOntology.objectTypes[link.objectTypeApiName];
+          const fromFull = fullMetadata?.objectTypes[link.objectTypeApiName];
           if (fromFull && hasObjectType(packageInfo, fromFull)) {
             continue;
           }
@@ -389,14 +448,13 @@ ${JSON.stringify(ontologyFullMetadata, null, 2)}`]);
     if (missingQueryTypes.length > 0) {
       errors.push(`Unable to find the following Query Types: ${missingQueryTypes.join()}`);
     }
-    const loadedActionTypes = Object.fromEntries(Object.entries(filteredFullMetadata.actionTypes).map(([actionApiName, action]) => [this.camelize(actionApiName), action]));
     const missingActionTypes = [];
     for (const actionApiName of expectedEntities.actionTypes) {
-      if (!loadedActionTypes[actionApiName]) {
+      if (!filteredFullMetadata.actionTypes[actionApiName]) {
         missingActionTypes.push(actionApiName);
       }
     }
-    for (const action of Object.values(loadedActionTypes)) {
+    for (const action of Object.values(filteredFullMetadata.actionTypes)) {
       const result = this.validateActionParameters(action, expectedEntities.objectTypes, expectedEntities.interfaceTypes);
       if (result.isErr()) {
         for (const errorString of result.error) {
@@ -419,8 +477,7 @@ ${JSON.stringify(ontologyFullMetadata, null, 2)}`]);
     return results;
   }
   validateActionParameters(actionType, loadedObjectApiNames, loadedInterfaceApiNames) {
-    const camelizedApiName = this.camelize(actionType.apiName);
-    const parameterValidation = Object.entries(actionType.parameters).map(([_paramName, paramData]) => this.isSupportedActionTypeParameter(camelizedApiName, paramData.dataType, loadedObjectApiNames, loadedInterfaceApiNames));
+    const parameterValidation = Object.entries(actionType.parameters).map(([_paramName, paramData]) => this.isSupportedActionTypeParameter(actionType.apiName, paramData.dataType, loadedObjectApiNames, loadedInterfaceApiNames));
     return Result.coalesce(parameterValidation);
   }
   visitSupportedQueryTypes(queryApiName, propertyName, baseType, loadedObjectApiNames) {
@@ -447,6 +504,8 @@ ${JSON.stringify(ontologyFullMetadata, null, 2)}`]);
           return Result.ok({});
         }
         return Result.err([`Unable to load query ${queryApiName} because it takes an unsupported parameter type: ${JSON.stringify(baseType)} in parameter ${propertyName}`]);
+      case "entrySet":
+        return Result.coalesce([this.visitSupportedQueryTypes(queryApiName, propertyName, baseType.keyType, loadedObjectApiNames), this.visitSupportedQueryTypes(queryApiName, propertyName, baseType.valueType, loadedObjectApiNames)]);
       case "string":
       case "boolean":
       case "attachment":
@@ -461,29 +520,30 @@ ${JSON.stringify(ontologyFullMetadata, null, 2)}`]);
       case "null":
         return Result.ok({});
       case "unsupported":
+        return Result.err([`Unable to load query ${queryApiName} because it takes an unsupported parameter type: ${JSON.stringify(baseType)} in parameter ${propertyName}`]);
       default:
         return Result.err([`Unable to load query ${queryApiName} because it takes an unsupported parameter type: ${JSON.stringify(baseType)} in parameter ${propertyName}`]);
     }
   }
-  isSupportedActionTypeParameter(actionApiName, actonTypeParameter, loadedObjectApiNames, loadedInterfaceApiNames) {
-    switch (actonTypeParameter.type) {
+  isSupportedActionTypeParameter(actionApiName, actionTypeParameter, loadedObjectApiNames, loadedInterfaceApiNames) {
+    switch (actionTypeParameter.type) {
       case "array":
-        return this.isSupportedActionTypeParameter(actionApiName, actonTypeParameter.subType, loadedObjectApiNames, loadedInterfaceApiNames);
+        return this.isSupportedActionTypeParameter(actionApiName, actionTypeParameter.subType, loadedObjectApiNames, loadedInterfaceApiNames);
       case "object":
-        if (loadedObjectApiNames.has(actonTypeParameter.objectTypeApiName)) {
+        if (loadedObjectApiNames.has(actionTypeParameter.objectTypeApiName)) {
           return Result.ok({});
         }
-        return Result.err([`Unable to load action ${actionApiName} because it takes an unloaded object type as a parameter: ${actonTypeParameter.objectTypeApiName} make sure to specify it as an argument with --ontologyObjects ${actonTypeParameter.objectTypeApiName})`]);
+        return Result.err([`Unable to load action ${actionApiName} because it takes an unloaded object type as a parameter: ${actionTypeParameter.objectTypeApiName} make sure to specify it as an argument with --ontologyObjects ${actionTypeParameter.objectTypeApiName})`]);
       case "objectSet":
-        if (loadedObjectApiNames.has(actonTypeParameter.objectTypeApiName)) {
+        if (loadedObjectApiNames.has(actionTypeParameter.objectTypeApiName)) {
           return Result.ok({});
         }
-        return Result.err([`Unable to load action ${actionApiName} because it takes an ObjectSet of unloaded object type as a parameter: ${actonTypeParameter.objectTypeApiName} make sure to specify it as an argument with --ontologyObjects ${actonTypeParameter.objectTypeApiName})`]);
+        return Result.err([`Unable to load action ${actionApiName} because it takes an ObjectSet of unloaded object type as a parameter: ${actionTypeParameter.objectTypeApiName} make sure to specify it as an argument with --ontologyObjects ${actionTypeParameter.objectTypeApiName})`]);
       case "interfaceObject":
-        if (loadedInterfaceApiNames.has(actonTypeParameter.interfaceTypeApiName)) {
+        if (loadedInterfaceApiNames.has(actionTypeParameter.interfaceTypeApiName)) {
           return Result.ok({});
         }
-        return Result.err([`Unable to load action ${actionApiName} because it takes an unloaded interface type as a parameter: ${actonTypeParameter.interfaceTypeApiName} make sure to specify it as an argument with --ontologyInterfaces ${actonTypeParameter.interfaceTypeApiName}`]);
+        return Result.err([`Unable to load action ${actionApiName} because it takes an unloaded interface type as a parameter: ${actionTypeParameter.interfaceTypeApiName} make sure to specify it as an argument with --ontologyInterfaces ${actionTypeParameter.interfaceTypeApiName}`]);
       case "string":
       case "boolean":
       case "attachment":
@@ -495,14 +555,16 @@ ${JSON.stringify(ontologyFullMetadata, null, 2)}`]);
       case "struct":
       case "mediaReference":
       case "objectType":
+      case "marking":
+      case "geohash":
+      case "geoshape":
         return Result.ok({});
+      case "vector":
+        return Result.err([`Unable to load action ${actionApiName} because it takes an unsupported parameter: ${JSON.stringify(actionTypeParameter)} specify only the actions you want to load with the --actions argument.`]);
       default:
-        return Result.err([`Unable to load action ${actionApiName} because it takes an unsupported parameter: ${JSON.stringify(actonTypeParameter)} specify only the actions you want to load with the --actions argument.`]);
+        return Result.err([`Unable to load action ${actionApiName} because it takes an unsupported parameter: ${JSON.stringify(actionTypeParameter)} specify only the actions you want to load with the --actions argument.`]);
     }
   }
-  camelize(name) {
-    return name.replace(/-./g, (segment) => segment[1].toUpperCase());
-  }
 };
 function hasObjectType(z, fromFull) {
   for (const q of z.values()) {
@@ -552,7 +614,7 @@ async function getDependencyVersionFromFindUpPackageJson(name, opts) {
     findUp
   } = await import('find-up');
   const packageJsonPath = await findUp("package.json", opts);
-  !(packageJsonPath !== undefined) ? process.env.NODE_ENV !== "production" ? process.env.NODE_ENV !== "production" ? invariant(false, "Could not find package.json") : invariant()  : process.env.NODE_ENV !== "production" ? invariant() : invariant()  : undefined;
+  !(packageJsonPath !== void 0) ? process.env.NODE_ENV !== "production" ? process.env.NODE_ENV !== "production" ? invariant(false, "Could not find package.json") : invariant()  : process.env.NODE_ENV !== "production" ? invariant() : invariant()  : void 0;
   const packageJson = await readFile(packageJsonPath, {
     encoding: "utf-8"
   });
@@ -561,7 +623,7 @@ async function getDependencyVersionFromFindUpPackageJson(name, opts) {
   }
   const parsedPackageJson = JSON.parse(packageJson);
   const version = parsedPackageJson.dependencies?.[name] ?? parsedPackageJson.devDependencies?.[name] ?? parsedPackageJson.peerDependencies?.[name];
-  !(version !== undefined) ? process.env.NODE_ENV !== "production" ? process.env.NODE_ENV !== "production" ? invariant(false, `Could not find a dependency for ${name} in ${packageJsonPath}`) : invariant()  : process.env.NODE_ENV !== "production" ? invariant() : invariant()  : undefined;
+  !(version !== void 0) ? process.env.NODE_ENV !== "production" ? process.env.NODE_ENV !== "production" ? invariant(false, `Could not find a dependency for ${name} in ${packageJsonPath}`) : invariant()  : process.env.NODE_ENV !== "production" ? invariant() : invariant()  : void 0;
   return version;
 }
 
@@ -578,7 +640,7 @@ async function resolveDependenciesFromFindUp(deps, cwd) {
 }
 
 // src/utils/UserAgent.ts
-var USER_AGENT = `typescript-sdk-generator/${"2.2.0-beta.9"}`;
+var USER_AGENT = `typescript-sdk-generator/${"2.2.0-rc.25"}`;
 async function createRollupBuild(absolutePackagePath, packageName) {
   const inputPath = `${absolutePackagePath}/${packageName}/esm/index.js`;
   const {
@@ -806,7 +868,7 @@ function compileInMemory(files, type) {
   const originalSourceFile = compilerHost.getSourceFile;
   compilerHost.getSourceFile = (fileName, languageVersion) => {
     const sourceText = files[fileName];
-    return sourceText !== undefined ? createSourceFile(fileName, sourceText, languageVersion) : originalSourceFile(fileName, languageVersion);
+    return sourceText !== void 0 ? createSourceFile(fileName, sourceText, languageVersion) : originalSourceFile(fileName, languageVersion);
   };
   const program = createProgram(Object.keys(files), compilerOptions, compilerHost);
   const emitOutput = program.emit();
@@ -845,7 +907,7 @@ async function generatePackageJson(options) {
     peerDependencies: packagePeerDeps,
     type: "commonjs"
   };
-  await writeFile(join(options.packagePath, "package.json"), JSON.stringify(packageJson, undefined, 4));
+  await writeFile(join(options.packagePath, "package.json"), JSON.stringify(packageJson, void 0, 4));
   return packageJson;
 }
 function constructDependencies(dependencies) {
@@ -857,7 +919,7 @@ function constructDependencies(dependencies) {
 
 // src/generate/betaClient/generatePackage.ts
 var betaPeerDependencies = {
-  "@osdk/client": undefined
+  "@osdk/client": void 0
 };
 async function generatePackage(ontologyInfo, options) {
   const {
@@ -868,7 +930,7 @@ async function generatePackage(ontologyInfo, options) {
     await mkdir(options.outputDir, {
       recursive: true
     });
-    await writeFile(path2__default.join(options.outputDir, "ontology.json"), JSON.stringify(ontologyInfo.filteredFullMetadata, null, 2), "utf-8");
+    await writeFile(path2__default.join(options.outputDir, "ontology.json"), JSON.stringify(ontologyInfo.requestedMetadata, null, 2), "utf-8");
     return;
   }
   const packagePath = customNormalize(join(options.outputDir, options.packageName));
@@ -888,15 +950,13 @@ async function generatePackage(ontologyInfo, options) {
     },
     readdir: (path4) => readdir(path4)
   };
-  await generateClientSdkVersionTwoPointZero(ontologyInfo.filteredFullMetadata, `typescript-sdk/${options.packageVersion} ${USER_AGENT}`, hostFs, packagePath, "module", ontologyInfo.externalObjects, ontologyInfo.externalInterfaces);
+  await generateClientSdkVersionTwoPointZero(ontologyInfo.requestedMetadata, `typescript-sdk/${options.packageVersion} ${USER_AGENT}`, hostFs, packagePath, "module", ontologyInfo.externalObjects, ontologyInfo.externalInterfaces, /* @__PURE__ */ new Map(), false, ontologyInfo.fixedVersionQueryTypes);
   const contents = await generatePackageJson({
     packageName: options.packageName,
     packagePath,
     packageVersion: options.packageVersion,
     dependencies: [],
-    peerDependencies: resolvedPeerDependencies,
-    beta: options.beta
-  });
+    peerDependencies: resolvedPeerDependencies});
   const compilerOutput = {};
   for (const type of ["esm", "cjs"]) {
     await hostFs.writeFile(join(packagePath, "package.json"), JSON.stringify({
@@ -973,8 +1033,8 @@ function customNormalize(pathName) {
 // src/generate/commandUtils.ts
 function transformArrayArg(arg) {
   if (arg && arg.length > 0) {
-    if (arg[0] === undefined) {
-      return undefined;
+    if (arg[0] === void 0) {
+      return void 0;
     }
   }
   return arg;
@@ -1015,42 +1075,42 @@ var GeneratePackageCommand = class {
       string: true,
       demandOption: false,
       description: `The API names of the object types to generate. Example Usage: --objectTypes Aircraft Airport`,
-      default: undefined,
+      default: void 0,
       defaultDescription: `By default, no arguments will not load any object type.`
     }).options("actionTypes", {
       array: true,
       string: true,
       demandOption: false,
       description: `The API names of the action types to generate. Example Usage: --actionTypes schedule-airplane-maintenance`,
-      default: undefined,
+      default: void 0,
       defaultDescription: `By default, no arguments will not load any action type.`
     }).options("linkTypes", {
       array: true,
       string: true,
       demandOption: false,
       description: `The link types to generate in the format of ObjectTypeApiName.LinkTypeApiName. Example Usage: --linkTypes Aircraft.scheduledFlight`,
-      default: undefined,
+      default: void 0,
       defaultDescription: `By default, no arguments will not load any link type.`
     }).options("queryTypes", {
       array: true,
       string: true,
       demandOption: false,
       description: `The API Names of the query types to generate. Example Usage: --queryTypes calculateMetric`,
-      default: undefined,
+      default: void 0,
       defaultDescription: `By default, no arguments will not load any query type.`
     }).options("interfaceTypes", {
       array: true,
       string: true,
       demandOption: false,
       description: `The API Names of the interface types to generate. Example Usage: --interfaceTypes Geolocatable`,
-      default: undefined,
+      default: void 0,
       defaultDescription: `By default, no arguments will not load any interface type.`
     }).options("experimentalFeatures", {
       array: true,
       string: true,
       demandOption: false,
       description: `Experimental features that can be modified or removed at any time. Example Usage: --experimentalFeatures realtimeUpdates`,
-      default: undefined,
+      default: void 0,
       defaultDescription: `By default, no arguments will not enable any experimental features.`
     }).options("beta", {
       boolean: true,