@osdk/foundry-sdk-generator 2.2.0-beta.8 → 2.3.0-beta.1

package/build/esm/index.js

@@ -1,11 +1,14 @@
 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';
 import { createSharedClientContext } from '@osdk/shared.client.impl';
 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';
@@ -13,10 +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 * as path2 from 'node:path';
-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();
@@ -224,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;
@@ -267,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);
+        }
+      }
+      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}`);
         }
-        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 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());
         }
-        externalInterfaces.set(it.apiName, sdk.npm.npmPackageName);
+        linkTypes.get(objectTypeApiName)?.add(linkTypeApiName);
       }
-    }
-    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 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);
       }
-      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);
+      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]))]));
@@ -349,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;
           }
@@ -388,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) {
@@ -418,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) {
@@ -446,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":
@@ -460,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":
@@ -494,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()) {
@@ -551,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"
   });
@@ -560,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;
 }
 
@@ -577,7 +640,7 @@ async function resolveDependenciesFromFindUp(deps, cwd) {
 }
 
 // src/utils/UserAgent.ts
-var USER_AGENT = `typescript-sdk-generator/${"2.2.0-beta.8"}`;
+var USER_AGENT = `typescript-sdk-generator/${"2.3.0-beta.1"}`;
 async function createRollupBuild(absolutePackagePath, packageName) {
   const inputPath = `${absolutePackagePath}/${packageName}/esm/index.js`;
   const {
@@ -805,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();
@@ -844,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) {
@@ -856,39 +919,44 @@ function constructDependencies(dependencies) {
 
 // src/generate/betaClient/generatePackage.ts
 var betaPeerDependencies = {
-  "@osdk/client": undefined
+  "@osdk/client": void 0
 };
 async function generatePackage(ontologyInfo, options) {
   const {
     consola
   } = await import('consola');
   let success = true;
-  const packagePath = join(options.outputDir, options.packageName);
+  if (options.ontologyJsonOnly) {
+    await mkdir(options.outputDir, {
+      recursive: true
+    });
+    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));
   const resolvedPeerDependencies = await resolveDependenciesFromFindUp(betaPeerDependencies, dirname(fileURLToPath(import.meta.url)));
   await mkdir(packagePath, {
     recursive: true
   });
   const inMemoryFileSystem = {};
   const hostFs = {
-    writeFile: async (path3, contents2) => {
-      inMemoryFileSystem[normalize(path3)] = contents2;
+    writeFile: async (path4, contents2) => {
+      inMemoryFileSystem[customNormalize(path4)] = contents2;
     },
-    mkdir: async (path3, _options) => {
-      await mkdir(normalize(path3), {
+    mkdir: async (path4, _options) => {
+      await mkdir(customNormalize(path4), {
         recursive: true
       });
     },
-    readdir: (path3) => readdir(path3)
+    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({
@@ -909,8 +977,8 @@ async function generatePackage(ontologyInfo, options) {
     await mkdir(join(packagePath, "cjs"), {
       recursive: true
     });
-    for (const [path3, contents2] of Object.entries(compilerOutput[type].files)) {
-      const newPath = path3.replace(packagePath, join(packagePath, type));
+    for (const [path4, contents2] of Object.entries(compilerOutput[type].files)) {
+      const newPath = path4.replace(packagePath, join(packagePath, type));
       await mkdir(dirname(newPath), {
         recursive: true
       });
@@ -958,12 +1026,15 @@ async function generatePackage(ontologyInfo, options) {
     throw new Error("Failed to generate package");
   }
 }
+function customNormalize(pathName) {
+  return normalize(pathName.replace(/\\/g, "/"));
+}
 
 // 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;
@@ -1004,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,
@@ -1087,7 +1158,8 @@ var GeneratePackageCommand = class {
       packageName: args.packageName,
       packageVersion: args.packageVersion,
       outputDir: args.outputDir,
-      beta: !!args.beta
+      beta: !!args.beta,
+      ontologyJsonOnly: args.experimentalFeatures?.includes("ontologyJsonOnly") ?? false
     });
     const elapsedTime = Date.now() - timeStart;
     consola.success(`Finished generating package in ${(elapsedTime / 1e3).toFixed(2)}s`);