@storm-software/k8s-tools 0.18.0 → 0.19.1

package/dist/chunk-W7DPLC4K.mjs

@@ -0,0 +1,184 @@
+import {
+  ProjectTagConstants,
+  getPackageInfo,
+  hasProjectTag,
+  isEqualProjectTag,
+  setDefaultProjectTags
+} from "./chunk-RVFKH45R.mjs";
+import {
+  findWorkspaceRoot,
+  loadStormConfig
+} from "./chunk-DZ5UCMNL.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/plugins/docker/_dockerfile.ts
+import { joinPathFragments, readJsonFile } from "@nx/devkit";
+import { existsSync } from "node:fs";
+var name = "storm-software/docker";
+var description = "Plugin for parsing Dockerfile files";
+var createNodes = [
+  "*/**/{Dockerfile,Dockerfile.*}",
+  async (dockerFilePath, opts = {
+    defaultEngine: "docker"
+  }, _) => {
+    if (!dockerFilePath) {
+      return {};
+    }
+    const root = dockerFilePath.substring(dockerFilePath.lastIndexOf("/") + 1);
+    const projectJsonPath = joinPathFragments(root, "project.json");
+    if (!existsSync(projectJsonPath)) {
+      return {};
+    }
+    const projectJson = readJsonFile(projectJsonPath);
+    if (projectJson?.name) {
+      return {};
+    }
+    const workspaceRoot = findWorkspaceRoot();
+    const config = await loadStormConfig(workspaceRoot);
+    Object.keys(projectJson).forEach((key) => {
+      if (!project[key]) {
+        project[key] = projectJson[key];
+      }
+    });
+    const project = {
+      root,
+      name: projectJson?.name
+    };
+    const engine = opts.defaultEngine ?? "docker";
+    const labels = [
+      `org.opencontainers.image.ref.name=${project.name}`,
+      `org.opencontainers.image.title=${titleCase(project.name)}`,
+      `org.opencontainers.image.authors=${config.organization ? titleCase(config.organization) : "Storm Software"}`,
+      `org.opencontainers.image.vendor=${config.organization ? titleCase(config.organization) : "Storm Software"}`,
+      `org.opencontainers.image.documentation=${config.docs}`,
+      `org.opencontainers.image.url=${config.homepage}`,
+      `org.opencontainers.image.source=${config.repository}`
+    ];
+    let tag = "latest";
+    const packageManager = getPackageInfo(project);
+    if (packageManager) {
+      if (packageManager.type === "Cargo.toml") {
+        tag = packageManager.content.package.version;
+        labels.push(`org.opencontainers.image.description=${packageManager.content.package.description}`);
+      } else if (packageManager.type === "package.json") {
+        tag = packageManager.content.version;
+        labels.push(`org.opencontainers.image.description=${packageManager.content.description}`);
+      }
+    }
+    project.targets = {
+      ...project.targets,
+      container: {
+        executor: "@nx-tools/nx-container:build",
+        options: {
+          file: dockerFilePath,
+          engine,
+          labels,
+          push: true,
+          platforms: [
+            "linux/amd64"
+          ],
+          metadata: {
+            images: [
+              `${config.namespace ? config.namespace : "storm-software"}/${project.name?.replace(`${config.namespace}-`, "")}`,
+              `ghcr.io/${config.organization ? config.organization : "storm-software"}/${project.name}`
+            ],
+            tags: [
+              "type=schedule",
+              "type=ref,event=branch",
+              "type=ref,event=tag",
+              "type=ref,event=pr",
+              "type=semver,pattern={{version}}",
+              "type=semver,pattern={{major}}.{{minor}}",
+              "type=semver,pattern={{major}}",
+              "type=sha"
+            ]
+          }
+        },
+        defaultConfiguration: "production",
+        configurations: {
+          development: {
+            quiet: false,
+            "build-args": [
+              "ENVIRONMENT=development",
+              "DEBUG_IMAGE=true",
+              `RELEASE=${tag}`
+            ]
+          },
+          production: {
+            quiet: true,
+            "build-args": [
+              "ENVIRONMENT=production",
+              "DEBUG_IMAGE=false",
+              `RELEASE=${tag}`
+            ]
+          }
+        }
+      }
+    };
+    if ((isEqualProjectTag(project, ProjectTagConstants.ProjectType.TAG_ID, ProjectTagConstants.ProjectType.APPLICATION) || project.projectType === "application") && hasProjectTag(project, ProjectTagConstants.Registry.TAG_ID)) {
+      if (project.targets["nx-release-publish"]) {
+        project.targets["nx-release-publish"] = {
+          ...project.targets["nx-release-publish"],
+          executor: "@storm-software/k8s-tools:container-publish",
+          options: {
+            packageRoot: project.root
+          }
+        };
+      } else {
+        project.targets["nx-release-publish"] = {
+          cache: true,
+          inputs: [
+            "linting",
+            "testing",
+            "documentation",
+            "rust",
+            "^production"
+          ],
+          dependsOn: [
+            "build",
+            "^nx-release-publish"
+          ],
+          executor: "@storm-software/k8s-tools:container-publish",
+          options: {
+            packageRoot: project.root
+          }
+        };
+      }
+    }
+    setDefaultProjectTags(project);
+    const projects = {};
+    const externalNodes = {};
+    projects[project.root] = {
+      ...project,
+      release: {
+        ...project.release,
+        version: {
+          ...project.release?.version,
+          generator: "@storm-software/workspace-tools:release-version"
+        }
+      }
+    };
+    return {
+      projects,
+      externalNodes
+    };
+  }
+];
+var createDependencies = /* @__PURE__ */ __name((_, context) => {
+  return [];
+}, "createDependencies");
+var titleCase = /* @__PURE__ */ __name((input) => {
+  if (!input) {
+    return "";
+  }
+  return input.split(/(?=[A-Z])|[\.\-\s_]/).map((s) => s.trim()).filter((s) => !!s).map((s) => s ? s.toLowerCase().charAt(0).toUpperCase() + s.toLowerCase().slice(1) : s).join(" ");
+}, "titleCase");
+
+export {
+  name,
+  description,
+  createNodes,
+  createDependencies
+};

