@actsecurity/cli 0.2.66

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cloud Copilot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,143 @@
+# CLI
+
+[![NPM Version](https://img.shields.io/npm/v/@cloud-copilot/cli.svg?logo=nodedotjs)](https://www.npmjs.com/package/@cloud-copilot/cli) [![MIT License](https://img.shields.io/github/license/cloud-copilot/cli)](LICENSE.txt)
+
+[![GuardDog](https://github.com/cloud-copilot/cli/actions/workflows/guarddog.yml/badge.svg)](https://github.com/cloud-copilot/cli/actions/workflows/guarddog.yml) [![Known Vulnerabilities](https://snyk.io/test/github/cloud-copilot/cli/badge.svg?targetFile=package.json&style=flat-square)](https://snyk.io/test/github/cloud-copilot/cli?targetFile=package.json)
+
+Utilities for standardizing working CLIs in Typescript.
+
+- Standardizes the way subcommands, arguments, and operands are parsed and validated
+- Includes "prefix matching" of subcommands and arguments, so users can provide partial names if they match only one subcommand or argument
+- Allows users to default arguments with environment variables
+- Automatically generates a help text for the user
+- Provides a type safe response of the parsed arguments
+- Has zero dependencies
+- Built-in argument types for string, number, boolean, enum, array, and map types
+- Easy custom argument types to create your own argument types with validation
+- Async argument validation and version checking
+- Automatic version checking for updates to your CLI
+
+I wrote this because I'm building several CLI applications and want to have a standard parsing of arguments that users can rely on across all of them.
+
+I was inspired by https://github.com/lirantal/nodejs-cli-apps-best-practices and https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html to follow best practices for accepting arguments and environment variables while keeping my scope extremely limited and having no dependencies.
+
+## Table of Contents
+
+- [Example](#example)
+- [Installation](#installation)
+- [Documentation](#documentation)
+  - [Core Guides](#core-guides)
+  - [Examples](#examples)
+
+## Documentation
+
+### Core Guides
+
+- **[Getting Started](docs/GettingStarted.md)** - Complete tutorial for new users
+- **[Parsing Reference](docs/ParsingReference.md)** - Detailed parsing rules and mechanics
+- **[Operands Guide](docs/OperandsGuide.md)** - Working with positional arguments and expectOperands
+- **[Subcommands Guide](docs/SubcommandsGuide.md)** - Building CLIs with subcommands
+- **[Custom Arguments](docs/CustomArguments.md)** - Creating custom argument types with validation
+- **[Environment Variables](docs/EnvironmentVariables.md)** - Environment variable integration
+- **[Version Handling](docs/VersionHandling.md)** - Version management and update checking
+- **[API Reference](docs/APIReference.md)** - API documentation
+
+### [Examples](src/demo/README.md)
+
+- **[Basic CLI](src/demo/basic.ts)** - Minimal CLI setup with version handling
+- **[Arguments Demo](src/demo/arguments.ts)** - All argument types including custom date arguments
+- **[Operands Demo](src/demo/operands.ts)** - Working with positional arguments (operands)
+- **[No Operands Demo](src/demo/noOperands.ts)** - CLIs that only accept flags and options
+- **[Subcommands Demo](src/demo/subcommands.ts)** - CLI with multiple subcommands and arguments
+- **[Version Handling](src/demo/version.ts)** - Version checking and update notifications
+- **[Reading from stdin](src/demo/stdin.ts)** - Processing input from stdin
+
+## Example
+
+```typescript
+import {
+  parseCliArguments,
+  stringArgument,
+  stringArrayArgument,
+  booleanArgument,
+  numberArgument,
+  enumArgument
+} from '@cloud-copilot/cli'
+
+const cli = await parseCliArguments(
+  'my-command',
+  // optional subcommands
+  {
+    init: {
+      description: 'Initialize the project',
+      // Subcommand Specific Arguments
+      arguments: {
+        s3: booleanArgument({
+          description: 'Use S3 as the storage',
+          character: 's'
+        }),
+        language: enumArgument({
+          description: 'The language to use',
+          validValues: ['typescript', 'javascript']
+        })
+      }
+    },
+    download: {
+      description: 'Download a file',
+      // Subcommand Specific Arguments
+      arguments: {
+        url: stringArgument({
+          description: 'The URL to download from'
+        })
+      }
+    }
+  },
+  // Global Arguments that apply to all subcommands
+  {
+    regions: stringArrayArgument({
+      description: 'Regions to deploy to'
+    }),
+    account: stringArgument({
+      description: 'AWS account to deploy to'
+    }),
+    ssl: booleanArgument({
+      description: 'Enable SSL',
+      character: 's'
+    }),
+    port: numberArgument({
+      description: 'Port to use'
+    })
+  },
+  {}
+)
+```
+
+This will automatically pull in the arguments from the command line and validate them. If any arguments are not valid, it will throw an error with the message of what is wrong. If all arguments and subcommands are valid, it will return an object with a type safe response.
+
+```typescript
+cli.subcommand // 'init' | 'download' | undefined
+cli.args.regions // string[] | undefined
+cli.args.account // string | undefined
+cli.args.ssl // boolean
+cli.args.port // number | undefined
+
+cli.anyValues // boolean, whether any values were provided on the CLI
+
+if (cli.subcommand === 'init') {
+  // Type Checked command specific arguments only in the return type if the subcommand is selected
+  cli.args.s3 // boolean
+  cli.args.language // 'typescript' | 'javascript' | undefined
+}
+
+if (cli.subcommand === 'download') {
+  cli.args.url // string | undefined
+}
+```
+
+If the user provides `--help` a help message will be printed out with the available subcommands and arguments.
+
+## Installation
+
+```bash
+npm install @cloud-copilot/cli
+```

package/dist/cjs/arguments/argument.d.ts

@@ -0,0 +1,63 @@
+export type ValidValue<T> = {
+    valid: true;
+    value: T;
+};
+export type InvalidValue = {
+    valid: false;
+    message: string;
+};
+export type ValidatedValues<T> = ValidValue<T> | InvalidValue;
+export type Argument<ArgumentType> = {
+    /**
+     * A description of the argument, used in help text.
+     */
+    description: string;
+    /**
+     * The default value of the argument, if any.
+     * If not provided, the argument will be undefined until a value is provided.
+     */
+    defaultValue: ArgumentType;
+    /**
+     * Validate all values passed to the argument at once.
+     * @param currentValue the current value of the argument
+     * @param values the array of strings passed to the argument
+     * @param isCurrentlyDefaulted true if the current value has not been set by the user and is still the default value
+     * @returns if the value is invalid, returns { valid: false, message: string } and message will be shown to the user.
+     *          if the value is valid, returns { valid: true, values`: ArgumentType[] } where value is the parsed value.
+     */
+    validateValues: (currentValue: ArgumentType, values: string[], isCurrentlyDefaulted: boolean) => Promise<ValidValue<ArgumentType> | InvalidValue> | ValidValue<ArgumentType> | InvalidValue;
+    /**
+     * Reduces the current value and a new values into a single value.
+     *
+     * @param current the current value of the argument, can be undefined if there is no default value
+     * @param newValues the new values being added as parsed by validateValues
+     * @param isCurrentlyDefaulted true if the current value has not been set by the user and is still the default value
+     * @returns the new value of the argument
+     */
+    reduceValues: (currentValue: ArgumentType, newValues: NonNullable<ArgumentType>, isCurrentlyDefaulted: boolean) => Promise<ArgumentType> | ArgumentType;
+    /**
+     * If this callback is provided, it will be called when the argument is present
+     *
+     * @param currentValue the current value of the argument
+     * @returns the value to set the argument to
+     */
+    present?(currentValue: ArgumentType): Promise<ArgumentType> | ArgumentType;
+    /**
+     * If this function is provided, it will be called to determine if the argument
+     * can accept multiple values.
+     *
+     * If not provided, the argument will only accept a single value.
+     *
+     * @returns true if the argument can accept multiple values, false otherwise
+     */
+    acceptMultipleValues?(): boolean;
+    /**
+     * A single-character alias for the argument, e.g. 'f' for --foo
+     *
+     * This is only valid if the argument does not take a value (e.g. boolean flags).
+     */
+    character?: string;
+};
+export type PerArgumentArgs = Pick<Argument<any>, 'description'>;
+export type CustomArgument<ArgumentType> = Omit<Argument<ArgumentType>, 'character'>;
+//# sourceMappingURL=argument.d.ts.map

package/dist/cjs/arguments/argument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"argument.d.ts","sourceRoot":"","sources":["../../../src/arguments/argument.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAAA;AACrD,MAAM,MAAM,YAAY,GAAG;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAC5D,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG,YAAY,CAAA;AAE7D,MAAM,MAAM,QAAQ,CAAC,YAAY,IAAI;IACnC;;OAEG;IACH,WAAW,EAAE,MAAM,CAAA;IAEnB;;;OAGG;IACH,YAAY,EAAE,YAAY,CAAA;IAE1B;;;;;;;OAOG;IACH,cAAc,EAAE,CACd,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,MAAM,EAAE,EAChB,oBAAoB,EAAE,OAAO,KAC1B,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,GAAG,YAAY,CAAC,GAAG,UAAU,CAAC,YAAY,CAAC,GAAG,YAAY,CAAA;IAE/F;;;;;;;OAOG;IACH,YAAY,EAAE,CACZ,YAAY,EAAE,YAAY,EAC1B,SAAS,EAAE,WAAW,CAAC,YAAY,CAAC,EACpC,oBAAoB,EAAE,OAAO,KAC1B,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAAA;IAEzC;;;;;OAKG;IACH,OAAO,CAAC,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAAA;IAE1E;;;;;;;OAOG;IACH,oBAAoB,CAAC,IAAI,OAAO,CAAA;IAEhC;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,aAAa,CAAC,CAAA;AAChE,MAAM,MAAM,cAAc,CAAC,YAAY,IAAI,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,WAAW,CAAC,CAAA"}

package/dist/cjs/arguments/argument.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=argument.js.map

package/dist/cjs/arguments/argument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"argument.js","sourceRoot":"","sources":["../../../src/arguments/argument.ts"],"names":[],"mappings":""}

package/dist/cjs/arguments/arrayValueArgument.d.ts

@@ -0,0 +1,17 @@
+import { type Argument, type PerArgumentArgs, type ValidatedValues } from './argument.js';
+type ArrayValueValidator<ValueType> = (rawValue: string) => Promise<ValidatedValues<ValueType>> | ValidatedValues<ValueType>;
+type ArrayWithDefault<ValueType> = {
+    defaultValue: ValueType[];
+} & PerArgumentArgs;
+type ArrayWithoutDefault<ValueType> = {
+    defaultValue?: undefined;
+} & PerArgumentArgs;
+/**
+ * Creates an array value argument factory for a specific type
+ */
+export declare function arrayValueArgument<ValueType>(validator: ArrayValueValidator<ValueType>, descriptionSuffix?: string): {
+    (options: ArrayWithDefault<ValueType>): Argument<ValueType[]>;
+    (options: ArrayWithoutDefault<ValueType>): Argument<ValueType[] | undefined>;
+};
+export {};
+//# sourceMappingURL=arrayValueArgument.d.ts.map

package/dist/cjs/arguments/arrayValueArgument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayValueArgument.d.ts","sourceRoot":"","sources":["../../../src/arguments/arrayValueArgument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAA;AAEzF,KAAK,mBAAmB,CAAC,SAAS,IAAI,CACpC,QAAQ,EAAE,MAAM,KACb,OAAO,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,SAAS,CAAC,CAAA;AAErE,KAAK,gBAAgB,CAAC,SAAS,IAAI;IAAE,YAAY,EAAE,SAAS,EAAE,CAAA;CAAE,GAAG,eAAe,CAAA;AAClF,KAAK,mBAAmB,CAAC,SAAS,IAAI;IAAE,YAAY,CAAC,EAAE,SAAS,CAAA;CAAE,GAAG,eAAe,CAAA;AAKpF;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAC1C,SAAS,EAAE,mBAAmB,CAAC,SAAS,CAAC,EACzC,iBAAiB,GAAE,MAAW;cAEG,gBAAgB,CAAC,SAAS,CAAC,GAAG,QAAQ,CAAC,SAAS,EAAE,CAAC;cAEzE,mBAAmB,CAAC,SAAS,CAAC,GACtC,QAAQ,CAAC,SAAS,EAAE,GAAG,SAAS,CAAC;EA2CrC"}

package/dist/cjs/arguments/arrayValueArgument.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayValueArgument = arrayValueArgument;
+/**
+ * Creates an array value argument factory for a specific type
+ */
+function arrayValueArgument(validator, descriptionSuffix = '') {
+    function createArgument(options) {
+        return {
+            description: options.description + descriptionSuffix,
+            validateValues: async (current, values, isCurrentlyDefaulted) => {
+                if (values.length === 0) {
+                    return { valid: false, message: 'at least one value is required' };
+                }
+                const validatedValues = [];
+                for (const rawValue of values) {
+                    const result = await validator(rawValue);
+                    if (!result.valid) {
+                        return result;
+                    }
+                    validatedValues.push(result.value);
+                }
+                return { valid: true, value: validatedValues };
+            },
+            reduceValues: async (current, newValues, isCurrentlyDefaulted) => {
+                if (isCurrentlyDefaulted || !current) {
+                    return newValues;
+                }
+                current.push(...newValues);
+                return current;
+            },
+            defaultValue: options.defaultValue,
+            acceptMultipleValues: () => true
+        };
+    }
+    return createArgument;
+}
+//# sourceMappingURL=arrayValueArgument.js.map

package/dist/cjs/arguments/arrayValueArgument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayValueArgument.js","sourceRoot":"","sources":["../../../src/arguments/arrayValueArgument.ts"],"names":[],"mappings":";;AAeA,gDAkDC;AArDD;;GAEG;AACH,SAAgB,kBAAkB,CAChC,SAAyC,EACzC,oBAA4B,EAAE;IAM9B,SAAS,cAAc,CACrB,OAA4C;QAE5C,OAAO;YACL,WAAW,EAAE,OAAO,CAAC,WAAW,GAAG,iBAAiB;YACpD,cAAc,EAAE,KAAK,EACnB,OAAgC,EAChC,MAAgB,EAChB,oBAA6B,EACU,EAAE;gBACzC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBACxB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,gCAAgC,EAAE,CAAA;gBACpE,CAAC;gBAED,MAAM,eAAe,GAAgB,EAAE,CAAA;gBACvC,KAAK,MAAM,QAAQ,IAAI,MAAM,EAAE,CAAC;oBAC9B,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,QAAQ,CAAC,CAAA;oBACxC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;wBAClB,OAAO,MAAM,CAAA;oBACf,CAAC;oBACD,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;gBACpC,CAAC;gBAED,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,eAAe,EAAE,CAAA;YAChD,CAAC;YACD,YAAY,EAAE,KAAK,EACjB,OAAgC,EAChC,SAAsB,EACtB,oBAA8B,EAC9B,EAAE;gBACF,IAAI,oBAAoB,IAAI,CAAC,OAAO,EAAE,CAAC;oBACrC,OAAO,SAAS,CAAA;gBAClB,CAAC;gBACD,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,CAAA;gBAC1B,OAAO,OAAO,CAAA;YAChB,CAAC;YACD,YAAY,EAAE,OAAO,CAAC,YAAY;YAClC,oBAAoB,EAAE,GAAG,EAAE,CAAC,IAAI;SACjC,CAAA;IACH,CAAC;IAED,OAAO,cAAc,CAAA;AACvB,CAAC"}

package/dist/cjs/arguments/booleanArgument.d.ts

@@ -0,0 +1,11 @@
+import { type Argument, type PerArgumentArgs } from './argument.js';
+/**
+ * Creates a boolean argument that is false by default and true if present.
+ *
+ * @param options the description and the single character that can be used to set the value to true
+ * @returns a boolean argument
+ */
+export declare function booleanArgument(options: {
+    character: string;
+} & PerArgumentArgs): Argument<boolean>;
+//# sourceMappingURL=booleanArgument.d.ts.map

package/dist/cjs/arguments/booleanArgument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"booleanArgument.d.ts","sourceRoot":"","sources":["../../../src/arguments/booleanArgument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAwB,MAAM,eAAe,CAAA;AAEzF;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,eAAe,GAC/C,QAAQ,CAAC,OAAO,CAAC,CAkBnB"}

package/dist/cjs/arguments/booleanArgument.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.booleanArgument = booleanArgument;
+/**
+ * Creates a boolean argument that is false by default and true if present.
+ *
+ * @param options the description and the single character that can be used to set the value to true
+ * @returns a boolean argument
+ */
+function booleanArgument(options) {
+    return {
+        description: options.description,
+        character: options.character,
+        validateValues: (currentValue, value, isCurrentlyDefaulted) => {
+            if (value.length == 0) {
+                return { valid: true, value: true };
+            }
+            return { valid: false, message: `does not accept values but received ${value.join(', ')}` };
+        },
+        reduceValues: (current, newValue, isCurrentlyDefaulted) => current,
+        present: (currentValue) => true,
+        defaultValue: false
+    };
+}
+//# sourceMappingURL=booleanArgument.js.map

package/dist/cjs/arguments/booleanArgument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"booleanArgument.js","sourceRoot":"","sources":["../../../src/arguments/booleanArgument.ts"],"names":[],"mappings":";;AAQA,0CAoBC;AA1BD;;;;;GAKG;AACH,SAAgB,eAAe,CAC7B,OAAgD;IAEhD,OAAO;QACL,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,cAAc,EAAE,CACd,YAAqB,EACrB,KAAe,EACf,oBAA6B,EACH,EAAE;YAC5B,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;gBACtB,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAA;YACrC,CAAC;YACD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,uCAAuC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAA;QAC7F,CAAC;QACD,YAAY,EAAE,CAAC,OAAgB,EAAE,QAAiB,EAAE,oBAA6B,EAAE,EAAE,CAAC,OAAO;QAC7F,OAAO,EAAE,CAAC,YAAqB,EAAE,EAAE,CAAC,IAAI;QACxC,YAAY,EAAE,KAAK;KACpB,CAAA;AACH,CAAC"}

package/dist/cjs/arguments/enumArgument.d.ts

@@ -0,0 +1,20 @@
+import { type NoExtraKeys } from '../utils.js';
+import { type Argument, type PerArgumentArgs } from './argument.js';
+type EnumType<T extends {
+    validValues: string[];
+    defaultValue?: string | undefined;
+}> = T['defaultValue'] extends string ? T['validValues'][number] | T['defaultValue'] : T['validValues'][number];
+type EnumOptions = {
+    defaultValue?: string;
+    validValues: string[];
+} & PerArgumentArgs;
+export declare function enumArgument<const O extends {
+    defaultValue: string;
+    validValues: string[];
+} & PerArgumentArgs>(options: NoExtraKeys<O, EnumOptions>): Argument<EnumType<O>>;
+export declare function enumArgument<const O extends {
+    defaultValue?: undefined;
+    validValues: string[];
+} & PerArgumentArgs>(options: NoExtraKeys<O, EnumOptions>): Argument<EnumType<O> | undefined>;
+export {};
+//# sourceMappingURL=enumArgument.d.ts.map

package/dist/cjs/arguments/enumArgument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumArgument.d.ts","sourceRoot":"","sources":["../../../src/arguments/enumArgument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAwB,MAAM,eAAe,CAAA;AAEzF,KAAK,QAAQ,CAAC,CAAC,SAAS;IAAE,WAAW,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,IAClF,CAAC,CAAC,cAAc,CAAC,SAAS,MAAM,GAC5B,CAAC,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,cAAc,CAAC,GAC5C,CAAC,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,CAAA;AAE9B,KAAK,WAAW,GAAG;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,eAAe,CAAA;AAErF,wBAAgB,YAAY,CAC1B,KAAK,CAAC,CAAC,SAAS;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,eAAe,EACjF,OAAO,EAAE,WAAW,CAAC,CAAC,EAAE,WAAW,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;AAC9D,wBAAgB,YAAY,CAC1B,KAAK,CAAC,CAAC,SAAS;IAAE,YAAY,CAAC,EAAE,SAAS,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,eAAe,EACrF,OAAO,EAAE,WAAW,CAAC,CAAC,EAAE,WAAW,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAA"}

package/dist/cjs/arguments/enumArgument.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumArgument = enumArgument;
+function enumArgument(options) {
+    return {
+        description: options.description +
+            `. One value required, valid values are: ${options.validValues.join(', ')}`,
+        validateValues: (currentValue, values, isCurrentlyDefaulted) => {
+            if (values.length == 0) {
+                return { valid: false, message: 'a value is required' };
+            }
+            if (currentValue != options.defaultValue) {
+                return { valid: false, message: 'expects a single value but was set multiple times' };
+            }
+            if (values.length > 1) {
+                return {
+                    valid: false,
+                    message: 'expects a single value but received ' + values.join(', ')
+                };
+            }
+            const value = values[0];
+            const match = options.validValues.find((v) => v.toLowerCase() === value.toLowerCase());
+            if (!match) {
+                return {
+                    valid: false,
+                    message: `${value} is not one of the allowed values: ${options.validValues.join(', ')}`
+                };
+            }
+            return { valid: true, value: match };
+        },
+        reduceValues: (current, newValue, isCurrentlyDefaulted) => newValue,
+        defaultValue: options.defaultValue
+    };
+}
+//# sourceMappingURL=enumArgument.js.map

package/dist/cjs/arguments/enumArgument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumArgument.js","sourceRoot":"","sources":["../../../src/arguments/enumArgument.ts"],"names":[],"mappings":";;AAgBA,oCA0CC;AA1CD,SAAgB,YAAY,CAE1B,OAAoC;IACpC,OAAO;QACL,WAAW,EACT,OAAO,CAAC,WAAW;YACnB,2CAA2C,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;QAC7E,cAAc,EAAE,CACd,YAAqC,EACrC,MAAgB,EAChB,oBAA6B,EACC,EAAE;YAChC,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;gBACvB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,qBAAqB,EAAE,CAAA;YACzD,CAAC;YACD,IAAI,YAAY,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;gBACzC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,mDAAmD,EAAE,CAAA;YACvF,CAAC;YACD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACtB,OAAO;oBACL,KAAK,EAAE,KAAK;oBACZ,OAAO,EAAE,sCAAsC,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;iBACpE,CAAA;YACH,CAAC;YACD,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;YACvB,MAAM,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC,WAAW,EAAE,CAAC,CAAA;YACtF,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,OAAO;oBACL,KAAK,EAAE,KAAK;oBACZ,OAAO,EAAE,GAAG,KAAK,sCAAsC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;iBACxF,CAAA;YACH,CAAC;YAED,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAoB,EAAE,CAAA;QACrD,CAAC;QACD,YAAY,EAAE,CACZ,OAAgC,EAChC,QAAqB,EACrB,oBAA6B,EAC7B,EAAE,CAAC,QAAQ;QACb,YAAY,EAAE,OAAO,CAAC,YAAY;KACnC,CAAA;AACH,CAAC"}

package/dist/cjs/arguments/enumArrayArgument.d.ts

@@ -0,0 +1,20 @@
+import { type NoExtraKeys } from '../utils.js';
+import { type Argument, type PerArgumentArgs } from './argument.js';
+type EnumArrayType<T extends {
+    validValues: string[];
+    defaultValue?: string[] | undefined;
+}> = T['defaultValue'] extends string[] ? T['validValues'][number] | T['defaultValue'][number] : T['validValues'][number];
+type EnumArrayOptions = {
+    defaultValue?: string[];
+    validValues: string[];
+} & PerArgumentArgs;
+export declare function enumArrayArgument<const O extends {
+    defaultValue: string[];
+    validValues: string[];
+} & PerArgumentArgs>(options: NoExtraKeys<O, EnumArrayOptions>): Argument<EnumArrayType<O>[]>;
+export declare function enumArrayArgument<const O extends {
+    defaultValue?: undefined;
+    validValues: string[];
+} & PerArgumentArgs>(options: NoExtraKeys<O, EnumArrayOptions>): Argument<EnumArrayType<O>[] | undefined>;
+export {};
+//# sourceMappingURL=enumArrayArgument.d.ts.map

package/dist/cjs/arguments/enumArrayArgument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumArrayArgument.d.ts","sourceRoot":"","sources":["../../../src/arguments/enumArrayArgument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAwB,MAAM,eAAe,CAAA;AAEzF,KAAK,aAAa,CAAC,CAAC,SAAS;IAAE,WAAW,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;CAAE,IACzF,CAAC,CAAC,cAAc,CAAC,SAAS,MAAM,EAAE,GAC9B,CAAC,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,GACpD,CAAC,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,CAAA;AAE9B,KAAK,gBAAgB,GAAG;IAAE,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,eAAe,CAAA;AAE5F,wBAAgB,iBAAiB,CAC/B,KAAK,CAAC,CAAC,SAAS;IAAE,YAAY,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,eAAe,EACnF,OAAO,EAAE,WAAW,CAAC,CAAC,EAAE,gBAAgB,CAAC,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;AAC1E,wBAAgB,iBAAiB,CAC/B,KAAK,CAAC,CAAC,SAAS;IAAE,YAAY,CAAC,EAAE,SAAS,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,eAAe,EACrF,OAAO,EAAE,WAAW,CAAC,CAAC,EAAE,gBAAgB,CAAC,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC,CAAA"}

package/dist/cjs/arguments/enumArrayArgument.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumArrayArgument = enumArrayArgument;
+function enumArrayArgument(options) {
+    return {
+        description: options.description +
+            `. One or more values required, valid values are: ${options.validValues.join(', ')}`,
+        validateValues: async (currentValue, values, isCurrentlyDefaulted) => {
+            if (values.length == 0) {
+                return { valid: false, message: 'At least one value is required' };
+            }
+            const invalidValues = [];
+            const validValues = [];
+            for (const value of values) {
+                const match = options.validValues.find((v) => v.toLowerCase() === value.toLowerCase());
+                if (!match) {
+                    invalidValues.push(value);
+                }
+                else {
+                    validValues.push(match);
+                }
+            }
+            if (invalidValues.length > 0) {
+                return {
+                    valid: false,
+                    message: `${invalidValues.map((v) => `${v}`).join(', ')} is not one of the allowed values: ${options.validValues.join(', ')}`
+                };
+            }
+            return { valid: true, value: validValues };
+        },
+        reduceValues: async (current, newValues, isCurrentlyDefaulted) => {
+            if (isCurrentlyDefaulted || !current) {
+                // If the current value is the default or undefined, replace it entirely
+                return newValues;
+            }
+            current.push(...newValues);
+            return current;
+        },
+        defaultValue: options.defaultValue,
+        acceptMultipleValues: () => true
+    };
+}
+//# sourceMappingURL=enumArrayArgument.js.map

package/dist/cjs/arguments/enumArrayArgument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumArrayArgument.js","sourceRoot":"","sources":["../../../src/arguments/enumArrayArgument.ts"],"names":[],"mappings":";;AAgBA,8CAoDC;AApDD,SAAgB,iBAAiB,CAG/B,OAAyC;IAEzC,OAAO;QACL,WAAW,EACT,OAAO,CAAC,WAAW;YACnB,oDAAoD,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;QACtF,cAAc,EAAE,KAAK,EACnB,YAA4C,EAC5C,MAAgB,EAChB,oBAA6B,EACiB,EAAE;YAChD,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;gBACvB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,gCAAgC,EAAE,CAAA;YACpE,CAAC;YACD,MAAM,aAAa,GAAa,EAAE,CAAA;YAClC,MAAM,WAAW,GAAuB,EAAE,CAAA;YAC1C,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;gBAC3B,MAAM,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC,WAAW,EAAE,CAAC,CAAA;gBACtF,IAAI,CAAC,KAAK,EAAE,CAAC;oBACX,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;gBAC3B,CAAC;qBAAM,CAAC;oBACN,WAAW,CAAC,IAAI,CAAC,KAAyB,CAAC,CAAA;gBAC7C,CAAC;YACH,CAAC;YAED,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC7B,OAAO;oBACL,KAAK,EAAE,KAAK;oBACZ,OAAO,EAAE,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,sCAAsC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;iBAC9H,CAAA;YACH,CAAC;YAED,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,CAAA;QAC5C,CAAC;QACD,YAAY,EAAE,KAAK,EACjB,OAAuC,EACvC,SAA6B,EAC7B,oBAA8B,EAC9B,EAAE;YACF,IAAI,oBAAoB,IAAI,CAAC,OAAO,EAAE,CAAC;gBACrC,wEAAwE;gBACxE,OAAO,SAAS,CAAA;YAClB,CAAC;YACD,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,CAAA;YAC1B,OAAO,OAAO,CAAA;QAChB,CAAC;QACD,YAAY,EAAE,OAAO,CAAC,YAAY;QAClC,oBAAoB,EAAE,GAAG,EAAE,CAAC,IAAI;KACjC,CAAA;AACH,CAAC"}

package/dist/cjs/arguments/mapArgument.d.ts

@@ -0,0 +1,20 @@
+import { type Argument, type PerArgumentArgs } from './argument.js';
+type MapResult = Record<string, string[]>;
+type MapWithDefault = {
+    defaultValue: MapResult;
+} & PerArgumentArgs;
+type MapWithoutDefault = {
+    defaultValue?: undefined;
+} & PerArgumentArgs;
+/**
+ * Creates a map argument where the first value is the key and the rest are values.
+ *
+ * --arg-name key1 key1Value1 key1Value2 --arg-name key2 key2Value1 key2Value2
+ *
+ * @param options the description and optional default value
+ * @returns a map argument
+ */
+export declare function mapArgument(options: MapWithDefault): Argument<MapResult>;
+export declare function mapArgument(options: MapWithoutDefault): Argument<MapResult | undefined>;
+export {};
+//# sourceMappingURL=mapArgument.d.ts.map

package/dist/cjs/arguments/mapArgument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapArgument.d.ts","sourceRoot":"","sources":["../../../src/arguments/mapArgument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAwB,MAAM,eAAe,CAAA;AAEzF,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;AAEzC,KAAK,cAAc,GAAG;IAAE,YAAY,EAAE,SAAS,CAAA;CAAE,GAAG,eAAe,CAAA;AACnE,KAAK,iBAAiB,GAAG;IAAE,YAAY,CAAC,EAAE,SAAS,CAAA;CAAE,GAAG,eAAe,CAAA;AAGvE;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,cAAc,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAA;AACzE,wBAAgB,WAAW,CAAC,OAAO,EAAE,iBAAiB,GAAG,QAAQ,CAAC,SAAS,GAAG,SAAS,CAAC,CAAA"}

package/dist/cjs/arguments/mapArgument.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapArgument = mapArgument;
+function mapArgument(options) {
+    return {
+        description: options.description + `. Each instance requires a key and at least one value.`,
+        validateValues: async (currentValue, values, isCurrentlyDefaulted) => {
+            const [first, ...rest] = values;
+            if (!first) {
+                return { valid: false, message: 'a key is required and at least one value is required' };
+            }
+            if (rest.length < 1) {
+                return { valid: false, message: `${first} requires at least one value` };
+            }
+            if (!isCurrentlyDefaulted && currentValue && first in currentValue) {
+                return { valid: false, message: `${first} is set multiple times` };
+            }
+            return {
+                valid: true,
+                value: {
+                    [first]: rest
+                }
+            };
+        },
+        reduceValues: async (current, newValue, isCurrentlyDefaulted) => {
+            if (isCurrentlyDefaulted || !current) {
+                return { ...newValue };
+            }
+            return { ...current, ...newValue };
+        },
+        defaultValue: options.defaultValue,
+        acceptMultipleValues: () => true
+    };
+}
+//# sourceMappingURL=mapArgument.js.map

package/dist/cjs/arguments/mapArgument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapArgument.js","sourceRoot":"","sources":["../../../src/arguments/mapArgument.ts"],"names":[],"mappings":";;AAkBA,kCAwCC;AAxCD,SAAgB,WAAW,CACzB,OAA+B;IAE/B,OAAO;QACL,WAAW,EAAE,OAAO,CAAC,WAAW,GAAG,wDAAwD;QAC3F,cAAc,EAAE,KAAK,EACnB,YAAmC,EACnC,MAAgB,EAChB,oBAA6B,EACQ,EAAE;YACvC,MAAM,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,GAAG,MAAM,CAAA;YAC/B,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,sDAAsD,EAAE,CAAA;YAC1F,CAAC;YACD,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACpB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,KAAK,8BAA8B,EAAE,CAAA;YAC1E,CAAC;YACD,IAAI,CAAC,oBAAoB,IAAI,YAAY,IAAI,KAAK,IAAI,YAAY,EAAE,CAAC;gBACnE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,KAAK,wBAAwB,EAAE,CAAA;YACpE,CAAC;YACD,OAAO;gBACL,KAAK,EAAE,IAAI;gBACX,KAAK,EAAE;oBACL,CAAC,KAAK,CAAC,EAAE,IAAI;iBACd;aACF,CAAA;QACH,CAAC;QACD,YAAY,EAAE,KAAK,EACjB,OAA8B,EAC9B,QAAmB,EACnB,oBAA6B,EAC7B,EAAE;YACF,IAAI,oBAAoB,IAAI,CAAC,OAAO,EAAE,CAAC;gBACrC,OAAO,EAAE,GAAG,QAAQ,EAAE,CAAA;YACxB,CAAC;YACD,OAAO,EAAE,GAAG,OAAO,EAAE,GAAG,QAAQ,EAAE,CAAA;QACpC,CAAC;QACD,YAAY,EAAE,OAAO,CAAC,YAAY;QAClC,oBAAoB,EAAE,GAAG,EAAE,CAAC,IAAI;KACjC,CAAA;AACH,CAAC"}

package/dist/cjs/arguments/numberArguments.d.ts

@@ -0,0 +1,17 @@
+export declare const numberArgument: {
+    (options: {
+        defaultValue: number;
+    } & import("./argument.js").PerArgumentArgs): import("./argument.js").Argument<number>;
+    (options: {
+        defaultValue?: undefined;
+    } & import("./argument.js").PerArgumentArgs): import("./argument.js").Argument<number | undefined>;
+};
+export declare const numberArrayArgument: {
+    (options: {
+        defaultValue: number[];
+    } & import("./argument.js").PerArgumentArgs): import("./argument.js").Argument<number[]>;
+    (options: {
+        defaultValue?: undefined;
+    } & import("./argument.js").PerArgumentArgs): import("./argument.js").Argument<number[] | undefined>;
+};
+//# sourceMappingURL=numberArguments.d.ts.map

package/dist/cjs/arguments/numberArguments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numberArguments.d.ts","sourceRoot":"","sources":["../../../src/arguments/numberArguments.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,cAAc;;;;;;;CAAwE,CAAA;AAEnG,eAAO,MAAM,mBAAmB;;;;;;;CAG/B,CAAA"}

package/dist/cjs/arguments/numberArguments.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberArrayArgument = exports.numberArgument = void 0;
+const arrayValueArgument_js_1 = require("./arrayValueArgument.js");
+const singleValueArgument_js_1 = require("./singleValueArgument.js");
+function validateNumber(rawValue) {
+    const num = Number(rawValue);
+    if (isNaN(num)) {
+        return { valid: false, message: `expects a number but received ${rawValue}` };
+    }
+    return { valid: true, value: num };
+}
+exports.numberArgument = (0, singleValueArgument_js_1.singleValueArgument)(validateNumber, '. One number required.');
+exports.numberArrayArgument = (0, arrayValueArgument_js_1.arrayValueArgument)(validateNumber, '. One or more numbers required.');
+//# sourceMappingURL=numberArguments.js.map

package/dist/cjs/arguments/numberArguments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"numberArguments.js","sourceRoot":"","sources":["../../../src/arguments/numberArguments.ts"],"names":[],"mappings":";;;AACA,mEAA4D;AAC5D,qEAA8D;AAE9D,SAAS,cAAc,CAAC,QAAgB;IACtC,MAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;IAC5B,IAAI,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QACf,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,iCAAiC,QAAQ,EAAE,EAAE,CAAA;IAC/E,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,CAAA;AACpC,CAAC;AAEY,QAAA,cAAc,GAAG,IAAA,4CAAmB,EAAS,cAAc,EAAE,wBAAwB,CAAC,CAAA;AAEtF,QAAA,mBAAmB,GAAG,IAAA,0CAAkB,EACnD,cAAc,EACd,iCAAiC,CAClC,CAAA"}

package/dist/cjs/arguments/singleValueArgument.d.ts

@@ -0,0 +1,17 @@
+import { type Argument, type PerArgumentArgs, type ValidatedValues } from './argument.js';
+type SingleValueValidator<ValueType> = (rawValue: string) => Promise<ValidatedValues<ValueType>> | ValidatedValues<ValueType>;
+type ArgumentWithDefault<ValueType> = {
+    defaultValue: ValueType;
+} & PerArgumentArgs;
+type ArgumentWithoutDefault<ValueType> = {
+    defaultValue?: undefined;
+} & PerArgumentArgs;
+/**
+ * Creates a single value argument factory for a specific type
+ */
+export declare function singleValueArgument<ValueType>(validator: SingleValueValidator<ValueType>, descriptionSuffix?: string): {
+    (options: ArgumentWithDefault<ValueType>): Argument<ValueType>;
+    (options: ArgumentWithoutDefault<ValueType>): Argument<ValueType | undefined>;
+};
+export {};
+//# sourceMappingURL=singleValueArgument.d.ts.map

package/dist/cjs/arguments/singleValueArgument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleValueArgument.d.ts","sourceRoot":"","sources":["../../../src/arguments/singleValueArgument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAA;AAEzF,KAAK,oBAAoB,CAAC,SAAS,IAAI,CACrC,QAAQ,EAAE,MAAM,KACb,OAAO,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,SAAS,CAAC,CAAA;AAErE,KAAK,mBAAmB,CAAC,SAAS,IAAI;IAAE,YAAY,EAAE,SAAS,CAAA;CAAE,GAAG,eAAe,CAAA;AACnF,KAAK,sBAAsB,CAAC,SAAS,IAAI;IAAE,YAAY,CAAC,EAAE,SAAS,CAAA;CAAE,GAAG,eAAe,CAAA;AAKvF;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAC3C,SAAS,EAAE,oBAAoB,CAAC,SAAS,CAAC,EAC1C,iBAAiB,GAAE,MAAW;cAEG,mBAAmB,CAAC,SAAS,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC;cAE1E,sBAAsB,CAAC,SAAS,CAAC,GACzC,QAAQ,CAAC,SAAS,GAAG,SAAS,CAAC;EAuCnC"}