@decaf-ts/decorator-validation 1.7.16 → 1.7.18

package/lib/esm/validation/Validators/constants.js

@@ -1,17 +1,23 @@
 import { ModelKeys } from "./../../utils/constants.js";
 /**
- * @summary Keys used for comparison-based validations.
- *
- * @property {string} EQUALS - Validates if two values are equal.
- * @property {string} DIFF - Validates if two values are different.
- * @property {string} LESS_THAN - Validates if a value is less than another.
- * @property {string} LESS_THAN_OR_EQUAL - Validates if a value is less than or equal to another.
- * @property {string} GREATER_THAN - Validates if a value is greater than another.
- * @property {string} GREATER_THAN_OR_EQUAL - Validates if a value is greater than or equal to another.
- *
- * @constant ComparisonValidationKeys
- * @memberof module:decorator-validation.Validation
+ * @description Object-like set of keys used for comparison-based validations.
+ * @summary Provides canonical names for validators that compare two values (equality and ordering checks).
+ * @typedef {Object} ComparisonValidationKeysDef
+ * @property {"equals"} EQUALS Validates if two values are equal.
+ * @property {"different"} DIFF Validates if two values are different.
+ * @property {"lessThan"} LESS_THAN Validates if a value is less than another.
+ * @property {"lessThanOrEqual"} LESS_THAN_OR_EQUAL Validates if a value is less than or equal to another.
+ * @property {"greaterThan"} GREATER_THAN Validates if a value is greater than another.
+ * @property {"greaterThanOrEqual"} GREATER_THAN_OR_EQUAL Validates if a value is greater than or equal to another.
+ * @memberOf module:decorator-validation.Validation
+ */
+/**
+ * @description Keys used for comparison-based validations.
+ * @summary Canonical key names for comparison validators.
+ * @const ComparisonValidationKeys
+ * @memberOf module:decorator-validation.Validation
  * @category Validation
+ * @type {ComparisonValidationKeysDef}
  */
 export const ComparisonValidationKeys = {
     EQUALS: "equals",
@@ -22,26 +28,34 @@ export const ComparisonValidationKeys = {
     GREATER_THAN_OR_EQUAL: "greaterThanOrEqual",
 };
 /**
- * @summary The keys used for validation
- *
- * @property {string} REFLECT prefixes others
- * @property {string} REQUIRED sets as required
- * @property {string} MIN defines min value
- * @property {string} MAX defines max value
- * @property {string} STEP defines step
- * @property {string} MIN_LENGTH defines min length
- * @property {string} MAX_LENGTH defines max length
- * @property {string} PATTERN defines pattern
- * @property {string} EMAIL defines email
- * @property {string} URL defines url
- * @property {string} DATE defines date
- * @property {string} TYPE defines type
- * @property {string} PASSWORD defines password
- * @property {string} LIST defines list
- *
- * @constant ValidationKeys
+ * @description Object-like set of keys used across all validators in the system.
+ * @summary Defines the canonical namespaced key prefix and the individual validation flags for rules such as required, min/max, length, patterns, types, lists and more.
+ * @typedef {Object} ValidationKeysDef
+ * @property {string} REFLECT prefixes others (namespace prefix)
+ * @property {"required"} REQUIRED sets as required
+ * @property {"min"} MIN defines min value
+ * @property {"max"} MAX defines max value
+ * @property {"step"} STEP defines step
+ * @property {"minlength"} MIN_LENGTH defines min length
+ * @property {"maxlength"} MAX_LENGTH defines max length
+ * @property {"pattern"} PATTERN defines pattern
+ * @property {"email"} EMAIL defines email
+ * @property {"url"} URL defines url
+ * @property {"date"} DATE defines date
+ * @property {"type"} TYPE defines type
+ * @property {"password"} PASSWORD defines password
+ * @property {"list"} LIST defines list
+ * @property {"unique"} UNIQUE flags uniqueness
+ * @property {"validator"} VALIDATOR custom validator id
+ * @memberOf module:decorator-validation.Validation
+ */
+/**
+ * @description The keys used for validation.
+ * @summary A namespaced collection of validation key strings used throughout the library.
+ * @const ValidationKeys
  * @memberOf module:decorator-validation.Validation
  * @category Validation
+ * @type {ValidationKeysDef}
  */
 export const ValidationKeys = {
     REFLECT: `${ModelKeys.REFLECT}validation.`,
@@ -64,10 +78,9 @@ export const ValidationKeys = {
     ...ComparisonValidationKeys,
 };
 /**
- * @summary list of month names
- * @description Stores month names. Can be changed for localization purposes
- *
- * @constant MONTH_NAMES
+ * @description list of month names
+ * @summary Stores month names. Can be changed for localization purposes
+ * @const MONTH_NAMES
  * @memberOf module:decorator-validation.Validation
  * @category Validation
  */
@@ -86,10 +99,9 @@ export const MONTH_NAMES = [
     "December",
 ];
 /**
- * @summary list of names of days of the week
- * @description Stores names for days of the week. Can be changed for localization purposes
- *
- * @constant DAYS_OF_WEEK_NAMES
+ * @description list of names of days of the week
+ * @summary Stores names for days of the week. Can be changed for localization purposes
+ * @const DAYS_OF_WEEK_NAMES
  * @memberOf module:decorator-validation.Validation
  * @category Validation
  */
@@ -103,8 +115,9 @@ export const DAYS_OF_WEEK_NAMES = [
     "Saturday",
 ];
 /**
- * @summary Defines the default error messages
- *
+ * @description Type definition for default error message strings keyed by validation type.
+ * @summary Enumerates the supported error message keys with their intended meaning; used to localize or override default messages.
+ * @typedef {Object} DefaultErrorMessages
  * @property {string} REQUIRED default error message
  * @property {string} MIN default error message
  * @property {string} MAX default error message
@@ -121,10 +134,15 @@ export const DAYS_OF_WEEK_NAMES = [
  * @property {string} LIST default error message
  * @property {string} LIST_INSIDE default error message
  * @property {string} MODEL_NOT_FOUND default error message
- *
- * @constant DEFAULT_ERROR_MESSAGES
+ * @memberOf module:decorator-validation.Validation
+ */
+/**
+ * @description Defines the default error messages
+ * @summary Mapping between validation keys and their default human-readable error messages.
+ * @const DEFAULT_ERROR_MESSAGES
  * @memberOf module:decorator-validation.Validation
  * @category Validation
+ * @type {DefaultErrorMessages}
  */
 export const DEFAULT_ERROR_MESSAGES = {
     REQUIRED: "This field is required",
@@ -151,11 +169,22 @@ export const DEFAULT_ERROR_MESSAGES = {
     UNIQUE: "Duplicate found, this field must be unique.",
 };
 /**
- * @summary Defines the various default regexp patterns used
- *
- * @enum DEFAULT_PATTERNS
+ * @description Type definition for default regular expression patterns used in validation.
+ * @summary Captures common regex patterns for email, URL, and password policies, including nested grouping for password-related rules.
+ * @typedef {Object} DefaultPatterns
+ * @property {RegExp} EMAIL Email address validation pattern
+ * @property {RegExp} URL URL validation pattern
+ * @property {Object} PASSWORD Password-related regex patterns
+ * @property {RegExp} PASSWORD.CHAR8_ONE_OF_EACH At least 8 chars with lower, upper, number, and special char
+ * @memberOf module:decorator-validation.Validation
+ */
+/**
+ * @description Defines the various default regexp patterns used
+ * @summary Collection of frequently used validation patterns grouped under semantic keys.
+ * @const DEFAULT_PATTERNS
  * @memberOf module:decorator-validation.Validation
  * @category Validation
+ * @type {DefaultPatterns}
  */
 export const DEFAULT_PATTERNS = {
     EMAIL: /[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?/,
@@ -164,4 +193,4 @@ export const DEFAULT_PATTERNS = {
         CHAR8_ONE_OF_EACH: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&_\-.,])[A-Za-z\d@$!%*?&_\-.,]{8,}$/g,
     },
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../src/validation/Validators/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,mCAA8B;AAElD;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,WAAW;IACjB,SAAS,EAAE,UAAU;IACrB,kBAAkB,EAAE,iBAAiB;IACrC,YAAY,EAAE,aAAa;IAC3B,qBAAqB,EAAE,oBAAoB;CACnC,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,OAAO,EAAE,GAAG,SAAS,CAAC,OAAO,aAAa;IAC1C,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,UAAU,EAAE,WAAW;IACvB,GAAG,EAAE,KAAK;IACV,UAAU,EAAE,WAAW;IACvB,QAAQ,EAAE,UAAU;IACpB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;IACpB,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,GAAG,EAAE,KAAK;IACV,SAAS,EAAE,WAAW;IACtB,GAAG,wBAAwB;CACnB,CAAC;AAEX;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,SAAS;IACT,UAAU;IACV,OAAO;IACP,OAAO;IACP,KAAK;IACL,MAAM;IACN,MAAM;IACN,QAAQ;IACR,WAAW;IACX,SAAS;IACT,UAAU;IACV,UAAU;CACX,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,QAAQ;IACR,QAAQ;IACR,SAAS;IACT,WAAW;IACX,UAAU;IACV,QAAQ;IACR,UAAU;CACX,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAA2B;IAC5D,QAAQ,EAAE,wBAAwB;IAClC,GAAG,EAAE,0BAA0B;IAC/B,GAAG,EAAE,0BAA0B;IAC/B,UAAU,EAAE,2BAA2B;IACvC,UAAU,EAAE,2BAA2B;IACvC,OAAO,EAAE,sCAAsC;IAC/C,KAAK,EAAE,gCAAgC;IACvC,GAAG,EAAE,8BAA8B;IACnC,IAAI,EAAE,0CAA0C;IAChD,IAAI,EAAE,kCAAkC;IACxC,IAAI,EAAE,iCAAiC;IACvC,OAAO,EAAE,mBAAmB;IAC5B,QAAQ,EACN,4HAA4H;IAC9H,IAAI,EAAE,qBAAqB;IAC3B,eAAe,EAAE,+BAA+B;IAChD,MAAM,EAAE,uCAAuC;IAC/C,IAAI,EAAE,6CAA6C;IACnD,SAAS,EAAE,wCAAwC;IACnD,kBAAkB,EAAE,oDAAoD;IACxE,YAAY,EAAE,2CAA2C;IACzD,qBAAqB,EACnB,uDAAuD;IACzD,MAAM,EAAE,6CAA6C;CACtD,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,KAAK,EACH,4JAA4J;IAC9J,GAAG,EAAE,yaAAya;IAC9a,QAAQ,EAAE;QACR,iBAAiB,EACf,iFAAiF;KACpF;CACF,CAAC","sourcesContent":["import { ModelKeys } from \"../../utils/constants\";\n\n/**\n * @summary Keys used for comparison-based validations.\n *\n * @property {string} EQUALS - Validates if two values are equal.\n * @property {string} DIFF - Validates if two values are different.\n * @property {string} LESS_THAN - Validates if a value is less than another.\n * @property {string} LESS_THAN_OR_EQUAL - Validates if a value is less than or equal to another.\n * @property {string} GREATER_THAN - Validates if a value is greater than another.\n * @property {string} GREATER_THAN_OR_EQUAL - Validates if a value is greater than or equal to another.\n *\n * @constant ComparisonValidationKeys\n * @memberof module:decorator-validation.Validation\n * @category Validation\n */\nexport const ComparisonValidationKeys = {\n  EQUALS: \"equals\",\n  DIFF: \"different\",\n  LESS_THAN: \"lessThan\",\n  LESS_THAN_OR_EQUAL: \"lessThanOrEqual\",\n  GREATER_THAN: \"greaterThan\",\n  GREATER_THAN_OR_EQUAL: \"greaterThanOrEqual\",\n} as const;\n\n/**\n * @summary The keys used for validation\n *\n * @property {string} REFLECT prefixes others\n * @property {string} REQUIRED sets as required\n * @property {string} MIN defines min value\n * @property {string} MAX defines max value\n * @property {string} STEP defines step\n * @property {string} MIN_LENGTH defines min length\n * @property {string} MAX_LENGTH defines max length\n * @property {string} PATTERN defines pattern\n * @property {string} EMAIL defines email\n * @property {string} URL defines url\n * @property {string} DATE defines date\n * @property {string} TYPE defines type\n * @property {string} PASSWORD defines password\n * @property {string} LIST defines list\n *\n * @constant ValidationKeys\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const ValidationKeys = {\n  REFLECT: `${ModelKeys.REFLECT}validation.`,\n  DATE: \"date\",\n  EMAIL: \"email\",\n  FORMAT: \"format\",\n  LIST: \"list\",\n  MAX: \"max\",\n  MAX_LENGTH: \"maxlength\",\n  MIN: \"min\",\n  MIN_LENGTH: \"minlength\",\n  PASSWORD: \"password\",\n  PATTERN: \"pattern\",\n  REQUIRED: \"required\",\n  STEP: \"step\",\n  TYPE: \"type\",\n  UNIQUE: \"unique\",\n  URL: \"url\",\n  VALIDATOR: \"validator\",\n  ...ComparisonValidationKeys,\n} as const;\n\n/**\n * @summary list of month names\n * @description Stores month names. Can be changed for localization purposes\n *\n * @constant MONTH_NAMES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const MONTH_NAMES = [\n  \"January\",\n  \"February\",\n  \"March\",\n  \"April\",\n  \"May\",\n  \"June\",\n  \"July\",\n  \"August\",\n  \"September\",\n  \"October\",\n  \"November\",\n  \"December\",\n];\n\n/**\n * @summary list of names of days of the week\n * @description Stores names for days of the week. Can be changed for localization purposes\n *\n * @constant DAYS_OF_WEEK_NAMES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DAYS_OF_WEEK_NAMES = [\n  \"Sunday\",\n  \"Monday\",\n  \"Tuesday\",\n  \"Wednesday\",\n  \"Thursday\",\n  \"Friday\",\n  \"Saturday\",\n];\n\n/**\n * @summary Defines the default error messages\n *\n * @property {string} REQUIRED default error message\n * @property {string} MIN default error message\n * @property {string} MAX default error message\n * @property {string} MIN_LENGTH default error message\n * @property {string} MAX_LENGTH default error message\n * @property {string} PATTERN default error message\n * @property {string} EMAIL default error message\n * @property {string} URL default error message\n * @property {string} TYPE default error message\n * @property {string} STEP default error message\n * @property {string} DATE default error message\n * @property {string} DEFAULT default error message\n * @property {string} PASSWORD default error message\n * @property {string} LIST default error message\n * @property {string} LIST_INSIDE default error message\n * @property {string} MODEL_NOT_FOUND default error message\n *\n * @constant DEFAULT_ERROR_MESSAGES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DEFAULT_ERROR_MESSAGES: Record<string, string> = {\n  REQUIRED: \"This field is required\",\n  MIN: \"The minimum value is {0}\",\n  MAX: \"The maximum value is {0}\",\n  MIN_LENGTH: \"The minimum length is {0}\",\n  MAX_LENGTH: \"The maximum length is {0}\",\n  PATTERN: \"The value does not match the pattern\",\n  EMAIL: \"The value is not a valid email\",\n  URL: \"The value is not a valid URL\",\n  TYPE: \"Invalid type. Expected {0}, received {1}\",\n  STEP: \"Invalid value. Not a step of {0}\",\n  DATE: \"Invalid value. not a valid Date\",\n  DEFAULT: \"There is an Error\",\n  PASSWORD:\n    \"Must be at least 8 characters and contain one of number, lower and upper case letters, and special character (@$!%*?&_-.,)\",\n  LIST: \"Invalid list of {0}\",\n  MODEL_NOT_FOUND: \"No model registered under {0}\",\n  EQUALS: \"This field must be equal to field {0}\",\n  DIFF: \"This field must be different from field {0}\",\n  LESS_THAN: \"This field must be less than field {0}\",\n  LESS_THAN_OR_EQUAL: \"This field must be less than or equal to field {0}\",\n  GREATER_THAN: \"This field must be greater than field {0}\",\n  GREATER_THAN_OR_EQUAL:\n    \"This field must be greater than or equal to field {0}\",\n  UNIQUE: \"Duplicate found, this field must be unique.\",\n};\n\n/**\n * @summary Defines the various default regexp patterns used\n *\n * @enum DEFAULT_PATTERNS\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DEFAULT_PATTERNS = {\n  EMAIL:\n    /[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-z0-9-]*[a-zA-Z0-9])?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?/,\n  URL: /^(?:(?:(?:https?|ftp):)?\\/\\/)(?:\\S+(?::\\S*)?@)?(?:(?!(?:10|127)(?:\\.\\d{1,3}){3})(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z0-9\\u00a1-\\uffff][a-z0-9\\u00a1-\\uffff_-]{0,62})?[a-z0-9\\u00a1-\\uffff]\\.)+(?:[a-z\\u00a1-\\uffff]{2,}\\.?))(?::\\d{2,5})?(?:[/?#]\\S*)?$/i,\n  PASSWORD: {\n    CHAR8_ONE_OF_EACH:\n      /^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&_\\-.,])[A-Za-z\\d@$!%*?&_\\-.,]{8,}$/g,\n  },\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../src/validation/Validators/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,mCAA8B;AAElD;;;;;;;;;;;GAWG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,WAAW;IACjB,SAAS,EAAE,UAAU;IACrB,kBAAkB,EAAE,iBAAiB;IACrC,YAAY,EAAE,aAAa;IAC3B,qBAAqB,EAAE,oBAAoB;CACnC,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,OAAO,EAAE,GAAG,SAAS,CAAC,OAAO,aAAa;IAC1C,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,UAAU,EAAE,WAAW;IACvB,GAAG,EAAE,KAAK;IACV,UAAU,EAAE,WAAW;IACvB,QAAQ,EAAE,UAAU;IACpB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;IACpB,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,GAAG,EAAE,KAAK;IACV,SAAS,EAAE,WAAW;IACtB,GAAG,wBAAwB;CACnB,CAAC;AAEX;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,SAAS;IACT,UAAU;IACV,OAAO;IACP,OAAO;IACP,KAAK;IACL,MAAM;IACN,MAAM;IACN,QAAQ;IACR,WAAW;IACX,SAAS;IACT,UAAU;IACV,UAAU;CACX,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,QAAQ;IACR,QAAQ;IACR,SAAS;IACT,WAAW;IACX,UAAU;IACV,QAAQ;IACR,UAAU;CACX,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAA2B;IAC5D,QAAQ,EAAE,wBAAwB;IAClC,GAAG,EAAE,0BAA0B;IAC/B,GAAG,EAAE,0BAA0B;IAC/B,UAAU,EAAE,2BAA2B;IACvC,UAAU,EAAE,2BAA2B;IACvC,OAAO,EAAE,sCAAsC;IAC/C,KAAK,EAAE,gCAAgC;IACvC,GAAG,EAAE,8BAA8B;IACnC,IAAI,EAAE,0CAA0C;IAChD,IAAI,EAAE,kCAAkC;IACxC,IAAI,EAAE,iCAAiC;IACvC,OAAO,EAAE,mBAAmB;IAC5B,QAAQ,EACN,4HAA4H;IAC9H,IAAI,EAAE,qBAAqB;IAC3B,eAAe,EAAE,+BAA+B;IAChD,MAAM,EAAE,uCAAuC;IAC/C,IAAI,EAAE,6CAA6C;IACnD,SAAS,EAAE,wCAAwC;IACnD,kBAAkB,EAAE,oDAAoD;IACxE,YAAY,EAAE,2CAA2C;IACzD,qBAAqB,EACnB,uDAAuD;IACzD,MAAM,EAAE,6CAA6C;CACtD,CAAC;AAEF;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,KAAK,EACH,4JAA4J;IAC9J,GAAG,EAAE,yaAAya;IAC9a,QAAQ,EAAE;QACR,iBAAiB,EACf,iFAAiF;KACpF;CACF,CAAC","sourcesContent":["import { ModelKeys } from \"../../utils/constants\";\n\n/**\n * @description Object-like set of keys used for comparison-based validations.\n * @summary Provides canonical names for validators that compare two values (equality and ordering checks).\n * @typedef {Object} ComparisonValidationKeysDef\n * @property {\"equals\"} EQUALS Validates if two values are equal.\n * @property {\"different\"} DIFF Validates if two values are different.\n * @property {\"lessThan\"} LESS_THAN Validates if a value is less than another.\n * @property {\"lessThanOrEqual\"} LESS_THAN_OR_EQUAL Validates if a value is less than or equal to another.\n * @property {\"greaterThan\"} GREATER_THAN Validates if a value is greater than another.\n * @property {\"greaterThanOrEqual\"} GREATER_THAN_OR_EQUAL Validates if a value is greater than or equal to another.\n * @memberOf module:decorator-validation.Validation\n */\n\n/**\n * @description Keys used for comparison-based validations.\n * @summary Canonical key names for comparison validators.\n * @const ComparisonValidationKeys\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n * @type {ComparisonValidationKeysDef}\n */\nexport const ComparisonValidationKeys = {\n  EQUALS: \"equals\",\n  DIFF: \"different\",\n  LESS_THAN: \"lessThan\",\n  LESS_THAN_OR_EQUAL: \"lessThanOrEqual\",\n  GREATER_THAN: \"greaterThan\",\n  GREATER_THAN_OR_EQUAL: \"greaterThanOrEqual\",\n} as const;\n\n/**\n * @description Object-like set of keys used across all validators in the system.\n * @summary Defines the canonical namespaced key prefix and the individual validation flags for rules such as required, min/max, length, patterns, types, lists and more.\n * @typedef {Object} ValidationKeysDef\n * @property {string} REFLECT prefixes others (namespace prefix)\n * @property {\"required\"} REQUIRED sets as required\n * @property {\"min\"} MIN defines min value\n * @property {\"max\"} MAX defines max value\n * @property {\"step\"} STEP defines step\n * @property {\"minlength\"} MIN_LENGTH defines min length\n * @property {\"maxlength\"} MAX_LENGTH defines max length\n * @property {\"pattern\"} PATTERN defines pattern\n * @property {\"email\"} EMAIL defines email\n * @property {\"url\"} URL defines url\n * @property {\"date\"} DATE defines date\n * @property {\"type\"} TYPE defines type\n * @property {\"password\"} PASSWORD defines password\n * @property {\"list\"} LIST defines list\n * @property {\"unique\"} UNIQUE flags uniqueness\n * @property {\"validator\"} VALIDATOR custom validator id\n * @memberOf module:decorator-validation.Validation\n */\n\n/**\n * @description The keys used for validation.\n * @summary A namespaced collection of validation key strings used throughout the library.\n * @const ValidationKeys\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n * @type {ValidationKeysDef}\n */\nexport const ValidationKeys = {\n  REFLECT: `${ModelKeys.REFLECT}validation.`,\n  DATE: \"date\",\n  EMAIL: \"email\",\n  FORMAT: \"format\",\n  LIST: \"list\",\n  MAX: \"max\",\n  MAX_LENGTH: \"maxlength\",\n  MIN: \"min\",\n  MIN_LENGTH: \"minlength\",\n  PASSWORD: \"password\",\n  PATTERN: \"pattern\",\n  REQUIRED: \"required\",\n  STEP: \"step\",\n  TYPE: \"type\",\n  UNIQUE: \"unique\",\n  URL: \"url\",\n  VALIDATOR: \"validator\",\n  ...ComparisonValidationKeys,\n} as const;\n\n/**\n * @description list of month names\n * @summary Stores month names. Can be changed for localization purposes\n * @const MONTH_NAMES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const MONTH_NAMES = [\n  \"January\",\n  \"February\",\n  \"March\",\n  \"April\",\n  \"May\",\n  \"June\",\n  \"July\",\n  \"August\",\n  \"September\",\n  \"October\",\n  \"November\",\n  \"December\",\n];\n\n/**\n * @description list of names of days of the week\n * @summary Stores names for days of the week. Can be changed for localization purposes\n * @const DAYS_OF_WEEK_NAMES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DAYS_OF_WEEK_NAMES = [\n  \"Sunday\",\n  \"Monday\",\n  \"Tuesday\",\n  \"Wednesday\",\n  \"Thursday\",\n  \"Friday\",\n  \"Saturday\",\n];\n\n/**\n * @description Type definition for default error message strings keyed by validation type.\n * @summary Enumerates the supported error message keys with their intended meaning; used to localize or override default messages.\n * @typedef {Object} DefaultErrorMessages\n * @property {string} REQUIRED default error message\n * @property {string} MIN default error message\n * @property {string} MAX default error message\n * @property {string} MIN_LENGTH default error message\n * @property {string} MAX_LENGTH default error message\n * @property {string} PATTERN default error message\n * @property {string} EMAIL default error message\n * @property {string} URL default error message\n * @property {string} TYPE default error message\n * @property {string} STEP default error message\n * @property {string} DATE default error message\n * @property {string} DEFAULT default error message\n * @property {string} PASSWORD default error message\n * @property {string} LIST default error message\n * @property {string} LIST_INSIDE default error message\n * @property {string} MODEL_NOT_FOUND default error message\n * @memberOf module:decorator-validation.Validation\n */\n\n/**\n * @description Defines the default error messages\n * @summary Mapping between validation keys and their default human-readable error messages.\n * @const DEFAULT_ERROR_MESSAGES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n * @type {DefaultErrorMessages}\n */\nexport const DEFAULT_ERROR_MESSAGES: Record<string, string> = {\n  REQUIRED: \"This field is required\",\n  MIN: \"The minimum value is {0}\",\n  MAX: \"The maximum value is {0}\",\n  MIN_LENGTH: \"The minimum length is {0}\",\n  MAX_LENGTH: \"The maximum length is {0}\",\n  PATTERN: \"The value does not match the pattern\",\n  EMAIL: \"The value is not a valid email\",\n  URL: \"The value is not a valid URL\",\n  TYPE: \"Invalid type. Expected {0}, received {1}\",\n  STEP: \"Invalid value. Not a step of {0}\",\n  DATE: \"Invalid value. not a valid Date\",\n  DEFAULT: \"There is an Error\",\n  PASSWORD:\n    \"Must be at least 8 characters and contain one of number, lower and upper case letters, and special character (@$!%*?&_-.,)\",\n  LIST: \"Invalid list of {0}\",\n  MODEL_NOT_FOUND: \"No model registered under {0}\",\n  EQUALS: \"This field must be equal to field {0}\",\n  DIFF: \"This field must be different from field {0}\",\n  LESS_THAN: \"This field must be less than field {0}\",\n  LESS_THAN_OR_EQUAL: \"This field must be less than or equal to field {0}\",\n  GREATER_THAN: \"This field must be greater than field {0}\",\n  GREATER_THAN_OR_EQUAL:\n    \"This field must be greater than or equal to field {0}\",\n  UNIQUE: \"Duplicate found, this field must be unique.\",\n};\n\n/**\n * @description Type definition for default regular expression patterns used in validation.\n * @summary Captures common regex patterns for email, URL, and password policies, including nested grouping for password-related rules.\n * @typedef {Object} DefaultPatterns\n * @property {RegExp} EMAIL Email address validation pattern\n * @property {RegExp} URL URL validation pattern\n * @property {Object} PASSWORD Password-related regex patterns\n * @property {RegExp} PASSWORD.CHAR8_ONE_OF_EACH At least 8 chars with lower, upper, number, and special char\n * @memberOf module:decorator-validation.Validation\n */\n\n/**\n * @description Defines the various default regexp patterns used\n * @summary Collection of frequently used validation patterns grouped under semantic keys.\n * @const DEFAULT_PATTERNS\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n * @type {DefaultPatterns}\n */\nexport const DEFAULT_PATTERNS = {\n  EMAIL:\n    /[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-z0-9-]*[a-zA-Z0-9])?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?/,\n  URL: /^(?:(?:(?:https?|ftp):)?\\/\\/)(?:\\S+(?::\\S*)?@)?(?:(?!(?:10|127)(?:\\.\\d{1,3}){3})(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z0-9\\u00a1-\\uffff][a-z0-9\\u00a1-\\uffff_-]{0,62})?[a-z0-9\\u00a1-\\uffff]\\.)+(?:[a-z\\u00a1-\\uffff]{2,}\\.?))(?::\\d{2,5})?(?:[/?#]\\S*)?$/i,\n  PASSWORD: {\n    CHAR8_ONE_OF_EACH:\n      /^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&_\\-.,])[A-Za-z\\d@$!%*?&_\\-.,]{8,}$/g,\n  },\n};\n"]}

package/lib/index.cjs

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

package/lib/index.d.ts

@@ -16,4 +16,4 @@ export * from "./model";
  * @const VERSION
  * @memberOf module:decorator-validation
  */
-export declare const VERSION = "1.7.16";
+export declare const VERSION = "1.7.18";

package/lib/mcp/ModelContextProtocol.cjs

@@ -3,6 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModelContextProtocol = void 0;
 const fastmcp_1 = require("fastmcp");
 const logging_1 = require("@decaf-ts/logging");
+/**
+ * @description Validates and normalizes a semantic version string.
+ * @summary Ensures the provided version follows semantic versioning (major.minor.patch) and returns a tuple-like template string typed as `${number}.${number}.${number}`.
+ * @template
+ * @param {string} version The version string to validate, expected in the form MAJOR.MINOR.PATCH.
+ * @return {string} The normalized version string if valid.
+ * @function validateVersion
+ * @memberOf module:decorator-validation
+ */
 function validateVersion(version) {
     const regexp = /(\d+)\.(\d+)\.(\d+)/g;
     const match = regexp.exec(version);
@@ -10,21 +19,69 @@ function validateVersion(version) {
         throw new Error(`Invalid version string. should obey semantic versioning: ${version}`);
     return `${match[1]}.${match[2]}.${match[3]}`;
 }
+/**
+ * @description Fluent builder for creating a configured ModelContextProtocol instance.
+ * @summary Collects MCP configuration including a semantic version, a name, and a registry of tools, offering chainable methods and a final build step to produce a ready-to-use ModelContextProtocol.
+ * @param {string} [name] The name of the MCP instance to build.
+ * @param {string} [version] The semantic version of the MCP instance.
+ * @param {Record<string, Tool<any, any>>} [tools] A map of tool configurations indexed by tool name.
+ * @class
+ * @example
+ * // Build a new MCP with a single tool
+ * const mcp = ModelContextProtocol.builder
+ *   .setName("Example")
+ *   .setVersion("1.0.0")
+ *   .addTool({ name: "do", description: "", parameters: z.any(), execute: async () => "ok" })
+ *   .build();
+ * @mermaid
+ * sequenceDiagram
+ *   participant Dev as Developer
+ *   participant B as Builder
+ *   participant MCP as ModelContextProtocol
+ *   Dev->>B: setName("Example")
+ *   B-->>Dev: Builder
+ *   Dev->>B: setVersion("1.0.0")
+ *   B-->>Dev: Builder
+ *   Dev->>B: addTool(tool)
+ *   B-->>Dev: Builder
+ *   Dev->>B: build()
+ *   B->>MCP: new ModelContextProtocol(FastMCP)
+ *   B-->>Dev: ModelContextProtocol
+ */
 class Builder {
     constructor() {
         this.tools = {};
         this.log = logging_1.Logging.for("MCP Builder");
     }
+    /**
+     * @description Sets the MCP instance name.
+     * @summary Assigns a human-readable identifier to the builder configuration and enables method chaining.
+     * @param {string} value The name to assign to the MCP instance.
+     * @return {this} The current builder instance for chaining.
+     */
     setName(value) {
         this.name = value;
         this.log.debug(`name set to ${value}`);
         return this;
     }
+    /**
+     * @description Sets and validates the semantic version for the MCP instance.
+     * @summary Parses the provided value against semantic versioning and stores the normalized version; enables method chaining.
+     * @param {string} value The semantic version string (e.g., "1.2.3").
+     * @return {this} The current builder instance for chaining.
+     */
     setVersion(value) {
         this.version = validateVersion(value);
         this.log.debug(`version set to ${value}`);
         return this;
     }
+    /**
+     * @description Registers a new tool in the builder.
+     * @summary Adds a tool configuration by its unique name to the internal registry, throwing if a tool with the same name already exists.
+     * @template Auth extends FastMCPSessionAuth
+     * @param {Tool<Auth, any>} config The tool configuration object, including a unique name and an execute handler.
+     * @return {this} The current builder instance for chaining.
+     */
     addTool(config) {
         const { name } = config;
         if (name in this.tools)
@@ -33,6 +90,12 @@ class Builder {
         this.log.debug(`tool ${name} added`);
         return this;
     }
+    /**
+     * @description Finalizes the configuration and produces a ModelContextProtocol instance.
+     * @summary Validates required fields (name and version), constructs a FastMCP instance, registers all configured tools, and returns a ModelContextProtocol wrapping the MCP.
+     * @template Auth extends FastMCPSessionAuth
+     * @return {ModelContextProtocol<Auth>} A fully initialized ModelContextProtocol instance.
+     */
     build() {
         if (!this.name)
             throw new Error("name is required");
@@ -55,20 +118,66 @@ class Builder {
         return new ModelContextProtocol(mcp);
     }
 }
+/**
+ * @description A thin wrapper around FastMCP providing a typed interface for model-centric protocols.
+ * @summary Encapsulates a configured FastMCP instance and exposes factory utilities via a static Builder for constructing MCPs with tools, versioning, and naming semantics.
+ * @template Auth extends FastMCPSessionAuth Authentication payload type stored in the MCP session, or undefined for no auth.
+ * @param {FastMCP<Auth>} mcp The underlying FastMCP instance used to register and run tools.
+ * @class
+ * @example
+ * // Using the builder
+ * const protocol = ModelContextProtocol.builder
+ *   .setName("Validator")
+ *   .setVersion("1.2.3")
+ *   .addTool({ name: "ping", description: "", parameters: z.any(), execute: async () => "pong" })
+ *   .build();
+ * @mermaid
+ * sequenceDiagram
+ *   participant Dev as Developer
+ *   participant B as ModelContextProtocol.Builder
+ *   participant MCP as FastMCP
+ *   participant Proto as ModelContextProtocol
+ *   Dev->>B: setName()/setVersion()/addTool()
+ *   Dev->>B: build()
+ *   B->>MCP: new FastMCP({ name, version })
+ *   B->>MCP: addTool(tool...)
+ *   B->>Proto: new ModelContextProtocol(MCP)
+ *   B-->>Dev: ModelContextProtocol
+ */
 class ModelContextProtocol {
+    /**
+     * @description Lazily obtains a logger instance for this protocol wrapper.
+     * @summary Uses the Logging facility to create a context-aware Logger bound to this instance.
+     * @return {Logger} A logger instance for this class.
+     */
     get log() {
         return logging_1.Logging.for(this);
     }
     constructor(mcp) {
         this.mcp = mcp;
     }
+    /**
+     * @description Alias to the inner Builder class for external access.
+     * @summary Exposes the builder type to consumers to enable typed construction of ModelContextProtocol instances.
+     */
     static { this.Builder = Builder; }
+    /**
+     * @description Factory accessor for a new Builder instance.
+     * @summary Creates a new builder to fluently configure and construct a ModelContextProtocol.
+     * @return {Builder} A new builder instance.
+     */
     static get builder() {
         return new ModelContextProtocol.Builder();
     }
+    /**
+     * @description Validates a semantic version string.
+     * @summary Utility wrapper around the module-level validateVersion to keep a typed validator close to the class API.
+     * @param {string} version The version string to validate.
+     * @return {string} The normalized semantic version string.
+     */
     static validateVersion(version) {
         return validateVersion(version);
     }
 }
 exports.ModelContextProtocol = ModelContextProtocol;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ModelContextProtocol.js","sourceRoot":"","sources":["../../src/mcp/ModelContextProtocol.ts"],"names":[],"mappings":"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","sourcesContent":["import { FastMCP, Tool } from \"fastmcp\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport { FastMCPSessionAuth } from \"./types\";\n\n/**\n * @description Validates and normalizes a semantic version string.\n * @summary Ensures the provided version follows semantic versioning (major.minor.patch) and returns a tuple-like template string typed as `${number}.${number}.${number}`.\n * @template\n * @param {string} version The version string to validate, expected in the form MAJOR.MINOR.PATCH.\n * @return {string} The normalized version string if valid.\n * @function validateVersion\n * @memberOf module:decorator-validation\n */\nfunction validateVersion(version: string): `${number}.${number}.${number}` {\n  const regexp = /(\\d+)\\.(\\d+)\\.(\\d+)/g;\n  const match = regexp.exec(version);\n  if (!match)\n    throw new Error(\n      `Invalid version string. should obey semantic versioning: ${version}`\n    );\n  return `${match[1]}.${match[2]}.${match[3]}` as `${number}.${number}.${number}`;\n}\n\n/**\n * @description Fluent builder for creating a configured ModelContextProtocol instance.\n * @summary Collects MCP configuration including a semantic version, a name, and a registry of tools, offering chainable methods and a final build step to produce a ready-to-use ModelContextProtocol.\n * @param {string} [name] The name of the MCP instance to build.\n * @param {string} [version] The semantic version of the MCP instance.\n * @param {Record<string, Tool<any, any>>} [tools] A map of tool configurations indexed by tool name.\n * @class\n * @example\n * // Build a new MCP with a single tool\n * const mcp = ModelContextProtocol.builder\n *   .setName(\"Example\")\n *   .setVersion(\"1.0.0\")\n *   .addTool({ name: \"do\", description: \"\", parameters: z.any(), execute: async () => \"ok\" })\n *   .build();\n * @mermaid\n * sequenceDiagram\n *   participant Dev as Developer\n *   participant B as Builder\n *   participant MCP as ModelContextProtocol\n *   Dev->>B: setName(\"Example\")\n *   B-->>Dev: Builder\n *   Dev->>B: setVersion(\"1.0.0\")\n *   B-->>Dev: Builder\n *   Dev->>B: addTool(tool)\n *   B-->>Dev: Builder\n *   Dev->>B: build()\n *   B->>MCP: new ModelContextProtocol(FastMCP)\n *   B-->>Dev: ModelContextProtocol\n */\nclass Builder {\n  name!: string;\n  version!: `${number}.${number}.${number}`;\n  tools: Record<string, Tool<any, any>> = {};\n\n  log = Logging.for(\"MCP Builder\");\n\n  constructor() {}\n\n  /**\n   * @description Sets the MCP instance name.\n   * @summary Assigns a human-readable identifier to the builder configuration and enables method chaining.\n   * @param {string} value The name to assign to the MCP instance.\n   * @return {this} The current builder instance for chaining.\n   */\n  setName(value: string) {\n    this.name = value;\n    this.log.debug(`name set to ${value}`);\n    return this;\n  }\n\n  /**\n   * @description Sets and validates the semantic version for the MCP instance.\n   * @summary Parses the provided value against semantic versioning and stores the normalized version; enables method chaining.\n   * @param {string} value The semantic version string (e.g., \"1.2.3\").\n   * @return {this} The current builder instance for chaining.\n   */\n  setVersion(value: string) {\n    this.version = validateVersion(value);\n    this.log.debug(`version set to ${value}`);\n    return this;\n  }\n\n  /**\n   * @description Registers a new tool in the builder.\n   * @summary Adds a tool configuration by its unique name to the internal registry, throwing if a tool with the same name already exists.\n   * @template Auth extends FastMCPSessionAuth\n   * @param {Tool<Auth, any>} config The tool configuration object, including a unique name and an execute handler.\n   * @return {this} The current builder instance for chaining.\n   */\n  addTool<Auth extends FastMCPSessionAuth = undefined>(\n    config: Tool<Auth, any>\n  ) {\n    const { name } = config;\n    if (name in this.tools) throw new Error(`tool ${name} already registered`);\n    this.tools[name] = config;\n    this.log.debug(`tool ${name} added`);\n    return this;\n  }\n\n  /**\n   * @description Finalizes the configuration and produces a ModelContextProtocol instance.\n   * @summary Validates required fields (name and version), constructs a FastMCP instance, registers all configured tools, and returns a ModelContextProtocol wrapping the MCP.\n   * @template Auth extends FastMCPSessionAuth\n   * @return {ModelContextProtocol<Auth>} A fully initialized ModelContextProtocol instance.\n   */\n  build<\n    Auth extends FastMCPSessionAuth = undefined,\n  >(): ModelContextProtocol<Auth> {\n    if (!this.name) throw new Error(\"name is required\");\n    if (!this.version) throw new Error(\"version is required\");\n    const mcp = new FastMCP<Auth>({\n      name: this.name,\n      version: this.version,\n    });\n    Object.values(this.tools).forEach((tool) => {\n      try {\n        mcp.addTool(tool);\n      } catch (e: unknown) {\n        throw new Error(`Failed to add tool ${tool.name}: ${e}`);\n      }\n    });\n    this.log.info(`${this.name} MCP built`);\n    this.log.debug(\n      `${this.name} MCP - available tools: ${Object.keys(this.tools).join(\", \")}`\n    );\n    return new ModelContextProtocol(mcp);\n  }\n}\n\n/**\n * @description A thin wrapper around FastMCP providing a typed interface for model-centric protocols.\n * @summary Encapsulates a configured FastMCP instance and exposes factory utilities via a static Builder for constructing MCPs with tools, versioning, and naming semantics.\n * @template Auth extends FastMCPSessionAuth Authentication payload type stored in the MCP session, or undefined for no auth.\n * @param {FastMCP<Auth>} mcp The underlying FastMCP instance used to register and run tools.\n * @class\n * @example\n * // Using the builder\n * const protocol = ModelContextProtocol.builder\n *   .setName(\"Validator\")\n *   .setVersion(\"1.2.3\")\n *   .addTool({ name: \"ping\", description: \"\", parameters: z.any(), execute: async () => \"pong\" })\n *   .build();\n * @mermaid\n * sequenceDiagram\n *   participant Dev as Developer\n *   participant B as ModelContextProtocol.Builder\n *   participant MCP as FastMCP\n *   participant Proto as ModelContextProtocol\n *   Dev->>B: setName()/setVersion()/addTool()\n *   Dev->>B: build()\n *   B->>MCP: new FastMCP({ name, version })\n *   B->>MCP: addTool(tool...)\n *   B->>Proto: new ModelContextProtocol(MCP)\n *   B-->>Dev: ModelContextProtocol\n */\nexport class ModelContextProtocol<Auth extends FastMCPSessionAuth = undefined> {\n  /**\n   * @description Lazily obtains a logger instance for this protocol wrapper.\n   * @summary Uses the Logging facility to create a context-aware Logger bound to this instance.\n   * @return {Logger} A logger instance for this class.\n   */\n  protected get log(): Logger {\n    return Logging.for(this as any);\n  }\n\n  constructor(protected readonly mcp: FastMCP<Auth>) {}\n\n  /**\n   * @description Alias to the inner Builder class for external access.\n   * @summary Exposes the builder type to consumers to enable typed construction of ModelContextProtocol instances.\n   */\n  static readonly Builder = Builder;\n\n  /**\n   * @description Factory accessor for a new Builder instance.\n   * @summary Creates a new builder to fluently configure and construct a ModelContextProtocol.\n   * @return {Builder} A new builder instance.\n   */\n  static get builder() {\n    return new ModelContextProtocol.Builder();\n  }\n\n  /**\n   * @description Validates a semantic version string.\n   * @summary Utility wrapper around the module-level validateVersion to keep a typed validator close to the class API.\n   * @param {string} version The version string to validate.\n   * @return {string} The normalized semantic version string.\n   */\n  private static validateVersion(\n    version: string\n  ): `${number}.${number}.${number}` {\n    return validateVersion(version);\n  }\n}\n"]}

package/lib/mcp/ModelContextProtocol.d.ts

@@ -1,23 +1,123 @@
 import { FastMCP, Tool } from "fastmcp";
 import { Logger } from "@decaf-ts/logging";
 import { FastMCPSessionAuth } from "./types";
+/**
+ * @description Fluent builder for creating a configured ModelContextProtocol instance.
+ * @summary Collects MCP configuration including a semantic version, a name, and a registry of tools, offering chainable methods and a final build step to produce a ready-to-use ModelContextProtocol.
+ * @param {string} [name] The name of the MCP instance to build.
+ * @param {string} [version] The semantic version of the MCP instance.
+ * @param {Record<string, Tool<any, any>>} [tools] A map of tool configurations indexed by tool name.
+ * @class
+ * @example
+ * // Build a new MCP with a single tool
+ * const mcp = ModelContextProtocol.builder
+ *   .setName("Example")
+ *   .setVersion("1.0.0")
+ *   .addTool({ name: "do", description: "", parameters: z.any(), execute: async () => "ok" })
+ *   .build();
+ * @mermaid
+ * sequenceDiagram
+ *   participant Dev as Developer
+ *   participant B as Builder
+ *   participant MCP as ModelContextProtocol
+ *   Dev->>B: setName("Example")
+ *   B-->>Dev: Builder
+ *   Dev->>B: setVersion("1.0.0")
+ *   B-->>Dev: Builder
+ *   Dev->>B: addTool(tool)
+ *   B-->>Dev: Builder
+ *   Dev->>B: build()
+ *   B->>MCP: new ModelContextProtocol(FastMCP)
+ *   B-->>Dev: ModelContextProtocol
+ */
 declare class Builder {
     name: string;
     version: `${number}.${number}.${number}`;
     tools: Record<string, Tool<any, any>>;
     log: Logger;
     constructor();
+    /**
+     * @description Sets the MCP instance name.
+     * @summary Assigns a human-readable identifier to the builder configuration and enables method chaining.
+     * @param {string} value The name to assign to the MCP instance.
+     * @return {this} The current builder instance for chaining.
+     */
     setName(value: string): this;
+    /**
+     * @description Sets and validates the semantic version for the MCP instance.
+     * @summary Parses the provided value against semantic versioning and stores the normalized version; enables method chaining.
+     * @param {string} value The semantic version string (e.g., "1.2.3").
+     * @return {this} The current builder instance for chaining.
+     */
     setVersion(value: string): this;
+    /**
+     * @description Registers a new tool in the builder.
+     * @summary Adds a tool configuration by its unique name to the internal registry, throwing if a tool with the same name already exists.
+     * @template Auth extends FastMCPSessionAuth
+     * @param {Tool<Auth, any>} config The tool configuration object, including a unique name and an execute handler.
+     * @return {this} The current builder instance for chaining.
+     */
     addTool<Auth extends FastMCPSessionAuth = undefined>(config: Tool<Auth, any>): this;
+    /**
+     * @description Finalizes the configuration and produces a ModelContextProtocol instance.
+     * @summary Validates required fields (name and version), constructs a FastMCP instance, registers all configured tools, and returns a ModelContextProtocol wrapping the MCP.
+     * @template Auth extends FastMCPSessionAuth
+     * @return {ModelContextProtocol<Auth>} A fully initialized ModelContextProtocol instance.
+     */
     build<Auth extends FastMCPSessionAuth = undefined>(): ModelContextProtocol<Auth>;
 }
+/**
+ * @description A thin wrapper around FastMCP providing a typed interface for model-centric protocols.
+ * @summary Encapsulates a configured FastMCP instance and exposes factory utilities via a static Builder for constructing MCPs with tools, versioning, and naming semantics.
+ * @template Auth extends FastMCPSessionAuth Authentication payload type stored in the MCP session, or undefined for no auth.
+ * @param {FastMCP<Auth>} mcp The underlying FastMCP instance used to register and run tools.
+ * @class
+ * @example
+ * // Using the builder
+ * const protocol = ModelContextProtocol.builder
+ *   .setName("Validator")
+ *   .setVersion("1.2.3")
+ *   .addTool({ name: "ping", description: "", parameters: z.any(), execute: async () => "pong" })
+ *   .build();
+ * @mermaid
+ * sequenceDiagram
+ *   participant Dev as Developer
+ *   participant B as ModelContextProtocol.Builder
+ *   participant MCP as FastMCP
+ *   participant Proto as ModelContextProtocol
+ *   Dev->>B: setName()/setVersion()/addTool()
+ *   Dev->>B: build()
+ *   B->>MCP: new FastMCP({ name, version })
+ *   B->>MCP: addTool(tool...)
+ *   B->>Proto: new ModelContextProtocol(MCP)
+ *   B-->>Dev: ModelContextProtocol
+ */
 export declare class ModelContextProtocol<Auth extends FastMCPSessionAuth = undefined> {
     protected readonly mcp: FastMCP<Auth>;
+    /**
+     * @description Lazily obtains a logger instance for this protocol wrapper.
+     * @summary Uses the Logging facility to create a context-aware Logger bound to this instance.
+     * @return {Logger} A logger instance for this class.
+     */
     protected get log(): Logger;
     constructor(mcp: FastMCP<Auth>);
+    /**
+     * @description Alias to the inner Builder class for external access.
+     * @summary Exposes the builder type to consumers to enable typed construction of ModelContextProtocol instances.
+     */
     static readonly Builder: typeof Builder;
+    /**
+     * @description Factory accessor for a new Builder instance.
+     * @summary Creates a new builder to fluently configure and construct a ModelContextProtocol.
+     * @return {Builder} A new builder instance.
+     */
     static get builder(): Builder;
+    /**
+     * @description Validates a semantic version string.
+     * @summary Utility wrapper around the module-level validateVersion to keep a typed validator close to the class API.
+     * @param {string} version The version string to validate.
+     * @return {string} The normalized semantic version string.
+     */
     private static validateVersion;
 }
 export {};