package/dist/chunk-XMPMWMWQ.js

@@ -0,0 +1,147 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkUWJTAL4Wjs = require('./chunk-UWJTAL4W.js');
+
+
+var _chunkIOT45LXVjs = require('./chunk-IOT45LXV.js');
+
+
+var _chunkAFPEYAYKjs = require('./chunk-AFPEYAYK.js');
+
+
+
+var _chunkGDXB64KGjs = require('./chunk-GDXB64KG.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/executors/container-publish/executor.ts
+var _devkit = require('@nx/devkit');
+var _https = require('https'); var _https2 = _interopRequireDefault(_https);
+async function* publishExecutor(options, context) {
+  const isDryRun = process.env.NX_DRY_RUN === "true" || options.dryRun || false;
+  if (!context.projectName) {
+    throw new Error("The executor requires a projectName.");
+  }
+  console.info(`\u{1F680}  Running Storm Container Registry Publish executor on the ${context.projectName} crate`);
+  const workspaceRoot = _chunkGDXB64KGjs.findWorkspaceRoot.call(void 0, );
+  const config = await _chunkGDXB64KGjs.loadStormConfig.call(void 0, workspaceRoot);
+  const projectConfig = _optionalChain([context, 'access', _ => _.projectsConfigurations, 'optionalAccess', _2 => _2.projects, 'access', _3 => _3[context.projectName]]);
+  if (!projectConfig) {
+    throw new Error(`The executor requires a valid projectsConfiguration - No configuration found for project ${context.projectName}`);
+  }
+  const projectRoot = _nullishCoalesce(_optionalChain([projectConfig, 'optionalAccess', _4 => _4.root]), () => ( workspaceRoot));
+  const sourceRoot = _nullishCoalesce(_optionalChain([projectConfig, 'optionalAccess', _5 => _5.sourceRoot]), () => ( workspaceRoot));
+  const projectName = _nullishCoalesce(_optionalChain([projectConfig, 'optionalAccess', _6 => _6.name]), () => ( context.projectName));
+  config.workspaceRoot = workspaceRoot;
+  const tokenized = await _chunkAFPEYAYKjs.applyWorkspaceTokens.call(void 0, options, {
+    config,
+    workspaceRoot,
+    projectRoot,
+    sourceRoot,
+    projectName,
+    ...projectConfig
+  }, _chunkUWJTAL4Wjs.applyWorkspaceExecutorTokens);
+  tokenized.engine ??= "docker";
+  tokenized.registry ??= config.registry.container;
+  try {
+    if (isDryRun) {
+      console.log(`Would publish to ${tokenized.registry}, but [dry-run] was set`);
+    } else {
+      console.log(`Published to ${tokenized.registry}`);
+      const packageManager = _chunkIOT45LXVjs.getPackageInfo.call(void 0, projectConfig);
+      if (packageManager) {
+        tokenized["build-args"] ??= [
+          "ENVIRONMENT=production",
+          "DEBUG_IMAGE=false"
+        ];
+        tokenized["labels"] ??= [];
+        let version = "";
+        if (process.env.TAG) {
+          version = process.env.TAG;
+        } else {
+          if (packageManager.type === "Cargo.toml") {
+            version = packageManager.content.package.version;
+          } else if (packageManager.type === "package.json") {
+            version = packageManager.content.version;
+          }
+        }
+        tokenized["build-args"].push(`RELEASE=${version}`);
+        tokenized["labels"].push(`org.opencontainers.image.version=${version}`);
+        const tags = await getRegistryVersion(projectName, config);
+        if (tags.length === 0) {
+          tokenized["labels"].push(`org.opencontainers.image.created=${(/* @__PURE__ */ new Date()).toISOString()}`);
+        } else if (tags.includes(version)) {
+          console.warn(`Skipped package "${projectName}" because v${version} already exists in ${tokenized.registry}`);
+          return {
+            success: true
+          };
+        }
+      } else {
+        console.warn(`No package manager found for project "${projectName}" - Skipping container publishing`);
+        return {
+          success: true
+        };
+      }
+      const { project, target, configuration } = _devkit.parseTargetString.call(void 0, "container", context);
+      for await (const output of await _devkit.runExecutor.call(void 0, {
+        project,
+        target,
+        configuration
+      }, tokenized, context)) {
+        if (!output.success) {
+          throw new Error("Could not compile application files");
+        }
+        yield;
+      }
+    }
+    return {
+      success: true
+    };
+  } catch (error) {
+    console.error(`Failed to publish to ${tokenized.registry}`);
+    console.error(error);
+    console.log("");
+    return {
+      success: false
+    };
+  }
+}
+_chunk3GQAWCBQjs.__name.call(void 0, publishExecutor, "publishExecutor");
+var getRegistryVersion = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (name, config) => {
+  if (!name) {
+    throw new Error("The `getRegistryVersion` function requires a container name.");
+  }
+  try {
+    const tagsApiUrl = `${config.registry.container}/v2/namespaces/${encodeURIComponent(config.namespace ? config.namespace : "storm-software")}/repositories/${encodeURIComponent(name.replace(`${config.namespace}-`, ""))}/tags`;
+    console.log(`Checking for existing version at ${tagsApiUrl}`);
+    return new Promise((resolve, reject) => _https2.default.get(tagsApiUrl, (res) => {
+      if (res.statusCode === 404) {
+        console.log(`No existing version found at ${tagsApiUrl}`);
+        return resolve([]);
+      }
+      res.on("data", (data) => {
+        if (data) {
+          console.log(`Existing versions found at ${tagsApiUrl} - ${data}`);
+          const json = JSON.parse(data.toString());
+          return resolve(json.results.filter((result) => result.status === "active" && result.name && result.name !== "latest").map((result) => result.name));
+        }
+        return reject(new Error("No data returned from container registry, expected a 404 if no tags exist"));
+      });
+    }).on("error", (e) => {
+      throw e;
+    }));
+  } catch (error) {
+    console.error(`Failed to get version from ${config.registry.container}`);
+    console.error(error);
+    console.log("");
+    throw new Error(`Could not get version from container registry - ${config.registry.container}`, {
+      cause: error
+    });
+  }
+}, "getRegistryVersion");
+
+
+
+
+exports.publishExecutor = publishExecutor; exports.getRegistryVersion = getRegistryVersion;

