@storm-software/k8s-tools 0.0.1

package/packages/config/src/types.d.ts

@@ -0,0 +1,23 @@
+import type z from "zod";
+import type { ColorConfigMapSchema, ColorConfigSchema, DarkThemeColorConfigSchema, LightThemeColorConfigSchema, MultiThemeColorConfigSchema, SingleThemeColorConfigSchema, StormConfigSchema } from "./schema";
+export type DarkThemeColorConfig = z.infer<typeof DarkThemeColorConfigSchema>;
+export type DarkThemeColorConfigInput = z.input<typeof DarkThemeColorConfigSchema>;
+export type LightThemeColorConfig = z.infer<typeof LightThemeColorConfigSchema>;
+export type LightThemeColorConfigInput = z.input<typeof LightThemeColorConfigSchema>;
+export type MultiThemeColorConfig = z.infer<typeof MultiThemeColorConfigSchema>;
+export type MultiThemeColorConfigInput = z.input<typeof MultiThemeColorConfigSchema>;
+export type SingleThemeColorConfig = z.infer<typeof SingleThemeColorConfigSchema>;
+export type SingleThemeColorConfigInput = z.input<typeof SingleThemeColorConfigSchema>;
+export type ColorConfig = z.infer<typeof ColorConfigSchema>;
+export type ColorConfigInput = z.input<typeof ColorConfigSchema>;
+export type ColorConfigMap = z.infer<typeof ColorConfigMapSchema>;
+export type ColorConfigMapInput = z.input<typeof ColorConfigMapSchema>;
+type TStormConfig = z.infer<typeof StormConfigSchema>;
+export type StormConfigInput = z.input<typeof StormConfigSchema>;
+export type StormConfig<TExtensionName extends keyof TStormConfig["extensions"] = keyof TStormConfig["extensions"], TExtensionConfig extends TStormConfig["extensions"][TExtensionName] = TStormConfig["extensions"][TExtensionName]> = TStormConfig & {
+    extensions?: (TStormConfig["extensions"] & {
+        [extensionName in TExtensionName]: TExtensionConfig;
+    }) | Record<string, any>;
+};
+export declare const COLOR_KEYS: string[];
+export {};

package/packages/config-tools/src/config-file/get-config-file.d.ts

@@ -0,0 +1,16 @@
+import type { StormConfigInput } from "@storm-software/config";
+import { ResolvedConfig, type LoadConfigOptions } from "c12";
+/**
+ * Get the config file for the current Storm workspace
+ *
+ * @param fileName - The name of the config file to search for
+ * @param filePath - The path to search for the config file in
+ * @returns The config file for the current Storm workspace
+ */
+export declare const getConfigFileByName: (fileName: string, filePath?: string, options?: LoadConfigOptions<Partial<StormConfigInput>>) => Promise<ResolvedConfig<Partial<StormConfigInput>>>;
+/**
+ * Get the config file for the current Storm workspace
+ *
+ * @returns The config file for the current Storm workspace
+ */
+export declare const getConfigFile: (filePath?: string, additionalFileNames?: string[]) => Promise<Partial<StormConfigInput> | undefined>;

package/packages/config-tools/src/config-file/index.d.ts

@@ -0,0 +1 @@
+export * from "./get-config-file";

package/packages/config-tools/src/create-storm-config.d.ts

@@ -0,0 +1,26 @@
+import type { StormConfig } from "@storm-software/config";
+import type { ZodTypeAny } from "zod";
+/**
+ * Get the config for the current Storm workspace
+ *
+ * @returns The config for the current Storm workspace
+ */
+export declare const createConfig: (workspaceRoot?: string) => StormConfig;
+/**
+ * Get the config for the current Storm workspace
+ *
+ * @returns The config for the current Storm workspace
+ */
+export declare const createStormConfig: <TExtensionName extends keyof StormConfig["extensions"] = string, TExtensionConfig = any, TExtensionSchema extends ZodTypeAny = ZodTypeAny>(extensionName?: TExtensionName, schema?: TExtensionSchema, workspaceRoot?: string) => StormConfig<TExtensionName, TExtensionConfig>;
+/**
+ * Get the config for a specific Storm config Extension
+ *
+ * @param extensionName - The name of the config extension
+ * @param options - The options for the config extension
+ * @returns The config for the specified Storm config extension. If the extension does not exist, `undefined` is returned.
+ */
+export declare const createConfigExtension: <TExtensionName extends keyof StormConfig["extensions"] = string, TExtensionConfig = any, TExtensionSchema extends ZodTypeAny = ZodTypeAny>(extensionName: TExtensionName, schema: TExtensionSchema) => TExtensionConfig;
+/**
+ * Load the config file values for the current Storm workspace into environment variables
+ */
+export declare const loadStormConfig: (workspaceRoot?: string) => Promise<StormConfig>;

