@decaf-ts/decorator-validation 1.7.3 → 1.7.5

package/lib/esm/validation/types.d.ts

@@ -60,6 +60,7 @@ export type ValidationElementDefinition = {
     [indexer: string]: any;
     value?: string | number;
     message: string;
+    description: string;
     types?: string[];
 };
 /**
@@ -128,20 +129,19 @@ export interface IValidatorRegistry<T extends Validator> extends IRegistry<T> {
 /**
  * @description Base options type for all validators
  * @summary Defines the common properties available to all validators
- * @typedef ValidatorOptions
+ * @interface ValidatorOptions
  * @property {string} [message] - Custom error message to display when validation fails
- * @memberOf module:decorator-validation
  * @category Validation
  */
-export type ValidatorOptions = {
+export interface ValidatorOptions {
     message?: string;
-};
+    description?: string;
+}
 /**
  * @description URL validation options interface
  * @summary Defines options for URL validation, including allowed URL types
  * @interface URLValidatorOptions
  * @property {(string|string[]|{ name: string })} types - Specifies the allowed URL types or patterns
- * @memberOf module:decorator-validation
  * @category Validation
  */
 export interface URLValidatorOptions extends ValidatorOptions {
@@ -172,6 +172,7 @@ export interface TypeValidatorOptions extends ValidatorOptions {
  */
 export interface StepValidatorOptions extends ValidatorOptions {
     [ValidationKeys.STEP]: number | string;
+    types?: string[];
 }
 /**
  * @description Pattern validation options interface
@@ -183,6 +184,7 @@ export interface StepValidatorOptions extends ValidatorOptions {
  */
 export interface PatternValidatorOptions extends ValidatorOptions {
     [ValidationKeys.PATTERN]?: RegExp | string;
+    types?: string[];
 }
 /**
  * @description Minimum value validation options interface
@@ -194,6 +196,7 @@ export interface PatternValidatorOptions extends ValidatorOptions {
  */
 export interface MinValidatorOptions extends ValidatorOptions {
     [ValidationKeys.MIN]: number | Date | string;
+    types?: string[];
 }
 /**
  * @description Minimum length validation options interface
@@ -205,6 +208,7 @@ export interface MinValidatorOptions extends ValidatorOptions {
  */
 export interface MinLengthValidatorOptions extends ValidatorOptions {
     [ValidationKeys.MIN_LENGTH]: number;
+    types?: string[];
 }
 /**
  * @description Maximum value validation options interface
@@ -216,6 +220,7 @@ export interface MinLengthValidatorOptions extends ValidatorOptions {
  */
 export interface MaxValidatorOptions extends ValidatorOptions {
     [ValidationKeys.MAX]: number | Date | string;
+    types?: string[];
 }
 /**
  * @description Maximum length validation options interface
@@ -227,6 +232,7 @@ export interface MaxValidatorOptions extends ValidatorOptions {
  */
 export interface MaxLengthValidatorOptions extends ValidatorOptions {
     [ValidationKeys.MAX_LENGTH]: number;
+    types?: string[];
 }
 /**
  * @description List validation options interface

package/lib/esm/validation/types.js

@@ -1,2 +1,2 @@
-import { ValidationKeys } from "./Validators";
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/validation/types.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAa,MAAM,cAAc,CAAC","sourcesContent":["import { DecoratorMetadata } from \"@decaf-ts/reflection\";\nimport { Constructor } from \"../model\";\nimport { ValidationKeys, Validator } from \"./Validators\";\nimport { IRegistry } from \"../utils\";\n\n/**\n * @description Type definition for metadata used by validation decorators\n * @summary Defines the structure of metadata attached to properties by validation decorators.\n * This metadata is used during validation to determine validation rules and error messages.\n *\n * @property {any[]} [args] - Optional arguments for the validator\n * @property {string} message - Error message to display when validation fails\n * @property {string[]} [types] - Array of type names that the property can have\n *\n * @typedef {Object} ValidationMetadata\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport type ValidationMetadata = {\n  [indexer: string]: any;\n  args?: any[];\n  message: string;\n  types?: string[];\n};\n\n/**\n * @description Type definition for property-level validation decorator configuration\n * @summary Defines the structure that associates a property with its validation decorators.\n * This type is used to track which decorators are applied to a specific property during validation.\n *\n * @property {string|symbol} prop - The property name or symbol that the decorators are applied to\n * @property {ValidationDecoratorDefinition[]} decorators - Array of decorator definitions applied to the property\n *\n * @typedef {Object} ValidationPropertyDecoratorDefinition\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport type ValidationPropertyDecoratorDefinition = {\n  prop: string | symbol;\n  decorators: ValidationDecoratorDefinition[];\n};\n\n/**\n * @description Type definition for individual validation decorator metadata\n * @summary Extends the base DecoratorMetadata type with validation-specific properties.\n * This type represents the metadata for a single validation decorator applied to a property.\n *\n * @property {ValidationElementDefinition} props - The validation element properties and configuration\n *\n * @typedef {Object} ValidationDecoratorDefinition\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport type ValidationDecoratorDefinition = DecoratorMetadata & {\n  props: ValidationElementDefinition;\n};\n\n/**\n * @summary Type for a validator element metadata\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport type ValidationElementDefinition = {\n  [indexer: string]: any;\n\n  value?: string | number;\n  message: string;\n  types?: string[];\n};\n\n/**\n * @summary Type for a model errors\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport type ModelErrors = Record<string, Record<string, string | undefined>>;\n\n/**\n * @summary Util type for {@link Validator} configuration\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport type ValidatorDefinition = {\n  validator: Constructor<Validator>;\n  validationKey: string;\n  save: boolean;\n};\n\n/**\n * @description Interface for a registry that manages validator instances\n * @summary Defines the contract for a registry that stores and retrieves validators.\n * The registry is responsible for maintaining a collection of validators and providing\n * access to them by key.\n *\n * @interface IValidatorRegistry\n * @template T Type of validator, must extend Validator\n * @extends IRegistry<T>\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface IValidatorRegistry<T extends Validator> extends IRegistry<T> {\n  /**\n   * @description Retrieves custom validation keys defined in the registry\n   * @summary Returns a mapping of custom validation keys to their corresponding standard keys.\n   * This allows for aliasing validation keys for specific use cases.\n   *\n   * @return {Record<string, string>} Object mapping custom keys to standard validation keys\n   */\n  getCustomKeys(): Record<string, string>;\n\n  /**\n   * @description Gets all registered validator keys\n   * @summary Returns an array of all validation keys that have registered validators.\n   *\n   * @return {string[]} Array of registered validator keys\n   */\n  getKeys(): string[];\n\n  /**\n   * @description Registers one or more validators with the registry\n   * @summary Adds validators to the registry, making them available for validation operations.\n   * Validators can be provided as instances or as validator definitions.\n   *\n   * @param {...(T|ValidatorDefinition)} validator - Validator instances or definitions to register\n   * @return {void}\n   */\n  register<T extends Validator>(\n    ...validator: (T | ValidatorDefinition)[]\n  ): void;\n\n  /**\n   * @description Retrieves a validator by its key\n   * @summary Looks up a validator in the registry using its validation key.\n   * Returns the validator if found, or undefined if no validator is registered for the key.\n   *\n   * @param {string} key - The validation key to look up, typically one of the {@link ValidationKeys}\n   * @return {T|undefined} The registered validator or undefined if none matches the provided key\n   */\n  get<T extends Validator>(key: string): T | undefined;\n}\n\n/**\n * @description Base options type for all validators\n * @summary Defines the common properties available to all validators\n * @typedef ValidatorOptions\n * @property {string} [message] - Custom error message to display when validation fails\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport type ValidatorOptions = {\n  message?: string;\n};\n\n/**\n * @description URL validation options interface\n * @summary Defines options for URL validation, including allowed URL types\n * @interface URLValidatorOptions\n * @property {(string|string[]|{ name: string })} types - Specifies the allowed URL types or patterns\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface URLValidatorOptions extends ValidatorOptions {\n  types: string | string[] | { name: string };\n}\n\n/**\n * @description Type validation options interface\n * @summary Defines options for type validation, specifying allowed types\n * @interface TypeValidatorOptions\n * @property {(string|string[]|{ name: string })} types - Specifies the allowed data types\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface TypeValidatorOptions extends ValidatorOptions {\n  types: string | string[] | { name: string };\n}\n\n/**\n * @description Step validation options interface\n * @summary Defines options for step validation, specifying the step increment\n * @interface StepValidatorOptions\n * @property {(number|string)} [ValidationKeys.STEP] - The step value for numerical validation\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface StepValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.STEP]: number | string;\n}\n\n/**\n * @description Pattern validation options interface\n * @summary Defines options for pattern validation using regular expressions\n * @interface PatternValidatorOptions\n * @property {(RegExp|string)} [ValidationKeys.PATTERN] - The pattern to match against\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface PatternValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.PATTERN]?: RegExp | string;\n}\n\n/**\n * @description Minimum value validation options interface\n * @summary Defines options for minimum value validation\n * @interface MinValidatorOptions\n * @property {(number|Date|string)} [ValidationKeys.MIN] - The minimum allowed value\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface MinValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.MIN]: number | Date | string;\n}\n\n/**\n * @description Minimum length validation options interface\n * @summary Defines options for minimum length validation\n * @interface MinLengthValidatorOptions\n * @property {number} [ValidationKeys.MIN_LENGTH] - The minimum allowed length\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface MinLengthValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.MIN_LENGTH]: number;\n}\n\n/**\n * @description Maximum value validation options interface\n * @summary Defines options for maximum value validation\n * @interface MaxValidatorOptions\n * @property {(number|Date|string)} [ValidationKeys.MAX] - The maximum allowed value\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface MaxValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.MAX]: number | Date | string;\n}\n\n/**\n * @description Maximum length validation options interface\n * @summary Defines options for maximum length validation\n * @interface MaxLengthValidatorOptions\n * @property {number} [ValidationKeys.MAX_LENGTH] - The maximum allowed length\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface MaxLengthValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.MAX_LENGTH]: number;\n}\n\n/**\n * @description List validation options interface\n * @summary Defines options for list validation\n * @interface ListValidatorOptions\n * @property {string[]} clazz - Array of allowed class names or types\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface ListValidatorOptions extends ValidatorOptions {\n  clazz: string[];\n}\n\n/**\n * @description Date validation options interface\n * @summary Defines options for date validation\n * @interface DateValidatorOptions\n * @property {string} [ValidationKeys.FORMAT] - The expected date format pattern\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface DateValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.FORMAT]?: string;\n}\n\nexport interface EqualsValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.EQUALS]: string;\n}\n\nexport interface DiffValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.DIFF]: string;\n}\n\nexport interface LessThanValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.LESS_THAN]: string;\n}\n\nexport interface LessThanOrEqualValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.LESS_THAN_OR_EQUAL]: string;\n}\n\nexport interface GreaterThanValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.GREATER_THAN]: string;\n}\n\nexport interface GreaterThanOrEqualValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.GREATER_THAN_OR_EQUAL]: string;\n}\n"]}
+import { ValidationKeys } from "./Validators/index.js";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/validation/types.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAa,8BAAqB","sourcesContent":["import { DecoratorMetadata } from \"@decaf-ts/reflection\";\nimport { Constructor } from \"../model\";\nimport { ValidationKeys, Validator } from \"./Validators\";\nimport { IRegistry } from \"../utils\";\n\n/**\n * @description Type definition for metadata used by validation decorators\n * @summary Defines the structure of metadata attached to properties by validation decorators.\n * This metadata is used during validation to determine validation rules and error messages.\n *\n * @property {any[]} [args] - Optional arguments for the validator\n * @property {string} message - Error message to display when validation fails\n * @property {string[]} [types] - Array of type names that the property can have\n *\n * @typedef {Object} ValidationMetadata\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport type ValidationMetadata = {\n  [indexer: string]: any;\n  args?: any[];\n  message: string;\n  types?: string[];\n};\n\n/**\n * @description Type definition for property-level validation decorator configuration\n * @summary Defines the structure that associates a property with its validation decorators.\n * This type is used to track which decorators are applied to a specific property during validation.\n *\n * @property {string|symbol} prop - The property name or symbol that the decorators are applied to\n * @property {ValidationDecoratorDefinition[]} decorators - Array of decorator definitions applied to the property\n *\n * @typedef {Object} ValidationPropertyDecoratorDefinition\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport type ValidationPropertyDecoratorDefinition = {\n  prop: string | symbol;\n  decorators: ValidationDecoratorDefinition[];\n};\n\n/**\n * @description Type definition for individual validation decorator metadata\n * @summary Extends the base DecoratorMetadata type with validation-specific properties.\n * This type represents the metadata for a single validation decorator applied to a property.\n *\n * @property {ValidationElementDefinition} props - The validation element properties and configuration\n *\n * @typedef {Object} ValidationDecoratorDefinition\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport type ValidationDecoratorDefinition = DecoratorMetadata & {\n  props: ValidationElementDefinition;\n};\n\n/**\n * @summary Type for a validator element metadata\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport type ValidationElementDefinition = {\n  [indexer: string]: any;\n\n  value?: string | number;\n  message: string;\n  description: string;\n  types?: string[];\n};\n\n/**\n * @summary Type for a model errors\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport type ModelErrors = Record<string, Record<string, string | undefined>>;\n\n/**\n * @summary Util type for {@link Validator} configuration\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport type ValidatorDefinition = {\n  validator: Constructor<Validator>;\n  validationKey: string;\n  save: boolean;\n};\n\n/**\n * @description Interface for a registry that manages validator instances\n * @summary Defines the contract for a registry that stores and retrieves validators.\n * The registry is responsible for maintaining a collection of validators and providing\n * access to them by key.\n *\n * @interface IValidatorRegistry\n * @template T Type of validator, must extend Validator\n * @extends IRegistry<T>\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface IValidatorRegistry<T extends Validator> extends IRegistry<T> {\n  /**\n   * @description Retrieves custom validation keys defined in the registry\n   * @summary Returns a mapping of custom validation keys to their corresponding standard keys.\n   * This allows for aliasing validation keys for specific use cases.\n   *\n   * @return {Record<string, string>} Object mapping custom keys to standard validation keys\n   */\n  getCustomKeys(): Record<string, string>;\n\n  /**\n   * @description Gets all registered validator keys\n   * @summary Returns an array of all validation keys that have registered validators.\n   *\n   * @return {string[]} Array of registered validator keys\n   */\n  getKeys(): string[];\n\n  /**\n   * @description Registers one or more validators with the registry\n   * @summary Adds validators to the registry, making them available for validation operations.\n   * Validators can be provided as instances or as validator definitions.\n   *\n   * @param {...(T|ValidatorDefinition)} validator - Validator instances or definitions to register\n   * @return {void}\n   */\n  register<T extends Validator>(\n    ...validator: (T | ValidatorDefinition)[]\n  ): void;\n\n  /**\n   * @description Retrieves a validator by its key\n   * @summary Looks up a validator in the registry using its validation key.\n   * Returns the validator if found, or undefined if no validator is registered for the key.\n   *\n   * @param {string} key - The validation key to look up, typically one of the {@link ValidationKeys}\n   * @return {T|undefined} The registered validator or undefined if none matches the provided key\n   */\n  get<T extends Validator>(key: string): T | undefined;\n}\n\n/**\n * @description Base options type for all validators\n * @summary Defines the common properties available to all validators\n * @interface ValidatorOptions\n * @property {string} [message] - Custom error message to display when validation fails\n * @category Validation\n */\nexport interface ValidatorOptions {\n  message?: string;\n  description?: string;\n}\n\n/**\n * @description URL validation options interface\n * @summary Defines options for URL validation, including allowed URL types\n * @interface URLValidatorOptions\n * @property {(string|string[]|{ name: string })} types - Specifies the allowed URL types or patterns\n * @category Validation\n */\nexport interface URLValidatorOptions extends ValidatorOptions {\n  types: string | string[] | { name: string };\n}\n\n/**\n * @description Type validation options interface\n * @summary Defines options for type validation, specifying allowed types\n * @interface TypeValidatorOptions\n * @property {(string|string[]|{ name: string })} types - Specifies the allowed data types\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface TypeValidatorOptions extends ValidatorOptions {\n  types: string | string[] | { name: string };\n}\n\n/**\n * @description Step validation options interface\n * @summary Defines options for step validation, specifying the step increment\n * @interface StepValidatorOptions\n * @property {(number|string)} [ValidationKeys.STEP] - The step value for numerical validation\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface StepValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.STEP]: number | string;\n  types?: string[];\n}\n\n/**\n * @description Pattern validation options interface\n * @summary Defines options for pattern validation using regular expressions\n * @interface PatternValidatorOptions\n * @property {(RegExp|string)} [ValidationKeys.PATTERN] - The pattern to match against\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface PatternValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.PATTERN]?: RegExp | string;\n  types?: string[];\n}\n\n/**\n * @description Minimum value validation options interface\n * @summary Defines options for minimum value validation\n * @interface MinValidatorOptions\n * @property {(number|Date|string)} [ValidationKeys.MIN] - The minimum allowed value\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface MinValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.MIN]: number | Date | string;\n  types?: string[];\n}\n\n/**\n * @description Minimum length validation options interface\n * @summary Defines options for minimum length validation\n * @interface MinLengthValidatorOptions\n * @property {number} [ValidationKeys.MIN_LENGTH] - The minimum allowed length\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface MinLengthValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.MIN_LENGTH]: number;\n  types?: string[];\n}\n\n/**\n * @description Maximum value validation options interface\n * @summary Defines options for maximum value validation\n * @interface MaxValidatorOptions\n * @property {(number|Date|string)} [ValidationKeys.MAX] - The maximum allowed value\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface MaxValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.MAX]: number | Date | string;\n  types?: string[];\n}\n\n/**\n * @description Maximum length validation options interface\n * @summary Defines options for maximum length validation\n * @interface MaxLengthValidatorOptions\n * @property {number} [ValidationKeys.MAX_LENGTH] - The maximum allowed length\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface MaxLengthValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.MAX_LENGTH]: number;\n  types?: string[];\n}\n\n/**\n * @description List validation options interface\n * @summary Defines options for list validation\n * @interface ListValidatorOptions\n * @property {string[]} clazz - Array of allowed class names or types\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface ListValidatorOptions extends ValidatorOptions {\n  clazz: string[];\n}\n\n/**\n * @description Date validation options interface\n * @summary Defines options for date validation\n * @interface DateValidatorOptions\n * @property {string} [ValidationKeys.FORMAT] - The expected date format pattern\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport interface DateValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.FORMAT]?: string;\n}\n\nexport interface EqualsValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.EQUALS]: string;\n}\n\nexport interface DiffValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.DIFF]: string;\n}\n\nexport interface LessThanValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.LESS_THAN]: string;\n}\n\nexport interface LessThanOrEqualValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.LESS_THAN_OR_EQUAL]: string;\n}\n\nexport interface GreaterThanValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.GREATER_THAN]: string;\n}\n\nexport interface GreaterThanOrEqualValidatorOptions extends ValidatorOptions {\n  [ValidationKeys.GREATER_THAN_OR_EQUAL]: string;\n}\n"]}

package/lib/index.cjs

@@ -32,5 +32,5 @@ __exportStar(require("./model/index.cjs"), exports);
  * @const VERSION
  * @memberOf module:decorator-validation
  */