package/dist/chunk-XO66D74Z.js

@@ -0,0 +1 @@
+"use strict";

package/dist/chunk-XUV4U54K.mjs

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// ../../node_modules/.pnpm/tsup@8.3.5_@microsoft+api-extractor@7.49.1_@types+node@22.10.7__@swc+core@1.7.26_@swc+helpers_ekim6y52mwpq6ssxiprcp44dam/node_modules/tsup/assets/esm_shims.js
+import { fileURLToPath } from "url";
+import path from "path";
+var getFilename = /* @__PURE__ */ __name(() => fileURLToPath(import.meta.url), "getFilename");
+var getDirname = /* @__PURE__ */ __name(() => path.dirname(getFilename()), "getDirname");
+var __dirname = /* @__PURE__ */ getDirname();
+
+export {
+  __name,
+  __require,
+  __dirname
+};

package/dist/chunk-ZO7MGNKJ.mjs

@@ -0,0 +1,61 @@
+import {
+  findWorkspaceRoot
+} from "./chunk-DZ5UCMNL.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// ../config-tools/src/utilities/apply-workspace-tokens.ts
+var applyWorkspaceBaseTokens = /* @__PURE__ */ __name(async (option, tokenizerOptions) => {
+  let result = option;
+  if (!result) {
+    return result;
+  }
+  if (tokenizerOptions) {
+    const optionKeys = Object.keys(tokenizerOptions);
+    if (optionKeys.some((optionKey) => result.includes(`{${optionKey}}`))) {
+      for (const optionKey of optionKeys) {
+        if (result.includes(`{${optionKey}}`)) {
+          result = result.replaceAll(`{${optionKey}}`, tokenizerOptions.config?.[optionKey] ?? "");
+        }
+      }
+    }
+  }
+  if (tokenizerOptions.config) {
+    const configKeys = Object.keys(tokenizerOptions.config);
+    if (configKeys.some((configKey) => result.includes(`{${configKey}}`))) {
+      for (const configKey of configKeys) {
+        if (result.includes(`{${configKey}}`)) {
+          result = result.replaceAll(`{${configKey}}`, tokenizerOptions.config[configKey]);
+        }
+      }
+    }
+  }
+  if (result.includes("{workspaceRoot}")) {
+    result = result.replaceAll("{workspaceRoot}", tokenizerOptions.workspaceRoot ?? tokenizerOptions.config?.workspaceRoot ?? findWorkspaceRoot());
+  }
+  return result;
+}, "applyWorkspaceBaseTokens");
+var applyWorkspaceTokens = /* @__PURE__ */ __name(async (options, config, tokenizerFn) => {
+  if (!options) {
+    return {};
+  }
+  const result = {};
+  for (const option of Object.keys(options)) {
+    if (typeof options[option] === "string") {
+      result[option] = await Promise.resolve(tokenizerFn(options[option], config));
+    } else if (Array.isArray(options[option])) {
+      result[option] = await Promise.all(options[option].map(async (item) => typeof item === "string" ? await Promise.resolve(tokenizerFn(item, config)) : item));
+    } else if (typeof options[option] === "object") {
+      result[option] = await applyWorkspaceTokens(options[option], config, tokenizerFn);
+    } else {
+      result[option] = options[option];
+    }
+  }
+  return result;
+}, "applyWorkspaceTokens");
+
+export {
+  applyWorkspaceBaseTokens,
+  applyWorkspaceTokens
+};