package/packages/config-tools/src/env/get-env.d.ts

@@ -0,0 +1,15 @@
+import { type StormConfig } from "@storm-software/config";
+import type { DeepPartial } from "../../declarations.d";
+/**
+ * Get the config for an extension module of Storm workspace from environment variables
+ *
+ * @param extensionName - The name of the extension module
+ * @returns The config for the specified Storm extension module. If the module does not exist, `undefined` is returned.
+ */
+export declare const getExtensionEnv: <TConfig extends Record<string, any> = Record<string, any>>(extensionName: string) => TConfig | undefined;
+/**
+ * Get the config for the current Storm workspace
+ *
+ * @returns The config for the current Storm workspace from environment variables
+ */
+export declare const getConfigEnv: () => DeepPartial<StormConfig>;

package/packages/config-tools/src/env/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./get-env";
+export * from "./set-env";

package/packages/config-tools/src/env/set-env.d.ts

@@ -0,0 +1,14 @@
+import type { StormConfig } from "@storm-software/config";
+/**
+ * Get the config for an extension module of Storm workspace from environment variables
+ *
+ * @param extensionName - The name of the extension module
+ * @returns The config for the specified Storm extension module. If the module does not exist, `undefined` is returned.
+ */
+export declare const setExtensionEnv: <TConfig extends Record<string, any> = Record<string, any>>(extensionName: string, extension: TConfig) => void;
+/**
+ * Get the config for the current Storm workspace
+ *
+ * @returns The config for the current Storm workspace from environment variables
+ */
+export declare const setConfigEnv: (config: StormConfig) => void;

package/packages/config-tools/src/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The config-tools library used by Storm Software for building TypeScript applications.
+ *
+ * @remarks
+ * A package containing various utilities to support custom workspace configurations
+ *
+ * @packageDocumentation
+ */
+export * from "./config-file";
+export * from "./create-storm-config";
+export * from "./env";
+export * from "./types";
+export * from "./utilities";

package/packages/config-tools/src/types.d.ts

@@ -0,0 +1,33 @@
+import type { StormConfig } from "@storm-software/config";
+export type LogLevel = 0 | 10 | 20 | 30 | 35 | 40 | 60 | 70 | 100;
+export declare const LogLevel: {
+    readonly SILENT: LogLevel;
+    readonly FATAL: LogLevel;
+    readonly ERROR: LogLevel;
+    readonly WARN: LogLevel;
+    readonly SUCCESS: LogLevel;
+    readonly INFO: LogLevel;
+    readonly DEBUG: LogLevel;
+    readonly TRACE: LogLevel;
+    readonly ALL: LogLevel;
+};
+export type LogLevelLabel = "silent" | "fatal" | "error" | "warn" | "info" | "debug" | "trace" | "all";
+export declare const LogLevelLabel: {
+    readonly SILENT: LogLevelLabel;
+    readonly FATAL: LogLevelLabel;
+    readonly ERROR: LogLevelLabel;
+    readonly WARN: LogLevelLabel;
+    readonly INFO: LogLevelLabel;
+    readonly DEBUG: LogLevelLabel;
+    readonly TRACE: LogLevelLabel;
+    readonly ALL: LogLevelLabel;
+};
+export interface BaseTokenizerOptions {
+    workspaceRoot?: string;
+    config?: StormConfig;
+}
+export interface ProjectTokenizerOptions extends BaseTokenizerOptions {
+    projectRoot?: string;
+    projectName?: string;
+    sourceRoot?: string;
+}

package/packages/config-tools/src/utilities/apply-workspace-tokens.d.ts