-exports.VERSION = "1.7.3";
+exports.VERSION = "1.7.5";
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTs7Ozs7O0dBTUc7QUFDSCx3REFBNEI7QUFDNUIsb0RBQXdCO0FBQ3hCLHlEQUE2QjtBQUM3QixvREFBd0I7QUFFeEI7Ozs7O0dBS0c7QUFDVSxRQUFBLE9BQU8sR0FBRyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgZGVjb3JhdG9yLXZhbGlkYXRpb25cbiAqIEBkZXNjcmlwdGlvbiBUeXBlU2NyaXB0IGRlY29yYXRvci1iYXNlZCB2YWxpZGF0aW9uIGxpYnJhcnlcbiAqIEBzdW1tYXJ5IFRoaXMgbW9kdWxlIHByb3ZpZGVzIGEgY29tcHJlaGVuc2l2ZSB2YWxpZGF0aW9uIGZyYW1ld29yayB1c2luZyBUeXBlU2NyaXB0IGRlY29yYXRvcnMuXG4gKiBJdCBleHBvc2VzIHV0aWxpdHkgZnVuY3Rpb25zLCB2YWxpZGF0aW9uIGRlY29yYXRvcnMsIGFuZCBtb2RlbC1yZWxhdGVkIGZ1bmN0aW9uYWxpdHkgZm9yXG4gKiBpbXBsZW1lbnRpbmcgdHlwZS1zYWZlLCBkZWNsYXJhdGl2ZSB2YWxpZGF0aW9uIGluIFR5cGVTY3JpcHQgYXBwbGljYXRpb25zLlxuICovXG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi92YWxpZGF0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tb2RlbFwiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBDdXJyZW50IHZlcnNpb24gb2YgdGhlIHJlZmxlY3Rpb24gcGFja2FnZVxuICogQHN1bW1hcnkgU3RvcmVzIHRoZSBzZW1hbnRpYyB2ZXJzaW9uIG51bWJlciBvZiB0aGUgcGFja2FnZVxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6ZGVjb3JhdG9yLXZhbGlkYXRpb25cbiAqL1xuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBcIiMjVkVSU0lPTiMjXCI7XG4iXX0=

