@decaf-ts/decorator-validation 1.7.4 → 1.7.6

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.4";
+exports.VERSION = "1.7.6";
 //# 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.4";
+export declare const VERSION = "1.7.6";

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTW9kZWxDb250ZXh0UHJvdG9jb2wuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWNwL01vZGVsQ29udGV4dFByb3RvY29sLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFDQUF3QztBQUN4QywrQ0FBb0Q7QUFHcEQsTUFBYSxvQkFBb0I7SUFDL0IsSUFBYyxHQUFHO1FBQ2YsT0FBTyxpQkFBTyxDQUFDLEdBQUcsQ0FBQyxJQUFXLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBRUQsWUFBK0IsR0FBa0I7UUFBbEIsUUFBRyxHQUFILEdBQUcsQ0FBZTtJQUFHLENBQUM7YUFFckMsWUFBTyxHQUFHLE1BQU0sT0FBTztRQU9yQztZQUpBLFVBQUssR0FBbUMsRUFBRSxDQUFDO1lBRTNDLFFBQUcsR0FBRyxpQkFBTyxDQUFDLEdBQUcsQ0FBQyxhQUFhLENBQUMsQ0FBQztRQUVsQixDQUFDO1FBRWhCLE9BQU8sQ0FBQyxLQUFhO1lBQ25CLElBQUksQ0FBQyxJQUFJLEdBQUcsS0FBSyxDQUFDO1lBQ2xCLElBQUksQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLGVBQWUsS0FBSyxFQUFFLENBQUMsQ0FBQztZQUN2QyxPQUFPLElBQUksQ0FBQztRQUNkLENBQUM7UUFFRCxVQUFVLENBQUMsS0FBYTtZQUN0QixJQUFJLENBQUMsT0FBTyxHQUFHLG9CQUFvQixDQUFDLGVBQWUsQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUMzRCxJQUFJLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxrQkFBa0IsS0FBSyxFQUFFLENBQUMsQ0FBQztZQUMxQyxPQUFPLElBQUksQ0FBQztRQUNkLENBQUM7UUFFRCxPQUFPLENBQ0wsTUFBdUI7WUFFdkIsTUFBTSxFQUFFLElBQUksRUFBRSxHQUFHLE1BQU0sQ0FBQztZQUN4QixJQUFJLElBQUksSUFBSSxJQUFJLENBQUMsS0FBSztnQkFDcEIsTUFBTSxJQUFJLEtBQUssQ0FBQyxRQUFRLElBQUkscUJBQXFCLENBQUMsQ0FBQztZQUNyRCxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLE1BQU0sQ0FBQztZQUMxQixJQUFJLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxRQUFRLElBQUksUUFBUSxDQUFDLENBQUM7WUFDckMsT0FBTyxJQUFJLENBQUM7UUFDZCxDQUFDO1FBRUQsS0FBSztZQUdILElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSTtnQkFBRSxNQUFNLElBQUksS0FBSyxDQUFDLGtCQUFrQixDQUFDLENBQUM7WUFDcEQsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPO2dCQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMscUJBQXFCLENBQUMsQ0FBQztZQUMxRCxNQUFNLEdBQUcsR0FBRyxJQUFJLGlCQUFPLENBQU87Z0JBQzVCLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSTtnQkFDZixPQUFPLEVBQUUsSUFBSSxDQUFDLE9BQU87YUFDdEIsQ0FBQyxDQUFDO1lBQ0gsTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUU7Z0JBQ3pDLElBQUksQ0FBQztvQkFDSCxHQUFHLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO2dCQUNwQixDQUFDO2dCQUFDLE9BQU8sQ0FBVSxFQUFFLENBQUM7b0JBQ3BCLE1BQU0sSUFBSSxLQUFLLENBQUMsc0JBQXNCLElBQUksQ0FBQyxJQUFJLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQztnQkFDM0QsQ0FBQztZQUNILENBQUMsQ0FBQyxDQUFDO1lBQ0gsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsSUFBSSxZQUFZLENBQUMsQ0FBQztZQUN4QyxJQUFJLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FDWixHQUFHLElBQUksQ0FBQyxJQUFJLDJCQUEyQixNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FDNUUsQ0FBQztZQUNGLE9BQU8sSUFBSSxvQkFBb0IsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUN2QyxDQUFDO0tBQ0YsQ0FBQztJQUVGLE1BQU0sS0FBSyxPQUFPO1FBQ2hCLE9BQU8sSUFBSSxvQkFBb0IsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUM1QyxDQUFDO0lBRU8sTUFBTSxDQUFDLGVBQWUsQ0FDNUIsT0FBZTtRQUVmLE1BQU0sTUFBTSxHQUFHLHNCQUFzQixDQUFDO1FBQ3RDLE1BQU0sS0FBSyxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDbkMsSUFBSSxDQUFDLEtBQUs7WUFDUixNQUFNLElBQUksS0FBSyxDQUNiLDREQUE0RCxPQUFPLEVBQUUsQ0FDdEUsQ0FBQztRQUNKLE9BQU8sR0FBRyxLQUFLLENBQUMsQ0FBQyxDQUFDLElBQUksS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUssQ0FBQyxDQUFDLENBQUMsRUFBcUMsQ0FBQztJQUNsRixDQUFDOztBQTdFSCxvREE4RUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGYXN0TUNQLCBUb29sIH0gZnJvbSBcImZhc3RtY3BcIjtcbmltcG9ydCB7IExvZ2dlciwgTG9nZ2luZyB9IGZyb20gXCJAZGVjYWYtdHMvbG9nZ2luZ1wiO1xuaW1wb3J0IHsgRmFzdE1DUFNlc3Npb25BdXRoIH0gZnJvbSBcIi4vdHlwZXNcIjtcblxuZXhwb3J0IGNsYXNzIE1vZGVsQ29udGV4dFByb3RvY29sPEF1dGggZXh0ZW5kcyBGYXN0TUNQU2Vzc2lvbkF1dGggPSB1bmRlZmluZWQ+IHtcbiAgcHJvdGVjdGVkIGdldCBsb2coKTogTG9nZ2VyIHtcbiAgICByZXR1cm4gTG9nZ2luZy5mb3IodGhpcyBhcyBhbnkpO1xuICB9XG5cbiAgY29uc3RydWN0b3IocHJvdGVjdGVkIHJlYWRvbmx5IG1jcDogRmFzdE1DUDxBdXRoPikge31cblxuICBzdGF0aWMgcmVhZG9ubHkgQnVpbGRlciA9IGNsYXNzIEJ1aWxkZXIge1xuICAgIG5hbWUhOiBzdHJpbmc7XG4gICAgdmVyc2lvbiE6IGAke251bWJlcn0uJHtudW1iZXJ9LiR7bnVtYmVyfWA7XG4gICAgdG9vbHM6IFJlY29yZDxzdHJpbmcsIFRvb2w8YW55LCBhbnk+PiA9IHt9O1xuXG4gICAgbG9nID0gTG9nZ2luZy5mb3IoXCJNQ1AgQnVpbGRlclwiKTtcblxuICAgIGNvbnN0cnVjdG9yKCkge31cblxuICAgIHNldE5hbWUodmFsdWU6IHN0cmluZykge1xuICAgICAgdGhpcy5uYW1lID0gdmFsdWU7XG4gICAgICB0aGlzLmxvZy5kZWJ1ZyhgbmFtZSBzZXQgdG8gJHt2YWx1ZX1gKTtcbiAgICAgIHJldHVybiB0aGlzO1xuICAgIH1cblxuICAgIHNldFZlcnNpb24odmFsdWU6IHN0cmluZykge1xuICAgICAgdGhpcy52ZXJzaW9uID0gTW9kZWxDb250ZXh0UHJvdG9jb2wudmFsaWRhdGVWZXJzaW9uKHZhbHVlKTtcbiAgICAgIHRoaXMubG9nLmRlYnVnKGB2ZXJzaW9uIHNldCB0byAke3ZhbHVlfWApO1xuICAgICAgcmV0dXJuIHRoaXM7XG4gICAgfVxuXG4gICAgYWRkVG9vbDxBdXRoIGV4dGVuZHMgRmFzdE1DUFNlc3Npb25BdXRoID0gdW5kZWZpbmVkPihcbiAgICAgIGNvbmZpZzogVG9vbDxBdXRoLCBhbnk+XG4gICAgKSB7XG4gICAgICBjb25zdCB7IG5hbWUgfSA9IGNvbmZpZztcbiAgICAgIGlmIChuYW1lIGluIHRoaXMudG9vbHMpXG4gICAgICAgIHRocm93IG5ldyBFcnJvcihgdG9vbCAke25hbWV9IGFscmVhZHkgcmVnaXN0ZXJlZGApO1xuICAgICAgdGhpcy50b29sc1tuYW1lXSA9IGNvbmZpZztcbiAgICAgIHRoaXMubG9nLmRlYnVnKGB0b29sICR7bmFtZX0gYWRkZWRgKTtcbiAgICAgIHJldHVybiB0aGlzO1xuICAgIH1cblxuICAgIGJ1aWxkPFxuICAgICAgQXV0aCBleHRlbmRzIEZhc3RNQ1BTZXNzaW9uQXV0aCA9IHVuZGVmaW5lZCxcbiAgICA+KCk6IE1vZGVsQ29udGV4dFByb3RvY29sPEF1dGg+IHtcbiAgICAgIGlmICghdGhpcy5uYW1lKSB0aHJvdyBuZXcgRXJyb3IoXCJuYW1lIGlzIHJlcXVpcmVkXCIpO1xuICAgICAgaWYgKCF0aGlzLnZlcnNpb24pIHRocm93IG5ldyBFcnJvcihcInZlcnNpb24gaXMgcmVxdWlyZWRcIik7XG4gICAgICBjb25zdCBtY3AgPSBuZXcgRmFzdE1DUDxBdXRoPih7XG4gICAgICAgIG5hbWU6IHRoaXMubmFtZSxcbiAgICAgICAgdmVyc2lvbjogdGhpcy52ZXJzaW9uLFxuICAgICAgfSk7XG4gICAgICBPYmplY3QudmFsdWVzKHRoaXMudG9vbHMpLmZvckVhY2goKHRvb2wpID0+IHtcbiAgICAgICAgdHJ5IHtcbiAgICAgICAgICBtY3AuYWRkVG9vbCh0b29sKTtcbiAgICAgICAgfSBjYXRjaCAoZTogdW5rbm93bikge1xuICAgICAgICAgIHRocm93IG5ldyBFcnJvcihgRmFpbGVkIHRvIGFkZCB0b29sICR7dG9vbC5uYW1lfTogJHtlfWApO1xuICAgICAgICB9XG4gICAgICB9KTtcbiAgICAgIHRoaXMubG9nLmluZm8oYCR7dGhpcy5uYW1lfSBNQ1AgYnVpbHRgKTtcbiAgICAgIHRoaXMubG9nLmRlYnVnKFxuICAgICAgICBgJHt0aGlzLm5hbWV9IE1DUCAtIGF2YWlsYWJsZSB0b29sczogJHtPYmplY3Qua2V5cyh0aGlzLnRvb2xzKS5qb2luKFwiLCBcIil9YFxuICAgICAgKTtcbiAgICAgIHJldHVybiBuZXcgTW9kZWxDb250ZXh0UHJvdG9jb2wobWNwKTtcbiAgICB9XG4gIH07XG5cbiAgc3RhdGljIGdldCBidWlsZGVyKCkge1xuICAgIHJldHVybiBuZXcgTW9kZWxDb250ZXh0UHJvdG9jb2wuQnVpbGRlcigpO1xuICB9XG5cbiAgcHJpdmF0ZSBzdGF0aWMgdmFsaWRhdGVWZXJzaW9uKFxuICAgIHZlcnNpb246IHN0cmluZ1xuICApOiBgJHtudW1iZXJ9LiR7bnVtYmVyfS4ke251bWJlcn1gIHtcbiAgICBjb25zdCByZWdleHAgPSAvKFxcZCspXFwuKFxcZCspXFwuKFxcZCspL2c7XG4gICAgY29uc3QgbWF0Y2ggPSByZWdleHAuZXhlYyh2ZXJzaW9uKTtcbiAgICBpZiAoIW1hdGNoKVxuICAgICAgdGhyb3cgbmV3IEVycm9yKFxuICAgICAgICBgSW52YWxpZCB2ZXJzaW9uIHN0cmluZy4gc2hvdWxkIG9iZXkgc2VtYW50aWMgdmVyc2lvbmluZzogJHt2ZXJzaW9ufWBcbiAgICAgICk7XG4gICAgcmV0dXJuIGAke21hdGNoWzFdfS4ke21hdGNoWzJdfS4ke21hdGNoWzNdfWAgYXMgYCR7bnVtYmVyfS4ke251bWJlcn0uJHtudW1iZXJ9YDtcbiAgfVxufVxuIl19

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;
+}