@@ -0,0 +1,4 @@
+import type { BaseTokenizerOptions, ProjectTokenizerOptions } from "../../declarations";
+export declare const applyWorkspaceBaseTokens: (option: string, tokenizerOptions: BaseTokenizerOptions) => Promise<string>;
+export declare const applyWorkspaceProjectTokens: (option: string, tokenizerOptions: ProjectTokenizerOptions) => Promise<string>;
+export declare const applyWorkspaceTokens: <TConfig extends BaseTokenizerOptions = BaseTokenizerOptions>(options: Record<string, any>, config: TConfig, tokenizerFn: (option: string, config: TConfig) => string | Promise<string>) => Promise<Record<string, any>>;

package/packages/config-tools/src/utilities/chalk.d.ts

@@ -0,0 +1,23 @@
+export type GetChalkReturn = {
+    hex: (_: string) => (message?: string) => string | undefined;
+    bgHex: (_: string) => {
+        whiteBright: (message?: string) => string | undefined;
+    };
+    whiteBright: (message?: string) => string | undefined;
+    bold: {
+        hex: (_: string) => (message?: string) => string | undefined;
+        bgHex: (_: string) => {
+            whiteBright: (message?: string) => string | undefined;
+        };
+        whiteBright: (message?: string) => string | undefined;
+    };
+};
+/**
+ * Get the chalk instance
+ *
+ * @remarks
+ * Annoying polyfill to temporarily fix the issue with the `chalk` import
+ *
+ * @returns The chalk instance
+ */
+export declare const getChalk: () => GetChalkReturn;

package/packages/config-tools/src/utilities/correct-paths.d.ts

@@ -0,0 +1 @@
+export declare const correctPaths: (path?: string) => string;

package/packages/config-tools/src/utilities/file-path-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const removeExtension: (filePath?: string) => string;
+export declare function findFileName(filePath: string): string;

package/packages/config-tools/src/utilities/find-up.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Gets the nearest "node_modules" folder by walking up from start path.
+ */
+export declare function findFolderUp(startPath: string, endFileNames: string[]): string | undefined;

package/packages/config-tools/src/utilities/find-workspace-root.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Find the monorepo root directory, searching upwards from `path`.
+ *
+ * @param pathInsideMonorepo - The path inside the monorepo to start searching from
+ * @returns The monorepo root directory
+ */
+export declare function findWorkspaceRootSafe(pathInsideMonorepo?: string): string | undefined;
+/**
+ * Find the monorepo root directory, searching upwards from `path`.
+ *
+ * @param pathInsideMonorepo - The path inside the monorepo to start searching from
+ * @returns The monorepo root directory
+ */
+export declare function findWorkspaceRoot(pathInsideMonorepo?: string): string;

package/packages/config-tools/src/utilities/get-default-config.d.ts

@@ -0,0 +1,15 @@
+import { type ColorConfig, type StormConfig } from "@storm-software/config";
+/**
+ * Storm theme config values used for styling various workspace elements
+ */
+export declare const DEFAULT_COLOR_CONFIG: ColorConfig;
+/**
+ * Storm Workspace config values used during various dev-ops processes
+ */
+export declare const DEFAULT_STORM_CONFIG: any;
+/**
+ * Get the default Storm config values used during various dev-ops processes
+ *
+ * @returns The default Storm config values
+ */
+export declare const getDefaultConfig: (config?: Partial<StormConfig>, root?: string) => StormConfig;

package/packages/config-tools/src/utilities/get-log-level.d.ts

@@ -0,0 +1,15 @@
+import { LogLevel, LogLevelLabel } from "../types";
+/**
+ * Convert the log level label to a log level
+ *
+ * @param label - The log level label to convert
+ * @returns The log level
+ */
+export declare const getLogLevel: (label?: string) => LogLevel;
+/**
+ * Convert the log level to a log level label
+ *
+ * @param logLevel - The log level to convert
+ * @returns The log level label
+ */
+export declare const getLogLevelLabel: (logLevel?: number) => LogLevelLabel;

package/packages/config-tools/src/utilities/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./find-workspace-root";
+export * from "./get-default-config";
+export * from "./get-log-level";
+export * from "./logger";
+export * from "./process-handler";
+export * from "./run";
+export * from "./correct-paths";
+export * from "./file-path-utils";
+export * from "./apply-workspace-tokens";
+export * from "./chalk";

package/packages/config-tools/src/utilities/logger.d.ts