package/dist/executor-DY-z8MOl.d.mts

@@ -0,0 +1,53 @@
+import { ExecutorContext, PromiseExecutor } from '@nx/devkit';
+import { S as StormConfig } from './types-CIJRaFHD.mjs';
+
+// Generated by @storm-software/untyped
+// Do not edit this file directly
+
+interface BaseExecutorSchema {
+ /**
+  * Output Path
+  * 
+  * The output path for the build
+  * 
+  * @default "dist/{projectRoot}"
+  * 
+  * @format path
+ */
+ outputPath?: string,
+}
+
+interface HelmPackageExecutorSchema extends BaseExecutorSchema {
+  /** Folder where the chart is stored */
+  chartFolder: string;
+  /** Folder to store the packaged chart */
+  outputFolder: string;
+  /** Push the chart to a remote registry */
+  push?: boolean;
+  /** Remote registry to publish the chart */
+  remote?: string;
+  /** Options related to dependencies */
+  dependencies?: {
+    /** Runs `helm dependency update` before packaging */
+    update?: boolean;
+    /** Runs `helm dependency build` before packaging */
+    build?: boolean;
+    /** List of repositories to add with `helm repo add` before packaging */
+    repositories?: {
+      /** Name of the repository */
+      name?: string;
+      /** URL of the repository */
+      url?: string;
+      [k: string]: unknown;
+    }[];
+    [k: string]: unknown;
+  };
+  [k: string]: unknown;
+}
+
+declare function serveExecutor(options: HelmPackageExecutorSchema, context: ExecutorContext, config?: StormConfig): Promise<{
+    success: boolean;
+}>;
+declare const _default: PromiseExecutor<HelmPackageExecutorSchema>;
+
+export { type HelmPackageExecutorSchema as H, _default as _, serveExecutor as s };