package/lib/index.d.ts

@@ -15,4 +15,4 @@ export * from "./model";
  * @const VERSION
  * @memberOf module:decorator-validation
  */
-export declare const VERSION = "1.7.3";
+export declare const VERSION = "1.7.5";

package/lib/mcp/ModelContextProtocol.cjs

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelContextProtocol = void 0;
+const fastmcp_1 = require("fastmcp");
+const logging_1 = require("@decaf-ts/logging");
+class ModelContextProtocol {
+    get log() {
+        return logging_1.Logging.for(this);
+    }
+    constructor(mcp) {
+        this.mcp = mcp;
+    }
+    static { this.Builder = class Builder {
+        constructor() {
+            this.tools = {};
+            this.log = logging_1.Logging.for("MCP Builder");
+        }
+        setName(value) {
+            this.name = value;
+            this.log.debug(`name set to ${value}`);
+            return this;
+        }
+        setVersion(value) {
+            this.version = ModelContextProtocol.validateVersion(value);
+            this.log.debug(`version set to ${value}`);
+            return this;
+        }
+        addTool(config) {
+            const { name } = config;
+            if (name in this.tools)
+                throw new Error(`tool ${name} already registered`);
+            this.tools[name] = config;
+            this.log.debug(`tool ${name} added`);
+            return this;
+        }
+        build() {
+            if (!this.name)
+                throw new Error("name is required");
+            if (!this.version)
+                throw new Error("version is required");
+            const mcp = new fastmcp_1.FastMCP({
+                name: this.name,
+                version: this.version,
+            });
+            Object.values(this.tools).forEach((tool) => {
+                try {
+                    mcp.addTool(tool);
+                }
+                catch (e) {
+                    throw new Error(`Failed to add tool ${tool.name}: ${e}`);
+                }
+            });
+            this.log.info(`${this.name} MCP built`);
+            this.log.debug(`${this.name} MCP - available tools: ${Object.keys(this.tools).join(", ")}`);
+            return new ModelContextProtocol(mcp);
+        }
+    }; }
+    static get builder() {
+        return new ModelContextProtocol.Builder();
+    }
+    static validateVersion(version) {
+        const regexp = /(\d+)\.(\d+)\.(\d+)/g;
+        const match = regexp.exec(version);
+        if (!match)
+            throw new Error(`Invalid version string. should obey semantic versioning: ${version}`);
+        return `${match[1]}.${match[2]}.${match[3]}`;
+    }
+}
+exports.ModelContextProtocol = ModelContextProtocol;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mcp/ModelContextProtocol.d.ts