@@ -0,0 +1,74 @@
+import type { StormConfig } from "@storm-software/config";
+import { LogLevel } from "../types";
+/**
+ * Get the log function for a log level
+ *
+ * @param logLevel - The log level
+ * @param config - The Storm configuration
+ * @returns The log function
+ */
+export declare const getLogFn: (logLevel?: number | LogLevel, config?: Partial<StormConfig>) => ((message?: any) => void);
+/**
+ * Write a message to the console at the `fatal` log level
+ *
+ * @param message - The message to write
+ * @param config - The Storm configuration
+ */
+export declare const writeFatal: (message?: any, config?: Partial<StormConfig>) => void;
+/**
+ * Write a message to the console at the `error` log level
+ *
+ * @param message - The message to write
+ * @param config - The Storm configuration
+ */
+export declare const writeError: (message?: any, config?: Partial<StormConfig>) => void;
+/**
+ * Write a message to the console at the `warning` log level
+ *
+ * @param message - The message to write
+ * @param config - The Storm configuration
+ */
+export declare const writeWarning: (message?: any, config?: Partial<StormConfig>) => void;
+/**
+ * Write a message to the console at the `info` log level
+ *
+ * @param message - The message to write
+ * @param config - The Storm configuration
+ */
+export declare const writeInfo: (message?: any, config?: Partial<StormConfig>) => void;
+/**
+ * Write a message to the console at the `success` log level
+ *
+ * @param message - The message to write
+ * @param config - The Storm configuration
+ */
+export declare const writeSuccess: (message?: any, config?: Partial<StormConfig>) => void;
+/**
+ * Write a message to the console at the `debug` log level
+ *
+ * @param message - The message to write
+ * @param config - The Storm configuration
+ */
+export declare const writeDebug: (message?: any, config?: Partial<StormConfig>) => void;
+/**
+ * Write a message to the console at the `trace` log level
+ *
+ * @param message - The message to write
+ * @param config - The Storm configuration
+ */
+export declare const writeTrace: (message?: any, config?: Partial<StormConfig>) => void;
+/**
+ * Write a message to the console at the `all` log level
+ *
+ * @param message - The message to write
+ * @param config - The Storm configuration
+ */
+export declare const writeSystem: (message?: any, config?: Partial<StormConfig>) => void;
+/**
+ * Get a stopwatch function
+ *
+ * @param name - The name of the process
+ * @returns The stopwatch function
+ */
+export declare const getStopwatch: (name: string) => () => void;
+export declare const formatLogMessage: (message?: any, prefix?: string) => string;

package/packages/config-tools/src/utilities/process-handler.d.ts

@@ -0,0 +1,4 @@
+import type { StormConfig } from "@storm-software/config";
+export declare const exitWithError: (config?: Partial<StormConfig>) => never;
+export declare const exitWithSuccess: (config?: Partial<StormConfig>) => never;
+export declare const handleProcess: (config?: Partial<StormConfig>) => void;

package/packages/config-tools/src/utilities/run.d.ts

@@ -0,0 +1,18 @@
+import type { StormConfig } from "@storm-software/config";
+export declare const LARGE_BUFFER: number;
+export type IOType = "overlapped" | "pipe" | "ignore" | "inherit";
+export type StdioOptions = IOType | Array<IOType | "ipc" | number | null | undefined>;
+/**
+ *  Run a command line process
+ *
+ * @remarks
+ * A wrapper around execSync to run our command line processes
+ *
+ * @param config - The Storm configuration object
+ * @param command - The command to run
+ * @param cwd - The current working directory
+ * @param stdio - The standard input/output options
+ * @param env - The environment variables
+ * @returns The result of the command
+ */
+export declare const run: (config: StormConfig, command: string, cwd?: string, stdio?: StdioOptions, env?: NodeJS.ProcessEnv) => Buffer;

package/packages/k8s-tools/index.d.ts

@@ -0,0 +1 @@
+export * from "./src";

package/packages/k8s-tools/src/executors/helm-package/executor.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutorContext, PromiseExecutor } from "@nx/devkit";
+import type { StormConfig } from "@storm-software/config";
+import { HelmPackageExecutorSchema } from "./schema";
+export declare function serveExecutor(options: HelmPackageExecutorSchema, context: ExecutorContext, config?: StormConfig): Promise<{
+    success: boolean;
+}>;
+declare const _default: PromiseExecutor<HelmPackageExecutorSchema>;
+export default _default;

package/packages/k8s-tools/src/executors/index.d.ts

@@ -0,0 +1 @@
+export * from "./helm-package/executor";