package/lib/mcp/mcp1.cjs

@@ -0,0 +1,405 @@
+"use strict";
+// import { FastMCP } from "fastmcp";
+// import { z } from "zod";
+// import { version } from "../../package.json";
+// import { ModelContextProtocol } from "./ModelContextProtocol";
+// import { Model } from "../model";
+// import {
+//   email,
+//   max,
+//   maxlength,
+//   min,
+//   minlength,
+//   pattern,
+//   required,
+// } from "../validation";
+// import { createModelTool } from "./tools/createModel.tool";
+//
+// const DecoratorValidatonMCP = ModelContextProtocol.builder
+//   .setName("decaf-validation-server")
+//   .setVersion(version)
+//   .addTool(createModelTool)
+//   .build();
+//
+// // Initialize FastMCP server
+// const server = new FastMCP({
+//   name: "decaf-validation-server",
+//   // @ts-ignore
+//   version: version,
+// });
+//
+// // Model registry for dynamic model management
+// const modelRegistry = new Map<string, any>();
+//
+// // Tool: Validate a model instance
+// server.addTool({
+//   name: "validate-model",
+//   description: "Validate a model instance against its decorators",
+//   parameters: z.object({
+//     modelName: z.string().describe("Name of the model class"),
+//     data: z.record(z.any()).describe("Data to validate"),
+//     options: z
+//       .object({
+//         partial: z.boolean().optional().describe("Allow partial validation"),
+//       })
+//       .optional(),
+//   }),
+//   execute: async (args) => {
+//     const { modelName, data, options } = args;
+//
+//     const ModelClass = modelRegistry.get(modelName) || Model.get(modelName);
+//     if (!ModelClass) {
+//       throw new Error(`Model "${modelName}" not found`);
+//     }
+//
+//     try {
+//       const instance = new ModelClass(data);
+//       const errors = instance.hasErrors();
+//
+//       return {
+//         isValid: !errors,
+//         errors: errors || null,
+//         validatedData: errors ? null : instance.serialize(),
+//       };
+//     } catch (error) {
+//       return {
+//         isValid: false,
+//         errors: [{ message: error.message }],
+//         validatedData: null,
+//       };
+//     }
+//   },
+// });
+//
+// // Tool: Get model schema information
+// server.addTool({
+//   name: "get-model-schema",
+//   description: "Get the validation schema for a model",
+//   parameters: z.object({
+//     modelName: z.string().describe("Name of the model class"),
+//   }),
+//   execute: async (args) => {
+//     const { modelName } = args;
+//
+//     const ModelClass = modelRegistry.get(modelName) || Model.get(modelName);
+//     if (!ModelClass) {
+//       throw new Error(`Model "${modelName}" not found`);
+//     }
+//
+//     // Extract validation metadata
+//     const instance = new ModelClass();
+//     const metadata = Reflect.getMetadata("validation", instance) || {};
+//
+//     return {
+//       modelName,
+//       properties: Object.keys(metadata).map((key) => ({
+//         name: key,
+//         validators: metadata[key] || [],
+//       })),
+//       capabilities: {
+//         serialization: !!instance.serialize,
+//         hashing: !!instance.hash,
+//         comparison: !!instance.equals,
+//       },
+//     };
+//   },
+// });
+//
+// // Tool: Serialize model
+// server.addTool({
+//   name: "serialize-model",
+//   description: "Serialize a model instance to string",
+//   parameters: z.object({
+//     modelName: z.string().describe("Name of the model class"),
+//     data: z.record(z.any()).describe("Model data to serialize"),
+//     format: z.enum(["json", "yaml"]).optional().default("json"),
+//   }),
+//   execute: async (args) => {
+//     const { modelName, data, format } = args;
+//
+//     const ModelClass = modelRegistry.get(modelName) || Model.get(modelName);
+//     if (!ModelClass) {
+//       throw new Error(`Model "${modelName}" not found`);
+//     }
+//
+//     const instance = new ModelClass(data);
+//     const errors = instance.hasErrors();
+//
+//     if (errors) {
+//       throw new Error(
+//         `Cannot serialize invalid model: ${JSON.stringify(errors)}`
+//       );
+//     }
+//
+//     return {
+//       serialized: instance.serialize(),
+//       format,
+//       modelName,
+//     };
+//   },
+// });
+//
+// // Tool: Deserialize model
+// server.addTool({
+//   name: "deserialize-model",
+//   description: "Deserialize a string to model instance",
+//   parameters: z.object({
+//     serializedData: z.string().describe("Serialized model data"),
+//     modelName: z
+//       .string()
+//       .optional()
+//       .describe("Expected model name for validation"),
+//   }),
+//   execute: async (args) => {
+//     const { serializedData, modelName } = args;
+//
+//     try {
+//       const instance = Model.deserialize(serializedData);
+//
+//       if (modelName && instance.constructor.name !== modelName) {
+//         throw new Error(
+//           `Expected model "${modelName}", got "${instance.constructor.name}"`
+//         );
+//       }
+//
+//       return {
+//         modelName: instance.constructor.name,
+//         data: JSON.parse(instance.serialize()),
+//         isValid: !instance.hasErrors(),
+//       };
+//     } catch (error) {
+//       throw new Error(`Deserialization failed: ${error.message}`);
+//     }
+//   },
+// });
+//
+// // Tool: Compare models
+// server.addTool({
+//   name: "compare-models",
+//   description: "Compare two model instances for equality",
+//   parameters: z.object({
+//     modelName: z.string().describe("Name of the model class"),
+//     data1: z.record(z.any()).describe("First model data"),
+//     data2: z.record(z.any()).describe("Second model data"),
+//     excludeFields: z
+//       .array(z.string())
+//       .optional()
+//       .describe("Fields to exclude from comparison"),
+//   }),
+//   execute: async (args) => {
+//     const { modelName, data1, data2, excludeFields } = args;
+//
+//     const ModelClass = modelRegistry.get(modelName) || Model.get(modelName);
+//     if (!ModelClass) {
+//       throw new Error(`Model "${modelName}" not found`);
+//     }
+//
+//     const instance1 = new ModelClass(data1);
+//     const instance2 = new ModelClass(data2);
+//
+//     const isEqual = excludeFields
+//       ? instance1.equals(instance2, ...excludeFields)
+//       : instance1.equals(instance2);
+//
+//     return {
+//       isEqual,
+//       hash1: instance1.hash(),
+//       hash2: instance2.hash(),
+//       differences: isEqual ? null : await findDifferences(instance1, instance2),
+//     };
+//   },
+// });
+//
+// // Tool: List available decorators
+// server.addTool({
+//   name: "list-decorators",
+//   description: "List all available validation decorators",
+//   parameters: z.object({
+//     category: z
+//       .enum(["basic", "type-specific", "comparison", "all"])
+//       .optional()
+//       .default("all"),
+//   }),
+//   execute: async (args) => {
+//     const { category } = args;
+//
+//     const decorators = {
+//       basic: [
+//         {
+//           name: "required",
+//           description: "Marks field as required",
+//           args: ["message?"],
+//         },
+//         {
+//           name: "min",
+//           description: "Minimum value validation",
+//           args: ["value", "message?"],
+//         },
+//         {
+//           name: "max",
+//           description: "Maximum value validation",
+//           args: ["value", "message?"],
+//         },
+//         {
+//           name: "minlength",
+//           description: "Minimum length validation",
+//           args: ["length", "message?"],
+//         },
+//         {
+//           name: "maxlength",
+//           description: "Maximum length validation",
+//           args: ["length", "message?"],
+//         },
+//         {
+//           name: "pattern",
+//           description: "Regex pattern validation",
+//           args: ["pattern", "message?"],
+//         },
+//         {
+//           name: "step",
+//           description: "Step value validation",
+//           args: ["step", "message?"],
+//         },
+//       ],
+//       "type-specific": [
+//         {
+//           name: "email",
+//           description: "Email format validation",
+//           args: ["message?"],
+//         },
+//         {
+//           name: "url",
+//           description: "URL format validation",
+//           args: ["message?"],
+//         },
+//         {
+//           name: "date",
+//           description: "Date format validation",
+//           args: ["format?", "message?"],
+//         },
+//         {
+//           name: "password",
+//           description: "Password strength validation",
+//           args: ["message?"],
+//         },
+//         {
+//           name: "type",
+//           description: "Type validation",
+//           args: ["type", "message?"],
+//         },
+//         {
+//           name: "list",
+//           description: "Array validation",
+//           args: ["itemType", "message?"],
+//         },
+//         {
+//           name: "set",
+//           description: "Set validation",
+//           args: ["itemType", "message?"],
+//         },
+//       ],
+//       comparison: [
+//         {
+//           name: "eq",
+//           description: "Equal to another field",
+//           args: ["fieldName", "message?"],
+//         },
+//         {
+//           name: "diff",
+//           description: "Different from another field",
+//           args: ["fieldName", "message?"],
+//         },
+//         {
+//           name: "lt",
+//           description: "Less than another field",
+//           args: ["fieldName", "message?"],
+//         },
+//         {
+//           name: "lte",
+//           description: "Less than or equal to another field",
+//           args: ["fieldName", "message?"],
+//         },
+//         {
+//           name: "gt",
+//           description: "Greater than another field",
+//           args: ["fieldName", "message?"],
+//         },
+//         {
+//           name: "gte",
+//           description: "Greater than or equal to another field",
+//           args: ["fieldName", "message?"],
+//         },
+//       ],
+//     };
+//
+//     if (category === "all") {
+//       return {
+//         categories: decorators,
+//         total: Object.values(decorators).reduce(
+//           (sum, arr) => sum + arr.length,
+//           0
+//         ),
+//       };
+//     }
+//
+//     return {
+//       category,
+//       decorators: decorators[category] || [],
+//       count: decorators[category]?.length || 0,
+//     };
+//   },
+// });
+//
+// // Utility function to get decorator function by name
+// function getDecoratorFunction(name: string): Function | null {
+//   const decoratorMap = {
+//     required,
+//     email,
+//     min,
+//     max,
+//     minlength,
+//     maxlength,
+//     pattern,
+//     url,
+//     date,
+//     password,
+//     list,
+//     set,
+//     eq,
+//     diff,
+//     lt,
+//     lte,
+//     gt,
+//     gte,
+//     type,
+//     step,
+//   };
+//   return decoratorMap[name] || null;
+// }
+//
+// // Utility function to find differences between models
+// async function findDifferences(instance1: any, instance2: any): Promise<any[]> {
+//   const differences = [];
+//   const serialized1 = JSON.parse(instance1.serialize());
+//   const serialized2 = JSON.parse(instance2.serialize());
+//
+//   for (const key in serialized1) {
+//     if (serialized1[key] !== serialized2[key]) {
+//       differences.push({
+//         field: key,
+//         value1: serialized1[key],
+//         value2: serialized2[key],
+//       });
+//     }
+//   }
+//
+//   return differences;
+// }
+//
+// // Start the server
+// server.start({
+//   transportType: "stdio",
+// });
+//
+// export { server };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mcp1.js","sourceRoot":"","sources":["../../src/mcp/mcp1.ts"],"names":[],"mappings":"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","sourcesContent":["// import { FastMCP } from \"fastmcp\";\n// import { z } from \"zod\";\n// import { version } from \"../../package.json\";\n// import { ModelContextProtocol } from \"./ModelContextProtocol\";\n// import { Model } from \"../model\";\n// import {\n//   email,\n//   max,\n//   maxlength,\n//   min,\n//   minlength,\n//   pattern,\n//   required,\n// } from \"../validation\";\n// import { createModelTool } from \"./tools/createModel.tool\";\n//\n// const DecoratorValidatonMCP = ModelContextProtocol.builder\n//   .setName(\"decaf-validation-server\")\n//   .setVersion(version)\n//   .addTool(createModelTool)\n//   .build();\n//\n// // Initialize FastMCP server\n// const server = new FastMCP({\n//   name: \"decaf-validation-server\",\n//   // @ts-ignore\n//   version: version,\n// });\n//\n// // Model registry for dynamic model management\n// const modelRegistry = new Map<string, any>();\n//\n// // Tool: Validate a model instance\n// server.addTool({\n//   name: \"validate-model\",\n//   description: \"Validate a model instance against its decorators\",\n//   parameters: z.object({\n//     modelName: z.string().describe(\"Name of the model class\"),\n//     data: z.record(z.any()).describe(\"Data to validate\"),\n//     options: z\n//       .object({\n//         partial: z.boolean().optional().describe(\"Allow partial validation\"),\n//       })\n//       .optional(),\n//   }),\n//   execute: async (args) => {\n//     const { modelName, data, options } = args;\n//\n//     const ModelClass = modelRegistry.get(modelName) || Model.get(modelName);\n//     if (!ModelClass) {\n//       throw new Error(`Model \"${modelName}\" not found`);\n//     }\n//\n//     try {\n//       const instance = new ModelClass(data);\n//       const errors = instance.hasErrors();\n//\n//       return {\n//         isValid: !errors,\n//         errors: errors || null,\n//         validatedData: errors ? null : instance.serialize(),\n//       };\n//     } catch (error) {\n//       return {\n//         isValid: false,\n//         errors: [{ message: error.message }],\n//         validatedData: null,\n//       };\n//     }\n//   },\n// });\n//\n// // Tool: Get model schema information\n// server.addTool({\n//   name: \"get-model-schema\",\n//   description: \"Get the validation schema for a model\",\n//   parameters: z.object({\n//     modelName: z.string().describe(\"Name of the model class\"),\n//   }),\n//   execute: async (args) => {\n//     const { modelName } = args;\n//\n//     const ModelClass = modelRegistry.get(modelName) || Model.get(modelName);\n//     if (!ModelClass) {\n//       throw new Error(`Model \"${modelName}\" not found`);\n//     }\n//\n//     // Extract validation metadata\n//     const instance = new ModelClass();\n//     const metadata = Reflect.getMetadata(\"validation\", instance) || {};\n//\n//     return {\n//       modelName,\n//       properties: Object.keys(metadata).map((key) => ({\n//         name: key,\n//         validators: metadata[key] || [],\n//       })),\n//       capabilities: {\n//         serialization: !!instance.serialize,\n//         hashing: !!instance.hash,\n//         comparison: !!instance.equals,\n//       },\n//     };\n//   },\n// });\n//\n// // Tool: Serialize model\n// server.addTool({\n//   name: \"serialize-model\",\n//   description: \"Serialize a model instance to string\",\n//   parameters: z.object({\n//     modelName: z.string().describe(\"Name of the model class\"),\n//     data: z.record(z.any()).describe(\"Model data to serialize\"),\n//     format: z.enum([\"json\", \"yaml\"]).optional().default(\"json\"),\n//   }),\n//   execute: async (args) => {\n//     const { modelName, data, format } = args;\n//\n//     const ModelClass = modelRegistry.get(modelName) || Model.get(modelName);\n//     if (!ModelClass) {\n//       throw new Error(`Model \"${modelName}\" not found`);\n//     }\n//\n//     const instance = new ModelClass(data);\n//     const errors = instance.hasErrors();\n//\n//     if (errors) {\n//       throw new Error(\n//         `Cannot serialize invalid model: ${JSON.stringify(errors)}`\n//       );\n//     }\n//\n//     return {\n//       serialized: instance.serialize(),\n//       format,\n//       modelName,\n//     };\n//   },\n// });\n//\n// // Tool: Deserialize model\n// server.addTool({\n//   name: \"deserialize-model\",\n//   description: \"Deserialize a string to model instance\",\n//   parameters: z.object({\n//     serializedData: z.string().describe(\"Serialized model data\"),\n//     modelName: z\n//       .string()\n//       .optional()\n//       .describe(\"Expected model name for validation\"),\n//   }),\n//   execute: async (args) => {\n//     const { serializedData, modelName } = args;\n//\n//     try {\n//       const instance = Model.deserialize(serializedData);\n//\n//       if (modelName && instance.constructor.name !== modelName) {\n//         throw new Error(\n//           `Expected model \"${modelName}\", got \"${instance.constructor.name}\"`\n//         );\n//       }\n//\n//       return {\n//         modelName: instance.constructor.name,\n//         data: JSON.parse(instance.serialize()),\n//         isValid: !instance.hasErrors(),\n//       };\n//     } catch (error) {\n//       throw new Error(`Deserialization failed: ${error.message}`);\n//     }\n//   },\n// });\n//\n// // Tool: Compare models\n// server.addTool({\n//   name: \"compare-models\",\n//   description: \"Compare two model instances for equality\",\n//   parameters: z.object({\n//     modelName: z.string().describe(\"Name of the model class\"),\n//     data1: z.record(z.any()).describe(\"First model data\"),\n//     data2: z.record(z.any()).describe(\"Second model data\"),\n//     excludeFields: z\n//       .array(z.string())\n//       .optional()\n//       .describe(\"Fields to exclude from comparison\"),\n//   }),\n//   execute: async (args) => {\n//     const { modelName, data1, data2, excludeFields } = args;\n//\n//     const ModelClass = modelRegistry.get(modelName) || Model.get(modelName);\n//     if (!ModelClass) {\n//       throw new Error(`Model \"${modelName}\" not found`);\n//     }\n//\n//     const instance1 = new ModelClass(data1);\n//     const instance2 = new ModelClass(data2);\n//\n//     const isEqual = excludeFields\n//       ? instance1.equals(instance2, ...excludeFields)\n//       : instance1.equals(instance2);\n//\n//     return {\n//       isEqual,\n//       hash1: instance1.hash(),\n//       hash2: instance2.hash(),\n//       differences: isEqual ? null : await findDifferences(instance1, instance2),\n//     };\n//   },\n// });\n//\n// // Tool: List available decorators\n// server.addTool({\n//   name: \"list-decorators\",\n//   description: \"List all available validation decorators\",\n//   parameters: z.object({\n//     category: z\n//       .enum([\"basic\", \"type-specific\", \"comparison\", \"all\"])\n//       .optional()\n//       .default(\"all\"),\n//   }),\n//   execute: async (args) => {\n//     const { category } = args;\n//\n//     const decorators = {\n//       basic: [\n//         {\n//           name: \"required\",\n//           description: \"Marks field as required\",\n//           args: [\"message?\"],\n//         },\n//         {\n//           name: \"min\",\n//           description: \"Minimum value validation\",\n//           args: [\"value\", \"message?\"],\n//         },\n//         {\n//           name: \"max\",\n//           description: \"Maximum value validation\",\n//           args: [\"value\", \"message?\"],\n//         },\n//         {\n//           name: \"minlength\",\n//           description: \"Minimum length validation\",\n//           args: [\"length\", \"message?\"],\n//         },\n//         {\n//           name: \"maxlength\",\n//           description: \"Maximum length validation\",\n//           args: [\"length\", \"message?\"],\n//         },\n//         {\n//           name: \"pattern\",\n//           description: \"Regex pattern validation\",\n//           args: [\"pattern\", \"message?\"],\n//         },\n//         {\n//           name: \"step\",\n//           description: \"Step value validation\",\n//           args: [\"step\", \"message?\"],\n//         },\n//       ],\n//       \"type-specific\": [\n//         {\n//           name: \"email\",\n//           description: \"Email format validation\",\n//           args: [\"message?\"],\n//         },\n//         {\n//           name: \"url\",\n//           description: \"URL format validation\",\n//           args: [\"message?\"],\n//         },\n//         {\n//           name: \"date\",\n//           description: \"Date format validation\",\n//           args: [\"format?\", \"message?\"],\n//         },\n//         {\n//           name: \"password\",\n//           description: \"Password strength validation\",\n//           args: [\"message?\"],\n//         },\n//         {\n//           name: \"type\",\n//           description: \"Type validation\",\n//           args: [\"type\", \"message?\"],\n//         },\n//         {\n//           name: \"list\",\n//           description: \"Array validation\",\n//           args: [\"itemType\", \"message?\"],\n//         },\n//         {\n//           name: \"set\",\n//           description: \"Set validation\",\n//           args: [\"itemType\", \"message?\"],\n//         },\n//       ],\n//       comparison: [\n//         {\n//           name: \"eq\",\n//           description: \"Equal to another field\",\n//           args: [\"fieldName\", \"message?\"],\n//         },\n//         {\n//           name: \"diff\",\n//           description: \"Different from another field\",\n//           args: [\"fieldName\", \"message?\"],\n//         },\n//         {\n//           name: \"lt\",\n//           description: \"Less than another field\",\n//           args: [\"fieldName\", \"message?\"],\n//         },\n//         {\n//           name: \"lte\",\n//           description: \"Less than or equal to another field\",\n//           args: [\"fieldName\", \"message?\"],\n//         },\n//         {\n//           name: \"gt\",\n//           description: \"Greater than another field\",\n//           args: [\"fieldName\", \"message?\"],\n//         },\n//         {\n//           name: \"gte\",\n//           description: \"Greater than or equal to another field\",\n//           args: [\"fieldName\", \"message?\"],\n//         },\n//       ],\n//     };\n//\n//     if (category === \"all\") {\n//       return {\n//         categories: decorators,\n//         total: Object.values(decorators).reduce(\n//           (sum, arr) => sum + arr.length,\n//           0\n//         ),\n//       };\n//     }\n//\n//     return {\n//       category,\n//       decorators: decorators[category] || [],\n//       count: decorators[category]?.length || 0,\n//     };\n//   },\n// });\n//\n// // Utility function to get decorator function by name\n// function getDecoratorFunction(name: string): Function | null {\n//   const decoratorMap = {\n//     required,\n//     email,\n//     min,\n//     max,\n//     minlength,\n//     maxlength,\n//     pattern,\n//     url,\n//     date,\n//     password,\n//     list,\n//     set,\n//     eq,\n//     diff,\n//     lt,\n//     lte,\n//     gt,\n//     gte,\n//     type,\n//     step,\n//   };\n//   return decoratorMap[name] || null;\n// }\n//\n// // Utility function to find differences between models\n// async function findDifferences(instance1: any, instance2: any): Promise<any[]> {\n//   const differences = [];\n//   const serialized1 = JSON.parse(instance1.serialize());\n//   const serialized2 = JSON.parse(instance2.serialize());\n//\n//   for (const key in serialized1) {\n//     if (serialized1[key] !== serialized2[key]) {\n//       differences.push({\n//         field: key,\n//         value1: serialized1[key],\n//         value2: serialized2[key],\n//       });\n//     }\n//   }\n//\n//   return differences;\n// }\n//\n// // Start the server\n// server.start({\n//   transportType: \"stdio\",\n// });\n//\n// export { server };\n"]}