@osdk/foundry-sdk-generator 2.0.0-beta.9 → 2.0.2-rc.0

package/build/cjs/index.cjs

@@ -1,881 +0,0 @@
-'use strict';
-
-var yargs = require('yargs');
-var helpers = require('yargs/helpers');
-var process$1 = require('process');
-var shared_net = require('@osdk/shared.net');
-var generator = require('@osdk/generator');
-var promises = require('fs/promises');
-var path = require('path');
-var commonjs = require('@rollup/plugin-commonjs');
-var pluginNodeResolve = require('@rollup/plugin-node-resolve');
-var rollup = require('rollup');
-var nodePolyfill = require('rollup-plugin-polyfill-node');
-var tsMorph = require('ts-morph');
-var fs = require('fs');
-var typescript = require('typescript');
-
-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 yargs__default = /*#__PURE__*/_interopDefault(yargs);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var commonjs__default = /*#__PURE__*/_interopDefault(commonjs);
-var nodePolyfill__default = /*#__PURE__*/_interopDefault(nodePolyfill);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-
-// src/cli/foundrySdkGeneratorCli.ts
-
-// src/ontologyMetadata/Result.ts
-var Ok = class {
-  constructor(value) {
-    this.value = value;
-  }
-  isErr() {
-    return false;
-  }
-  isOk() {
-    return true;
-  }
-  transform(transformOk, _transformErr) {
-    return transformOk(this.value);
-  }
-  map(transformOk) {
-    return Result.ok(transformOk(this.value));
-  }
-  mapErr(_transformErr) {
-    return Result.ok(this.value);
-  }
-};
-var Err = class {
-  constructor(error) {
-    this.error = error;
-  }
-  isErr() {
-    return true;
-  }
-  isOk() {
-    return false;
-  }
-  transform(_transformOk, transformErr) {
-    return transformErr(this.error);
-  }
-  map(_transformOk) {
-    return Result.err(this.error);
-  }
-  mapErr(transformErr) {
-    return Result.err(transformErr(this.error));
-  }
-};
-var Result = {
-  ok(ok) {
-    return new Ok(ok);
-  },
-  err(err) {
-    return new Err(err);
-  },
-  /**
-   * Returns err E array if any result has an error.
-   * Returns T array if all results are ok.
-   */
-  coalesce(results) {
-    return results.reduce((acc, value) => {
-      return value.transform((ok) => {
-        return acc.transform((accOk) => {
-          return Result.ok([...accOk, ok]);
-        }, (accErr) => {
-          return Result.err(accErr);
-        });
-      }, (err) => {
-        return acc.transform(() => {
-          return Result.err([...err]);
-        }, (accErr) => {
-          return Result.err([...accErr, ...err]);
-        });
-      });
-    }, Result.ok([]));
-  }
-};
-
-// src/ontologyMetadata/ontologyMetadataResolver.ts
-var OntologyMetadataResolver = class {
-  #authToken;
-  constructor(authToken, stackName) {
-    this.stackName = stackName;
-    this.#authToken = authToken;
-  }
-  getClientContext() {
-    return shared_net.createClientContext(this.stackName.match(/^https?:\/\//) ? this.stackName : `https://${this.stackName}`, () => this.#authToken, `foundry-typescript-osdk-generator/${process.env.npm_package_version}`);
-  }
-  filterMetadata(ontologyFullMetadata, expectedEntities) {
-    const filteredObjectTypes = Object.fromEntries(Object.entries(ontologyFullMetadata.objectTypes).filter(([objectTypeApiName]) => expectedEntities.objectTypes.has(objectTypeApiName.toLowerCase())));
-    const filteredInterfaceTypes = Object.fromEntries(Object.entries(ontologyFullMetadata.interfaceTypes).filter(([interfaceApiName]) => expectedEntities.interfaceTypes.has(interfaceApiName.toLowerCase())));
-    Object.values(filteredObjectTypes).forEach((objectType) => {
-      const linkTypesToKeep = expectedEntities.linkTypes.get(objectType.objectType.apiName.toLowerCase());
-      if (!linkTypesToKeep) {
-        objectType.linkTypes = [];
-        return;
-      }
-      objectType.linkTypes = objectType.linkTypes.filter((linkType) => linkTypesToKeep.has(linkType.apiName.toLowerCase()));
-    });
-    const filteredActionTypes = Object.fromEntries(Object.entries(ontologyFullMetadata.actionTypes).filter(([actionApiName]) => {
-      if (expectedEntities.actionTypes.has(this.camelize(actionApiName).toLowerCase())) {
-        return true;
-      }
-      return false;
-    }));
-    const filteredQueryTypes = Object.fromEntries(Object.entries(ontologyFullMetadata.queryTypes).filter(([queryApiName]) => expectedEntities.queryTypes.has(queryApiName.toLowerCase())));
-    return {
-      ontology: ontologyFullMetadata.ontology,
-      objectTypes: filteredObjectTypes,
-      actionTypes: filteredActionTypes,
-      queryTypes: filteredQueryTypes,
-      interfaceTypes: filteredInterfaceTypes,
-      sharedPropertyTypes: {}
-    };
-  }
-  async getWireOntologyDefinition(ontologyRid, entities) {
-    let ontology;
-    const {
-      Ontologies
-    } = await import('@osdk/internal.foundry.ontologies');
-    const {
-      OntologiesV2
-    } = await import('@osdk/internal.foundry.ontologiesv2');
-    try {
-      ontology = await Ontologies.getOntology(this.getClientContext(), ontologyRid);
-    } catch (e) {
-      return Result.err([`Unable to load the specified Ontology with network error: ${JSON.stringify(e)}`]);
-    }
-    const ontologyFullMetadata = await OntologiesV2.getOntologyFullMetadata(this.getClientContext(), ontology.rid);
-    if (ontologyFullMetadata.errorName != null) {
-      return Result.err([`Unable to load the specified Ontology metadata.
-${JSON.stringify(ontologyFullMetadata, null, 2)}`]);
-    }
-    const linkTypes = /* @__PURE__ */ new Map();
-    const objectTypes = new Set(entities.objectTypesApiNamesToLoad?.map((object) => object.toLowerCase()));
-    const queryTypes = new Set(entities.queryTypesApiNamesToLoad?.map((query) => query.toLowerCase()));
-    const actionTypes = new Set(entities.actionTypesApiNamesToLoad?.map((action) => this.camelize(action).toLowerCase()));
-    const interfaceTypes = new Set(entities.interfaceTypesApiNamesToLoad?.map((interfaceName) => interfaceName.toLowerCase()));
-    for (const linkType of entities.linkTypesApiNamesToLoad ?? []) {
-      const [objectTypeApiName, linkTypeApiName] = linkType.toLowerCase().split(".");
-      if (!linkTypes.has(objectTypeApiName)) {
-        linkTypes.set(objectTypeApiName, /* @__PURE__ */ new Set());
-      }
-      linkTypes.get(objectTypeApiName)?.add(linkTypeApiName);
-    }
-    const filteredFullMetadata = this.filterMetadata(ontologyFullMetadata, {
-      objectTypes,
-      linkTypes,
-      actionTypes,
-      queryTypes,
-      interfaceTypes
-    });
-    const validData = this.validateLoadedOntologyMetadata(filteredFullMetadata, {
-      objectTypes,
-      linkTypes,
-      actionTypes,
-      queryTypes
-    });
-    if (validData.isErr()) {
-      return Result.err(validData.error);
-    }
-    return Result.ok(filteredFullMetadata);
-  }
-  validateLoadedOntologyMetadata(filteredFullMetadata, expectedEntities) {
-    const errors = [];
-    const loadedObjectTypes = Object.fromEntries(Object.values(filteredFullMetadata.objectTypes).map((object) => [object.objectType.apiName.toLowerCase(), object]));
-    const loadedLinkTypes = Object.fromEntries(Object.values(filteredFullMetadata.objectTypes).map((object) => [object.objectType.apiName.toLowerCase(), Object.fromEntries(object.linkTypes.map((link) => [link.apiName.toLowerCase(), link]))]));
-    const missingObjectTypes = [];
-    for (const object of expectedEntities.objectTypes) {
-      if (!loadedObjectTypes[object]) {
-        missingObjectTypes.push(object);
-        continue;
-      }
-      for (const expectedLink of expectedEntities.linkTypes.get(object) ?? []) {
-        if (!loadedLinkTypes[object][expectedLink]) {
-          errors.push(`Unable to find link type ${expectedLink} for Object Type ${object}`);
-        }
-      }
-      for (const [, link] of Object.entries(loadedLinkTypes[object])) {
-        if (!expectedEntities.objectTypes.has(link.objectTypeApiName.toLowerCase())) {
-          errors.push(`Unable to load link type ${link.apiName} for ${loadedObjectTypes[object].objectType.apiName}, because the target object type ${link.objectTypeApiName} is not loaded. Please specify the target Object type with --objectTypes ${link.objectTypeApiName}`);
-        }
-      }
-    }
-    if (missingObjectTypes.length > 0) {
-      errors.push(`Unable to find the following Object Types: ${missingObjectTypes.join()}`);
-    }
-    const loadedQueryTypes = Object.fromEntries(Object.entries(filteredFullMetadata.queryTypes).map(([queryApiName, query]) => [queryApiName.toLowerCase(), query]));
-    const missingQueryTypes = [];
-    for (const queryApiName of expectedEntities.queryTypes) {
-      if (!loadedQueryTypes[queryApiName]) {
-        missingQueryTypes.push(queryApiName);
-      }
-    }
-    for (const query of Object.values(loadedQueryTypes)) {
-      const result = this.validateQueryParametersAndOutput(query, expectedEntities.objectTypes);
-      if (result.isErr()) {
-        for (const errorString of result.error) {
-          errors.push(errorString);
-        }
-      }
-    }
-    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).toLowerCase(), action]));
-    const missingActionTypes = [];
-    for (const actionApiName of expectedEntities.actionTypes) {
-      if (!loadedActionTypes[actionApiName]) {
-        missingActionTypes.push(actionApiName);
-      }
-    }
-    for (const action of Object.values(loadedActionTypes)) {
-      const result = this.validateActionParameters(action, expectedEntities.objectTypes);
-      if (result.isErr()) {
-        for (const errorString of result.error) {
-          errors.push(errorString);
-        }
-      }
-    }
-    if (missingActionTypes.length > 0) {
-      errors.push(`Unable to find the following Action Types: ${missingActionTypes.join()}`);
-    }
-    if (errors.length > 0) {
-      return Result.err(errors);
-    }
-    return Result.ok({});
-  }
-  validateQueryParametersAndOutput(query, loadedObjectApiNames) {
-    const parameterValidation = Object.entries(query.parameters).map(([paramName, paramData]) => this.visitSupportedQueryTypes(query.apiName, paramName, paramData.dataType, loadedObjectApiNames));
-    parameterValidation.push(this.visitSupportedQueryTypes(query.apiName, "output", query.output, loadedObjectApiNames));
-    const results = Result.coalesce(parameterValidation);
-    return results;
-  }
-  validateActionParameters(actionType, loadedObjectApiNames) {
-    const camelizedApiName = this.camelize(actionType.apiName);
-    const parameterValidation = Object.entries(actionType.parameters).map(([_paramName, paramData]) => this.isSupportedActionTypeParameter(camelizedApiName, paramData.dataType, loadedObjectApiNames));
-    return Result.coalesce(parameterValidation);
-  }
-  visitSupportedQueryTypes(queryApiName, propertyName, baseType, loadedObjectApiNames) {
-    switch (baseType.type) {
-      case "array":
-      case "set":
-        return this.visitSupportedQueryTypes(queryApiName, propertyName, baseType.subType, loadedObjectApiNames);
-      case "objectSet":
-      case "object":
-        if (loadedObjectApiNames.has(baseType.objectTypeApiName?.toLowerCase())) {
-          return Result.ok({});
-        }
-        return Result.err([`Unable to load query ${queryApiName} because it takes an unloaded object type as a parameter: ${baseType.objectTypeApiName} in parameter ${propertyName}. Make sure to specify it as an argument with --ontologyObjects ${baseType.objectTypeApiName}.}`]);
-      case "struct":
-        const results = baseType.fields?.map((field) => {
-          return this.visitSupportedQueryTypes(queryApiName, propertyName, field.fieldType, loadedObjectApiNames);
-        });
-        if (!results) {
-          return Result.ok({});
-        }
-        return Result.coalesce(results);
-      case "union":
-        if (baseType.unionTypes.find((unionTypes) => unionTypes.type === "null")) {
-          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 "string":
-      case "boolean":
-      case "attachment":
-      case "date":
-      case "double":
-      case "float":
-      case "integer":
-      case "long":
-      case "threeDimensionalAggregation":
-      case "timestamp":
-      case "twoDimensionalAggregation":
-      case "null":
-        return Result.ok({});
-      case "unsupported":
-      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) {
-    switch (actonTypeParameter.type) {
-      case "array":
-        return this.isSupportedActionTypeParameter(actionApiName, actonTypeParameter.subType, loadedObjectApiNames);
-      case "object":
-        if (loadedObjectApiNames.has(actonTypeParameter.objectTypeApiName?.toLowerCase())) {
-          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})`]);
-      case "objectSet":
-        if (loadedObjectApiNames.has(actonTypeParameter.objectTypeApiName?.toLowerCase())) {
-          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})`]);
-      case "string":
-      case "boolean":
-      case "attachment":
-      case "date":
-      case "double":
-      case "integer":
-      case "long":
-      case "timestamp":
-        return Result.ok({});
-      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.`]);
-    }
-  }
-  camelize(name) {
-    return name.replace(/-./g, (segment) => segment[1].toUpperCase());
-  }
-};
-
-// src/utils/semverUtils.ts
-var semver = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
-function isValidSemver(semverString) {
-  return semver.test(semverString);
-}
-
-// src/utils/UserAgent.ts
-var USER_AGENT = `typescript-sdk-generator/${"2.0.0-beta.9"}`;
-async function createRollupBuild(absolutePackagePath, packageName) {
-  const inputPath = `${absolutePackagePath}/${packageName}/index.js`;
-  const {
-    findUp
-  } = await import('find-up');
-  const nodeModulesPath = await findUp("node_modules", {
-    cwd: __dirname,
-    type: "directory"
-  });
-  return rollup.rollup({
-    input: inputPath,
-    plugins: [pluginNodeResolve.nodeResolve({
-      browser: true,
-      modulePaths: [nodeModulesPath]
-    }), ("default" in commonjs__default.default ? commonjs__default.default.default : commonjs__default.default)({}), ("default" in nodePolyfill__default.default ? nodePolyfill__default.default.default : nodePolyfill__default.default)()],
-    onwarn: (warning, warn) => {
-      if (warning.code === "CIRCULAR_DEPENDENCY") {
-        return;
-      }
-      warn(warning);
-    }
-  });
-}
-async function writeRollupBuild(rollupBuild, absolutePackagePath, packageName, format) {
-  const outputPath = `${absolutePackagePath}/${packageName}/dist/bundle/index.${format}.js`;
-  await Promise.all([rollupBuild.write({
-    file: outputPath,
-    format,
-    name: packageName,
-    amd: {
-      id: packageName
-    },
-    plugins: []
-  })]);
-}
-async function generateEsmBuild(absolutePackagePath, packageName) {
-  const umdBuild = await createRollupBuild(absolutePackagePath, packageName);
-  await writeRollupBuild(umdBuild, absolutePackagePath, packageName, "esm");
-}
-async function generateBundles(absolutePackagePath, packageName) {
-  await Promise.all([generateEsmBuild(absolutePackagePath, packageName)]);
-}
-function withoutTrailingIndex(filePath) {
-  return filePath.endsWith("/index") ? filePath.slice(0, -6) : filePath;
-}
-
-// src/generate/betaClient/copyFiles.ts
-var KNOWN_EXTERNAL = /* @__PURE__ */ new Set(["geojson"]);
-function removeDts(file) {
-  return file.replace(/\.d\.c?ts$/, "");
-}
-async function copyFiles(project, dirs, generatedPackageName, generatedFiles) {
-  const importSet = /* @__PURE__ */ new Set();
-  for (const [fileName, file] of Object.entries(generatedFiles)) {
-    if (!fileName.endsWith(".d.ts") && !fileName.endsWith(".d.cts")) {
-      continue;
-    }
-    const indexOfPackageName = fileName.indexOf(generatedPackageName);
-    const tsPath = removeDts(fileName.slice(indexOfPackageName + generatedPackageName.length));
-    const newModulePath = `${generatedPackageName}${tsPath}`;
-    const sourceFile = project.createSourceFile(newModulePath, file);
-    for (const importDeclaration of sourceFile.getImportDeclarations()) {
-      const moduleSpecifier = importDeclaration.getModuleSpecifier();
-      const newModuleSpecifier = transformModuleSpecifier(moduleSpecifier.getLiteralValue(), newModulePath);
-      moduleSpecifier.setLiteralValue(newModuleSpecifier);
-      if (newModuleSpecifier.startsWith("internal")) {
-        for (const importName of importDeclaration.getNamedImports().map((imp) => imp.getName())) {
-          importSet.add(importName);
-        }
-      }
-    }
-    for (const exportedDecl of sourceFile.getStatements()) {
-      if (tsMorph.Node.isModifierable(exportedDecl)) {
-        exportedDecl.toggleModifier("declare", false);
-      }
-    }
-    for (const exportDeclaration of sourceFile.getExportDeclarations()) {
-      const moduleSpecifier = exportDeclaration.getModuleSpecifier();
-      if (moduleSpecifier) {
-        const newModuleSpecifier = transformModuleSpecifier(moduleSpecifier.getLiteralValue(), newModulePath);
-        moduleSpecifier.setLiteralValue(newModuleSpecifier);
-        if (newModuleSpecifier.startsWith("internal")) {
-          for (const exportName of exportDeclaration.getNamedExports().map((exp) => exp.getName())) {
-            importSet.add(exportName);
-          }
-        }
-      }
-    }
-  }
-  for (const dir of dirs) {
-    const buildDirsToTry = ["build/cjs", "build/esm"];
-    const packageName = getPackageName(dir);
-    const relativeBuildDir = buildDirsToTry.find((buildDir) => {
-      return ["d.ts", "d.cts", "d.mts"].some((ext) => {
-        try {
-          fs__namespace.statSync(path__namespace.join(dir, buildDir, `index.${ext}`));
-          return true;
-        } catch (e) {
-          return false;
-        }
-      });
-    });
-    if (!relativeBuildDir) {
-      throw new Error("Couldn't find the right build dir");
-    }
-    for (const file of getTypeFiles(path__namespace.join(dir, relativeBuildDir))) {
-      const absoluteBuildDir = path__namespace.join(dir, relativeBuildDir);
-      const tsPath = removeDts(path__namespace.relative(absoluteBuildDir, file));
-      const newModulePath = `internal/${packageName}/${tsPath}`;
-      const fileContents = fs__namespace.readFileSync(file).toString();
-      const sourceFile = project.createSourceFile(`${newModulePath}.ts`, fileContents, {
-        overwrite: true
-      });
-      for (const importDeclaration of sourceFile.getImportDeclarations()) {
-        const moduleSpecifier = importDeclaration.getModuleSpecifier();
-        const newModuleSpecifier = transformModuleSpecifier(moduleSpecifier.getLiteralValue(), newModulePath);
-        moduleSpecifier.setLiteralValue(newModuleSpecifier);
-      }
-      for (const exportedDecl of sourceFile.getStatements()) {
-        if (tsMorph.Node.isModifierable(exportedDecl)) {
-          exportedDecl.toggleModifier("declare", false);
-        }
-      }
-      for (const exportDeclaration of sourceFile.getExportDeclarations()) {
-        const moduleSpecifier = exportDeclaration.getModuleSpecifier();
-        if (moduleSpecifier) {
-          const newModuleSpecifier = transformModuleSpecifier(moduleSpecifier.getLiteralValue(), newModulePath);
-          moduleSpecifier.setLiteralValue(withoutTrailingIndex(newModuleSpecifier));
-        }
-      }
-    }
-  }
-  return importSet;
-}
-function getPackageName(dir) {
-  const pkg = fs__namespace.readFileSync(path__namespace.join(dir, "package.json"));
-  const parsed = JSON.parse(pkg.toString());
-  return parsed.name;
-}
-function* getTypeFiles(dir) {
-  for (const item of fs__namespace.readdirSync(dir)) {
-    const target = path__namespace.join(dir, item);
-    if (target.endsWith(".d.ts") && !target.endsWith(".test.d.ts") || target.endsWith(".d.cts") && !target.endsWith(".test.d.cts")) {
-      yield target;
-    } else {
-      const stat = fs__namespace.lstatSync(target);
-      if (stat.isDirectory() && item !== "test") {
-        yield* getTypeFiles(target);
-      }
-    }
-  }
-}
-function transformModuleSpecifier(value, filePath) {
-  let moduleSpecifier;
-  if (value.startsWith("@osdk")) {
-    if (value.startsWith("@osdk/gateway/types")) {
-      moduleSpecifier = `internal/${value.replace("@osdk/gateway/types", "@osdk/gateway/public/types")}`;
-    } else {
-      moduleSpecifier = `internal/${value}`;
-    }
-  } else if (value.startsWith(".")) {
-    moduleSpecifier = path__namespace.join(filePath, "..", value);
-  } else if (KNOWN_EXTERNAL.has(value)) {
-    moduleSpecifier = `internal/${value}`;
-  } else {
-    throw new Error("Failed generated DTS for package, no handling for: " + value);
-  }
-  return withoutTrailingIndex(withoutExtension(moduleSpecifier));
-}
-function withoutExtension(value) {
-  return value.replace(".js", "");
-}
-
-// src/generate/betaClient/bundleDependencies.ts
-async function bundleDependencies(dirs, generatedPackageName, generatedFiles, entry) {
-  const project = new tsMorph.Project({
-    useInMemoryFileSystem: true,
-    compilerOptions: {
-      declaration: true,
-      emitDeclarationOnly: true,
-      outFile: "dist/bundle/index.d.ts"
-    }
-  });
-  await copyFiles(project, dirs, generatedPackageName, generatedFiles);
-  return outputModule(project);
-}
-function outputModule(project) {
-  const modules = [];
-  project.getSourceFiles().forEach((sourceFile) => {
-    const lines = sourceFile.getText().split("\n");
-    while (lines.length > 0 && lines[lines.length - 1] === "") {
-      lines.pop();
-    }
-    if (lines.length === 0) {
-      return;
-    }
-    const module = [];
-    module.push(`/** ${sourceFile.getFilePath()} **/`);
-    module.push(`declare module "${withoutTrailingIndex(sourceFile.getFilePath().replace(".ts", "").replace("/", ""))}" {`);
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.length === 0) {
-        continue;
-      }
-      module.push(`	${line}`);
-    }
-    module.push(`}`);
-    modules.push(module.join("\n"));
-  });
-  return modules.join("\n");
-}
-function compileInMemory(files, opts) {
-  const inMemoryOutputFileSystem = {};
-  const compilerOptions = {
-    module: opts?.esm ? typescript.ModuleKind.NodeNext : typescript.ModuleKind.CommonJS,
-    target: typescript.ScriptTarget.ES2019,
-    declaration: true,
-    skipLibCheck: true
-  };
-  const compilerHost = typescript.createCompilerHost(compilerOptions);
-  compilerHost.writeFile = (fileName, data) => {
-    inMemoryOutputFileSystem[fileName] = data;
-  };
-  const originalSourceFile = compilerHost.getSourceFile;
-  compilerHost.getSourceFile = (fileName, languageVersion) => {
-    const sourceText = files[fileName];
-    return sourceText !== void 0 ? typescript.createSourceFile(fileName, sourceText, languageVersion) : originalSourceFile(fileName, languageVersion);
-  };
-  const program = typescript.createProgram(Object.keys(files), compilerOptions, compilerHost);
-  const emitOutput = program.emit();
-  return {
-    files: inMemoryOutputFileSystem,
-    diagnostics: emitOutput.diagnostics
-  };
-}
-async function generatePackageJson(options) {
-  const packageDeps = options.dependencies?.reduce((acc, value) => {
-    acc[value.dependencyName] = value.dependencyVersion;
-    return acc;
-  }, {});
-  const packageJson = options.beta ? {
-    name: options.packageName,
-    version: options.packageVersion,
-    main: "./index.js",
-    types: "./index.d.ts",
-    exports: {
-      ".": {
-        types: "./index.d.ts",
-        script: {
-          default: "./dist/bundle/index.esm.js"
-        },
-        default: "./index.js"
-      }
-    },
-    dependencies: packageDeps
-  } : {
-    name: options.packageName,
-    version: options.packageVersion,
-    main: "./index.js",
-    types: "./index.d.ts",
-    exports: {
-      ".": {
-        types: "./index.d.ts",
-        script: {
-          types: "./dist/bundle/index.d.ts",
-          default: "./dist/bundle/index.esm.js"
-        },
-        default: "./index.js"
-      },
-      "./ontology/objects": {
-        types: "./ontology/objects/index.d.ts",
-        default: "./ontology/objects/index.js"
-      }
-    },
-    dependencies: packageDeps
-  };
-  await promises.writeFile(path.join(options.packagePath, "package.json"), JSON.stringify(packageJson, void 0, 4));
-}
-
-// src/generate/betaClient/generatePackage.ts
-var betaDependencies = {
-  "@osdk/client.api": typeof __OSDK_CLIENT_API_VERSION__ !== "undefined" ? __OSDK_CLIENT_API_VERSION__ : void 0,
-  "@osdk/api": typeof __OSDK_API_VERSION__ !== "undefined" ? __OSDK_API_VERSION__ : void 0
-};
-async function generatePackage(ontology, options) {
-  const {
-    consola
-  } = await import('consola');
-  const packagePath = path.join(options.outputDir, options.packageName);
-  const resolvedDependencies = await Promise.all(Object.keys(betaDependencies).map(async (dependency) => {
-    return {
-      dependencyName: dependency,
-      dependencyVersion: await getDependencyVersion(dependency)
-    };
-  }));
-  await promises.mkdir(packagePath, {
-    recursive: true
-  });
-  const inMemoryFileSystem = {};
-  const hostFs = {
-    writeFile: async (path2, contents) => {
-      inMemoryFileSystem[path.normalize(path2)] = contents;
-    },
-    mkdir: async (path2, _options) => {
-      await promises.mkdir(path.normalize(path2), {
-        recursive: true
-      });
-    },
-    readdir: (path2) => promises.readdir(path2)
-  };
-  if (!options.beta) {
-    throw new Error("Only beta is supported in this version");
-  } else {
-    await generator.generateClientSdkVersionTwoPointZero(ontology, `typescript-sdk/${options.packageVersion} ${USER_AGENT}`, hostFs, packagePath, "module");
-  }
-  const compilerOutput = compileInMemory(inMemoryFileSystem, {
-    esm: options.beta
-  });
-  compilerOutput.diagnostics.forEach((d) => consola.error(`Error compiling file`, d.file?.fileName, d.messageText));
-  await promises.mkdir(path.join(packagePath, "dist", "bundle"), {
-    recursive: true
-  });
-  const {
-    findUp
-  } = await import('find-up');
-  const nodeModulesPath = await findUp("node_modules", {
-    cwd: __dirname,
-    type: "directory"
-  });
-  let bundleDts = "";
-  if (nodeModulesPath) {
-    try {
-      bundleDts = await bundleDependencies([], options.packageName, compilerOutput.files, void 0);
-    } catch (e) {
-      consola.error("Failed bundling DTS", e);
-    }
-  } else {
-    consola.error("Could not find node_modules directory, skipping DTS bundling");
-  }
-  await Promise.all([...Object.entries(compilerOutput.files).map(async ([path2, contents]) => {
-    await promises.writeFile(path2, contents, {
-      flag: "w"
-    });
-  }), await promises.writeFile(path.join(packagePath, "dist", "bundle", "index.d.ts"), bundleDts, {
-    flag: "w"
-  }), generatePackageJson({
-    packageName: options.packageName,
-    packagePath,
-    packageVersion: options.packageVersion,
-    dependencies: resolvedDependencies,
-    beta: options.beta
-  })]);
-  const absolutePackagePath = path.isAbsolute(options.outputDir) ? options.outputDir : path.join(process.cwd(), options.outputDir);
-  try {
-    await generateBundles(absolutePackagePath, options.packageName);
-  } catch (e) {
-    consola.error(e);
-  }
-}
-async function getDependencyVersion(dependency) {
-  const {
-    findUp
-  } = await import('find-up');
-  const result = await findUp("package.json", {
-    cwd: __dirname
-  });
-  const packageJson = await promises.readFile(result, {
-    encoding: "utf-8"
-  });
-  if (!packageJson) {
-    throw new Error(`Could not find package.json in current working directory: ${process.cwd()}`);
-  }
-  const parsedPackageJson = JSON.parse(packageJson);
-  return parsedPackageJson.dependencies[dependency];
-}
-
-// src/generate/commandUtils.ts
-function transformArrayArg(arg) {
-  if (arg && arg.length > 0) {
-    if (arg[0] === void 0) {
-      return void 0;
-    }
-  }
-  return arg;
-}
-
-// src/generate/GeneratePackageCommand.ts
-var GeneratePackageCommand = class {
-  command = "generatePackage";
-  describe = "Generates a new npm package which can be published";
-  constructor() {
-  }
-  builder(args) {
-    return args.positional("authToken", {
-      type: "string",
-      demandOption: true
-    }).positional("foundryHostname", {
-      type: "string",
-      demandOption: true
-    }).positional("packageName", {
-      type: "string",
-      demandOption: true,
-      description: "The name of the package to generate"
-    }).positional("packageVersion", {
-      type: "string",
-      demandOption: true,
-      description: "The version of the package to generate"
-    }).positional("outputDir", {
-      type: "string",
-      demandOption: true,
-      description: "The path where the package with the provided package name will be generated"
-    }).positional("ontology", {
-      type: "string",
-      demandOption: true,
-      description: `The ontology rid or ontology API name of the ontology to generate. Example Usage: --ontology palantirOntology`,
-      default: "ri.ontology.main.ontology.00000000-0000-0000-0000-000000000000"
-    }).options("objectTypes", {
-      array: true,
-      string: true,
-      demandOption: false,
-      description: `The API names of the object types to generate. Example Usage: --objectTypes Aircraft Airport`,
-      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: 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: 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: 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: 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: void 0,
-      defaultDescription: `By default, no arguments will not enable any experimental features.`
-    }).options("beta", {
-      boolean: true,
-      demandOption: false,
-      hidden: true,
-      default: false
-    }).options("sdkPackages", {
-      array: true,
-      string: true,
-      // experimental for now
-      hidden: true
-    }).strict();
-  }
-  handler = async (args) => {
-    const {
-      consola
-    } = await import('consola');
-    consola.start(`Generating OSDK: ${args.packageName} at version: ${args.packageVersion}`);
-    const ontologyRid = args.ontology;
-    const ontologyMetadataResolver = new OntologyMetadataResolver(args.authToken, args.foundryHostname);
-    if (!isValidSemver(args.packageVersion)) {
-      consola.error(new Error(`Invalid argument provided for packageVersion: ${args.packageVersion}, expected valid semver`));
-      process$1.exit(1);
-    }
-    const timeStart = Date.now();
-    const wireOntologyDefinition = await ontologyMetadataResolver.getWireOntologyDefinition(ontologyRid, {
-      objectTypesApiNamesToLoad: transformArrayArg(args.objectTypes),
-      actionTypesApiNamesToLoad: transformArrayArg(args.actionTypes),
-      queryTypesApiNamesToLoad: transformArrayArg(args.queryTypes),
-      interfaceTypesApiNamesToLoad: transformArrayArg(args.interfaceTypes),
-      linkTypesApiNamesToLoad: transformArrayArg(args.linkTypes)
-    });
-    if (wireOntologyDefinition.isErr()) {
-      wireOntologyDefinition.error.forEach((err) => {
-        consola.error(err);
-      });
-      consola.error("Failed generating package");
-      process$1.exit(1);
-    }
-    await generatePackage(wireOntologyDefinition.value, {
-      packageName: args.packageName,
-      packageVersion: args.packageVersion,
-      outputDir: args.outputDir,
-      beta: !!args.beta
-    });
-    const elapsedTime = Date.now() - timeStart;
-    consola.success(`Finished generating package in ${(elapsedTime / 1e3).toFixed(2)}s`);
-    return;
-  };
-};
-
-// src/cli/foundrySdkGeneratorCli.ts
-async function cli(args = process.argv) {
-  const base = yargs__default.default(helpers.hideBin(args)).command(new GeneratePackageCommand()).demandCommand().recommendCommands().strict().showHelpOnFail(true).help().version(process.env.npm_package_version);
-  try {
-    return base.parseAsync();
-  } catch (e) {
-    console.log(e);
-  }
-}
-
-exports.__testSeamOnly_NotSemverStable__GeneratePackageCommand = GeneratePackageCommand;
-exports.cli = cli;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map