package/packages/k8s-tools/src/generators/helm-chart/generator.d.ts

@@ -0,0 +1,5 @@
+import { GeneratorCallback, Tree } from "@nx/devkit";
+import type { HelmChartGeneratorSchema } from "./schema";
+export declare function helmChartGenerator(tree: Tree, options: HelmChartGeneratorSchema): Promise<GeneratorCallback>;
+export default helmChartGenerator;
+export declare const helmChartSchematic: (generatorOptions: HelmChartGeneratorSchema) => (tree: any, context: any) => Promise<any>;

package/packages/k8s-tools/src/generators/helm-dependency/generator.d.ts

@@ -0,0 +1,5 @@
+import { GeneratorCallback, Tree } from "@nx/devkit";
+import type { HelmDependencyGeneratorSchema } from "./schema";
+export declare function helmDependencyGenerator(tree: Tree, options: HelmDependencyGeneratorSchema): Promise<GeneratorCallback>;
+export default helmDependencyGenerator;
+export declare const helmDependencySchematic: (generatorOptions: HelmDependencyGeneratorSchema) => (tree: any, context: any) => Promise<any>;

package/packages/k8s-tools/src/generators/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./helm-chart/generator";
+export * from "./helm-dependency/generator";

package/packages/k8s-tools/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./executors";
+export * from "./generators";

package/packages/k8s-tools/src/types.d.ts

@@ -0,0 +1,28 @@
+import { Options } from 'prettier';
+/** Types for the core library */
+/** Interface for objects that can be initialized */
+export interface Initializable {
+    initialized: boolean;
+    initialize(): Promise<void>;
+}
+/** Options for packaging a chart */
+export interface PackageOptions {
+    chartFolder: string;
+    outputFolder: string;
+}
+/** Options for pushing a chart */
+export interface PushOptions {
+    chartPath: string;
+    remote: string;
+}
+/** Abstract class for Helm */
+export declare abstract class AbstractHelmClient implements Initializable {
+    initialized: boolean;
+    abstract package(options: PackageOptions): Promise<string | undefined>;
+    initialize(): Promise<void>;
+}
+/** Represents an Prettier ignore file. */
+export interface PrettierConfig {
+    sourceFilepath: string;
+    config: Options;
+}

package/packages/k8s-tools/src/utils/client.d.ts

@@ -0,0 +1,26 @@
+import { AbstractHelmClient, PackageOptions, PushOptions } from "../types";
+/** Helm wrapper class */
+export declare class HelmClient extends AbstractHelmClient {
+    /**
+     * Package a chart directory into a chart archive
+     *
+     * @param {PackageOptions} [options]
+     */
+    package(options: PackageOptions): Promise<string | undefined>;
+    push(options: PushOptions): Promise<void>;
+    dependencyUpdate(chartFolder: string): Promise<void>;
+    dependencyBuild(chartFolder: string): Promise<void>;
+    addRepository(name: string, url: string): Promise<void>;
+    /**
+     * Initialize Helm
+     *
+     * @returns {Promise<void>}
+     */
+    initialize(): Promise<void>;
+}
+/**
+ * Create a new Helm client instance
+ *
+ * @returns {HelmClient}
+ */
+export declare const createHelmClient: () => HelmClient;