@@ -0,0 +1,31 @@
+import { FastMCP, Tool } from "fastmcp";
+import { Logger } from "@decaf-ts/logging";
+import { FastMCPSessionAuth } from "./types";
+export declare class ModelContextProtocol<Auth extends FastMCPSessionAuth = undefined> {
+    protected readonly mcp: FastMCP<Auth>;
+    protected get log(): Logger;
+    constructor(mcp: FastMCP<Auth>);
+    static readonly Builder: {
+        new (): {
+            name: string;
+            version: `${number}.${number}.${number}`;
+            tools: Record<string, Tool<any, any>>;
+            log: Logger;
+            setName(value: string): /*elided*/ any;
+            setVersion(value: string): /*elided*/ any;
+            addTool<Auth_1 extends FastMCPSessionAuth = undefined>(config: Tool<Auth_1, any>): /*elided*/ any;
+            build<Auth_1 extends FastMCPSessionAuth = undefined>(): ModelContextProtocol<Auth_1>;
+        };
+    };
+    static get builder(): {
+        name: string;
+        version: `${number}.${number}.${number}`;
+        tools: Record<string, Tool<any, any>>;
+        log: Logger;
+        setName(value: string): /*elided*/ any;
+        setVersion(value: string): /*elided*/ any;
+        addTool<Auth extends FastMCPSessionAuth = undefined>(config: Tool<Auth, any>): /*elided*/ any;
+        build<Auth extends FastMCPSessionAuth = undefined>(): ModelContextProtocol<Auth>;
+    };
+    private static validateVersion;
+}