package/dist/executor-Dr6UXfvX.d.ts

@@ -0,0 +1,53 @@
+import { ExecutorContext, PromiseExecutor } from '@nx/devkit';
+import { S as StormConfig } from './types-CIJRaFHD.js';
+
+// Generated by @storm-software/untyped
+// Do not edit this file directly
+
+interface BaseExecutorSchema {
+ /**
+  * Output Path
+  * 
+  * The output path for the build
+  * 
+  * @default "dist/{projectRoot}"
+  * 
+  * @format path
+ */
+ outputPath?: string,
+}
+
+interface HelmPackageExecutorSchema extends BaseExecutorSchema {
+  /** Folder where the chart is stored */
+  chartFolder: string;
+  /** Folder to store the packaged chart */
+  outputFolder: string;
+  /** Push the chart to a remote registry */
+  push?: boolean;
+  /** Remote registry to publish the chart */
+  remote?: string;
+  /** Options related to dependencies */
+  dependencies?: {
+    /** Runs `helm dependency update` before packaging */
+    update?: boolean;
+    /** Runs `helm dependency build` before packaging */
+    build?: boolean;
+    /** List of repositories to add with `helm repo add` before packaging */
+    repositories?: {
+      /** Name of the repository */
+      name?: string;
+      /** URL of the repository */
+      url?: string;
+      [k: string]: unknown;
+    }[];
+    [k: string]: unknown;
+  };
+  [k: string]: unknown;
+}
+
+declare function serveExecutor(options: HelmPackageExecutorSchema, context: ExecutorContext, config?: StormConfig): Promise<{
+    success: boolean;
+}>;
+declare const _default: PromiseExecutor<HelmPackageExecutorSchema>;
+
+export { type HelmPackageExecutorSchema as H, _default as _, serveExecutor as s };

package/dist/executors.d.mts

@@ -0,0 +1,6 @@
+export { getRegistryVersion } from './src/executors/container-publish/executor.mjs';
+export { C as ContainerPublishExecutorSchema } from './schema.d-Cx_3iG9A.mjs';
+export { H as HelmPackageExecutorSchema, s as serveExecutor } from './executor-DY-z8MOl.mjs';
+import '@nx/devkit';
+import './types-CIJRaFHD.mjs';
+import 'zod';

package/dist/executors.d.ts

@@ -0,0 +1,6 @@
+export { getRegistryVersion } from './src/executors/container-publish/executor.js';
+export { C as ContainerPublishExecutorSchema } from './schema.d-Cx_3iG9A.js';
+export { H as HelmPackageExecutorSchema, s as serveExecutor } from './executor-Dr6UXfvX.js';
+import '@nx/devkit';
+import './types-CIJRaFHD.js';
+import 'zod';

package/dist/executors.js

@@ -0,0 +1,19 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('./chunk-XO66D74Z.js');
+
+
+var _chunkXMPMWMWQjs = require('./chunk-XMPMWMWQ.js');
+
+
+var _chunkEISL3C34js = require('./chunk-EISL3C34.js');
+require('./chunk-UWJTAL4W.js');
+require('./chunk-IOT45LXV.js');
+require('./chunk-AFPEYAYK.js');
+require('./chunk-GDXB64KG.js');
+require('./chunk-2GAU2GHG.js');
+require('./chunk-LFNGKV6F.js');
+require('./chunk-EAQFLLRB.js');
+require('./chunk-3GQAWCBQ.js');
+
+
+
+exports.getRegistryVersion = _chunkXMPMWMWQjs.getRegistryVersion; exports.serveExecutor = _chunkEISL3C34js.serveExecutor;

package/dist/executors.mjs