package/packages/k8s-tools/src/utils/ensure-init.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Decorator to ensure the class is initialized before executing a method
+ *
+ * @param {any} target
+ * @param {string} propertyKey
+ * @param {PropertyDescriptor} descriptor
+ * @returns {PropertyDescriptor}
+ */
+export declare const ensureInitialized: (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/packages/k8s-tools/src/utils/prettier.d.ts

@@ -0,0 +1,9 @@
+import { Tree } from "@nx/devkit";
+import { PrettierConfig } from "../types";
+/**
+ * Resolves the existing Prettier configuration.
+ *
+ * @returns The Prettier configuration or undefined if not found.
+ */
+export declare function resolveUserExistingPrettierConfig(): Promise<PrettierConfig | undefined>;
+export declare function addToPrettierIgnore(tree: Tree, ignore: string[]): void;

package/packages/workspace-tools/index.d.ts

@@ -0,0 +1,32 @@
+export * from "./src/base";
+export * from "./src/executors/cargo-publish/executor";
+export * from "./src/executors/cargo-publish/schema";
+export * from "./src/executors/clean-package/executor";
+export * from "./src/executors/clean-package/schema";
+export * from "./src/executors/npm-publish/executor";
+export * from "./src/executors/npm-publish/schema";
+export * from "./src/executors/rolldown/executor";
+export * from "./src/executors/rolldown/schema";
+export * from "./src/executors/size-limit/executor";
+export * from "./src/executors/size-limit/schema";
+export * from "./src/executors/tsup-browser/executor";
+export * from "./src/executors/tsup-browser/schema";
+export * from "./src/executors/tsup-neutral/executor";
+export * from "./src/executors/tsup-neutral/schema";
+export * from "./src/executors/tsup-node/executor";
+export * from "./src/executors/tsup-node/schema";
+export * from "./src/executors/typia/executor";
+export * from "./src/executors/typia/schema";
+export * from "./src/executors/unbuild/executor";
+export * from "./src/executors/unbuild/schema";
+export * from "./src/generators/config-schema/generator";
+export * from "./src/generators/config-schema/schema";
+export * from "./src/generators/init/init";
+export * from "./src/generators/init/schema";
+export * from "./src/generators/node-library/generator";
+export * from "./src/generators/node-library/schema";
+export * from "./src/generators/preset/generator";
+export * from "./src/generators/preset/schema";
+export * from "./src/generators/release-version/generator";
+export * from "./src/generators/release-version/schema";
+export * from "./src/utils";

package/packages/workspace-tools/src/base/base-executor.d.ts

@@ -0,0 +1,7 @@
+import type { ExecutorContext, PromiseExecutor } from "@nx/devkit";
+import type { StormConfig } from "@storm-software/config";
+import type { BaseExecutorOptions as _BaseExecutorOptions, BaseExecutorResult as _BaseExecutorResult, BaseExecutorSchema as _BaseExecutorSchema } from "../../declarations";
+export type BaseExecutorOptions<TExecutorSchema extends BaseExecutorSchema = BaseExecutorSchema> = _BaseExecutorOptions<TExecutorSchema>;
+export type BaseExecutorResult = _BaseExecutorResult;
+export type BaseExecutorSchema = _BaseExecutorSchema;
+export declare const withRunExecutor: <TExecutorSchema extends BaseExecutorSchema = _BaseExecutorSchema>(name: string, executorFn: (options: TExecutorSchema, context: ExecutorContext, config: StormConfig) => Promise<BaseExecutorResult | null | undefined> | AsyncGenerator<any, BaseExecutorResult | null | undefined> | BaseExecutorResult | null | undefined, executorOptions?: BaseExecutorOptions<TExecutorSchema>) => PromiseExecutor<TExecutorSchema>;

package/packages/workspace-tools/src/base/base-generator.d.ts

@@ -0,0 +1,4 @@
+import type { GeneratorCallback, Tree } from "@nx/devkit";
+import type { StormConfig } from "@storm-software/config";
+import type { BaseGeneratorOptions, BaseGeneratorResult, BaseGeneratorSchema } from "../../declarations";
+export declare const withRunGenerator: <TGeneratorSchema extends BaseGeneratorSchema = any>(name: string, generatorFn: (tree: Tree, options: TGeneratorSchema, config?: StormConfig) => Promise<BaseGeneratorResult | null | undefined> | BaseGeneratorResult | null | undefined, generatorOptions?: BaseGeneratorOptions<TGeneratorSchema>) => (tree: Tree, _options: TGeneratorSchema) => Promise<GeneratorCallback | BaseGeneratorResult>;

package/packages/workspace-tools/src/base/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./base-executor";
+export * from "./base-generator";
+export * from "./typescript-library-generator";

package/packages/workspace-tools/src/base/typescript-library-generator.d.ts

@@ -0,0 +1,8 @@
+import { type GeneratorCallback, type Tree } from "@nx/devkit";
+import type { AddLintOptions } from "@nx/js/src/generators/library/library";
+import type { TypeScriptLibraryGeneratorNormalizedSchema, TypeScriptLibraryGeneratorSchema } from "../../declarations.d";
+export declare function typeScriptLibraryGeneratorFn(tree: Tree, schema: TypeScriptLibraryGeneratorSchema): Promise<null>;
+export declare function addLint(tree: Tree, options: AddLintOptions): Promise<GeneratorCallback>;
+export declare function getOutputPath(options: TypeScriptLibraryGeneratorNormalizedSchema): string;
+export declare function createProjectTsConfigJson(tree: Tree, options: TypeScriptLibraryGeneratorNormalizedSchema): void;
+export declare function normalizeOptions(tree: Tree, options: TypeScriptLibraryGeneratorSchema): Promise<TypeScriptLibraryGeneratorNormalizedSchema>;

package/packages/workspace-tools/src/executors/cargo-publish/executor.d.ts

@@ -0,0 +1,6 @@
+import { type ExecutorContext } from "@nx/devkit";
+import type { CargoPublishExecutorSchema } from "./schema.d";
+export default function runExecutor(options: CargoPublishExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;
+export declare const getRegistryVersion: (name: string, version: string, registry: string) => Promise<string>;

package/packages/workspace-tools/src/executors/clean-package/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const IGNORE_FILES: (string | RegExp)[];
+export declare const IGNORE_FIELDS: string[];
+export declare const NPM_SCRIPTS: string[];
+export declare const PUBLISH_CONFIG_FIELDS: string[];

package/packages/workspace-tools/src/executors/clean-package/executor.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutorContext } from "@nx/devkit";
+import type { StormConfig } from "@storm-software/config";
+import { CleanPackageExecutorSchema } from "./schema";
+export declare function cleanPackageExecutorFn(options: CleanPackageExecutorSchema, context: ExecutorContext, config: StormConfig): Promise<{
+    success: boolean;
+}>;
+declare const _default: import("@nx/devkit").PromiseExecutor<CleanPackageExecutorSchema>;
+export default _default;

package/packages/workspace-tools/src/executors/clean-package/types.d.ts

@@ -0,0 +1,8 @@
+import type { PackageJson as NxPackageJson } from "nx/src/utils/package-json.js";
+export interface PackageJson extends NxPackageJson {
+    repository?: string | {
+        type?: string;
+        url: string;
+    };
+    homepage?: string;
+}

package/packages/workspace-tools/src/executors/clean-package/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function isObject(object: any): boolean;
+export declare function filterObjectByKey(object: Record<string, any>, filterByKey?: (key?: string) => boolean, deep?: boolean): {};
+export declare function createIgnoreMatcher(ignorePattern?: string | RegExp): (_filename: any, path: any) => boolean;
+export declare function createFilesFilter(ignoreFiles: string | undefined, cwd: string): Promise<(path: any) => boolean | void | undefined>;

package/packages/workspace-tools/src/executors/npm-publish/executor.d.ts

@@ -0,0 +1,6 @@
+import { type ExecutorContext } from "@nx/devkit";
+import type { NpmPublishExecutorSchema } from "./schema.d";
+export declare const LARGE_BUFFER: number;
+export default function npmPublishExecutorFn(options: NpmPublishExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;

package/packages/workspace-tools/src/executors/rolldown/executor.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutorContext } from "@nx/devkit";
+import type { RolldownOptions } from "@storm-software/build-tools";
+import type { StormConfig } from "@storm-software/config";
+import type { RolldownExecutorSchema } from "./schema.d";
+export declare function rolldownExecutorFn(options: RolldownExecutorSchema, context: ExecutorContext, config?: StormConfig): Promise<{
+    success: boolean;
+}>;
+declare const _default: import("@nx/devkit").PromiseExecutor<RolldownOptions>;
+export default _default;

package/packages/workspace-tools/src/executors/size-limit/executor.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutorContext } from "@nx/devkit";
+import type { StormConfig } from "@storm-software/config";
+import type { SizeLimitExecutorSchema } from "./schema";
+export declare function sizeLimitExecutorFn(options: SizeLimitExecutorSchema, context: ExecutorContext, config?: StormConfig): Promise<{
+    success: boolean;
+}>;
+declare const _default: import("@nx/devkit").PromiseExecutor<SizeLimitExecutorSchema>;
+export default _default;

package/packages/workspace-tools/src/executors/tsup/executor.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutorContext } from "@nx/devkit";
+import type { StormConfig } from "@storm-software/config";
+import type { TsupExecutorSchema } from "./schema.d";
+export declare function tsupExecutorFn(options: TsupExecutorSchema, context: ExecutorContext, config: StormConfig): Promise<{
+    success: boolean;
+}>;
+declare const _default: import("@nx/devkit").PromiseExecutor<TsupExecutorSchema>;
+export default _default;