@@ -0,0 +1,19 @@
+import "./chunk-YSCEY447.mjs";
+import {
+  getRegistryVersion
+} from "./chunk-Q6DDBFXE.mjs";
+import {
+  serveExecutor
+} from "./chunk-7AV2CVBT.mjs";
+import "./chunk-OBT35QXS.mjs";
+import "./chunk-RVFKH45R.mjs";
+import "./chunk-ZO7MGNKJ.mjs";
+import "./chunk-DZ5UCMNL.mjs";
+import "./chunk-6V45YKVB.mjs";
+import "./chunk-UDLI3L7V.mjs";
+import "./chunk-OA63SGD6.mjs";
+import "./chunk-XUV4U54K.mjs";
+export {
+  getRegistryVersion,
+  serveExecutor
+};

package/dist/generator-B5bCfIUV.d.ts

@@ -0,0 +1,24 @@
+import { B as BaseGeneratorSchema, a as BaseGeneratorResult } from './types-BCBFBwnJ.js';
+import * as _nx_devkit from '@nx/devkit';
+import { Tree } from '@nx/devkit';
+import { S as StormConfig } from './types-CIJRaFHD.js';
+
+interface HelmChartGeneratorSchema extends BaseGeneratorSchema {
+  /** Name of the chart */
+  name: string;
+  /** Name of the project to add the chart to */
+  project: string;
+  /** Folder to store the chart */
+  chartFolder?: string;
+  /** Format the generated chart */
+  format?: boolean;
+
+  [k: string]: unknown;
+}
+
+declare function helmChartGeneratorFn(tree: Tree, options: HelmChartGeneratorSchema, config?: StormConfig): Promise<{
+    success: boolean;
+}>;
+declare const _default: (tree: Tree, _options: HelmChartGeneratorSchema) => Promise<_nx_devkit.GeneratorCallback | BaseGeneratorResult>;
+
+export { type HelmChartGeneratorSchema as H, _default as _, helmChartGeneratorFn as h };

package/dist/generator-BIe65kKR.d.mts

@@ -0,0 +1,28 @@
+import { B as BaseGeneratorSchema, a as BaseGeneratorResult } from './types-BCBFBwnJ.mjs';
+import * as _nx_devkit from '@nx/devkit';
+import { Tree } from '@nx/devkit';
+import { S as StormConfig } from './types-CIJRaFHD.mjs';
+
+interface HelmDependencyGeneratorSchema extends BaseGeneratorSchema {
+  /** Project name */
+  project: string;
+  /** Chart Name of the Dependency */
+  chartName?: string;
+  /** Chart Version of the Dependency */
+  chartVersion?: string;
+  /** Repository of the Dependency */
+  repository: string;
+  /** Repository Name of the Dependency */
+  repositoryName: string;
+  /** Format the generated files */
+  format?: boolean;
+
+  [k: string]: unknown;
+}
+
+declare function helmDependencyGeneratorFn(tree: Tree, options: HelmDependencyGeneratorSchema, config?: StormConfig): Promise<{
+    success: boolean;
+}>;
+declare const _default: (tree: Tree, _options: HelmDependencyGeneratorSchema) => Promise<_nx_devkit.GeneratorCallback | BaseGeneratorResult>;
+
+export { type HelmDependencyGeneratorSchema as H, _default as _, helmDependencyGeneratorFn as h };

package/dist/generator-Cad7bXVB.d.mts

@@ -0,0 +1,24 @@
+import { B as BaseGeneratorSchema, a as BaseGeneratorResult } from './types-BCBFBwnJ.mjs';
+import * as _nx_devkit from '@nx/devkit';
+import { Tree } from '@nx/devkit';
+import { S as StormConfig } from './types-CIJRaFHD.mjs';
+
+interface HelmChartGeneratorSchema extends BaseGeneratorSchema {
+  /** Name of the chart */
+  name: string;
+  /** Name of the project to add the chart to */
+  project: string;
+  /** Folder to store the chart */
+  chartFolder?: string;
+  /** Format the generated chart */
+  format?: boolean;
+
+  [k: string]: unknown;
+}
+
+declare function helmChartGeneratorFn(tree: Tree, options: HelmChartGeneratorSchema, config?: StormConfig): Promise<{
+    success: boolean;
+}>;
+declare const _default: (tree: Tree, _options: HelmChartGeneratorSchema) => Promise<_nx_devkit.GeneratorCallback | BaseGeneratorResult>;
+
+export { type HelmChartGeneratorSchema as H, _default as _, helmChartGeneratorFn as h };