timonel 3.1.1 → 3.1.2

package/dist/lib/helmChartWriter.d.ts

@@ -1,22 +1,51 @@
+/**
+ * @fileoverview Helm chart writer for generating complete Helm chart structures
+ * @since 2.8.0+
+ */
 import { type TimonelLogger } from './utils/logger.js';
 import type { HelperDefinition as ExternalHelperDefinition } from './utils/helmHelpers/types.js';
+/**
+ * Helm template helper definition shared across helper modules.
+ * @since 2.8.0+ (unified with utils helper definitions in 2.12.2)
+ */
 export type HelperDefinition = ExternalHelperDefinition;
+/**
+ * Metadata for a Helm chart
+ *
+ * Contains all the information needed for Chart.yaml file generation
+ * following Helm chart specification.
+ *
+ * @interface HelmChartMeta
+ * @since 2.8.0+
+ */
 export interface HelmChartMeta {
+    /** Chart name */
     name: string;
+    /** SemVer chart version */
     version: string;
+    /** Chart description */
     description?: string;
+    /** Underlying application version */
     appVersion?: string;
+    /** Chart type */
     type?: 'application' | 'library';
+    /** Kubernetes version constraint */
     kubeVersion?: string;
+    /** Chart keywords for searchability */
     keywords?: string[];
+    /** Chart home page URL */
     home?: string;
+    /** Source code URLs */
     sources?: string[];
+    /** Chart maintainers */
     maintainers?: {
         name: string;
         email?: string;
         url?: string;
     }[];
+    /** Chart icon URL */
     icon?: string;
+    /** Chart dependencies */
     dependencies?: Array<{
         name: string;
         version: string;
@@ -27,34 +56,162 @@ export interface HelmChartMeta {
         importValues?: unknown;
     }>;
 }
+/**
+ * Environment-specific values mapping
+ *
+ * @interface EnvValuesMap
+ * @since 2.8.0+
+ */
 export interface EnvValuesMap {
     [env: string]: Record<string, unknown>;
 }
+/**
+ * Synthesized Kubernetes asset for Helm chart
+ *
+ * Represents a Kubernetes manifest that will be written to the chart's
+ * templates or crds directory.
+ *
+ * @interface SynthAsset
+ * @since 2.8.0+
+ */
 export interface SynthAsset {
+    /** Filename or logical identifier */
     id: string;
+    /** YAML content, may contain multiple documents separated by --- */
     yaml: string;
+    /** Target directory inside chart */
     target?: 'templates' | 'crds';
+    /** If true, don't split into multiple files even with multiple docs */
     singleFile?: boolean;
 }
+/**
+ * Options for writing a complete Helm chart
+ *
+ * @interface HelmChartWriteOptions
+ * @since 2.8.0+
+ */
 export interface HelmChartWriteOptions {
+    /** Output directory path (e.g., dist/charts/my-chart) */
     outDir: string;
+    /** Chart metadata */
     meta: HelmChartMeta;
+    /** Default values for values.yaml */
     defaultValues?: Record<string, unknown> | undefined;
+    /** Environment-specific values (e.g., { dev: {...}, prod: {...} }) */
     envValues?: EnvValuesMap | undefined;
+    /** Kubernetes manifests to place under templates/ */
     assets: SynthAsset[];
+    /** Helm helpers content for templates/_helpers.tpl */
     helpersTpl?: string | HelperDefinition[];
+    /** NOTES.txt content under templates/ */
     notesTpl?: string;
+    /** JSON schema for values validation */
     valuesSchema?: Record<string, unknown>;
+    /**
+     * Custom logger instance
+     * @since 2.13.0
+     */
     logger?: TimonelLogger;
 }
+/**
+ * Helm chart writer for generating complete chart structures
+ *
+ * This class provides static methods to generate a complete Helm chart
+ * including Chart.yaml, values.yaml, templates, and auxiliary files.
+ *
+ * @class HelmChartWriter
+ * @since 2.8.0+
+ *
+ * @example
+ * ```typescript
+ * HelmChartWriter.write({
+ *   outDir: './dist/my-chart',
+ *   meta: { name: 'my-app', version: '1.0.0' },
+ *   assets: []
+ * });
+ * ```
+ */
 export declare class HelmChartWriter {
+    /**
+     * Writes a complete Helm chart to the specified directory
+     *
+     * @param {HelmChartWriteOptions} opts - Chart writing options
+     * @throws {Error} If chart cannot be written
+     * @since 2.8.0+
+     */
     static write(opts: HelmChartWriteOptions): void;
+    /**
+     * Creates the necessary directory structure for the chart
+     *
+     * @private
+     * @param {string} outDir - Output directory path (must be pre-validated)
+     * @throws {Error} If directories cannot be created
+     * @since 2.8.0+
+     */
     private static createDirectories;
+    /**
+     * Writes the Chart.yaml file with chart metadata
+     *
+     * @private
+     * @param {string} outDir - Output directory path
+     * @param {HelmChartMeta} meta - Chart metadata
+     * @throws {Error} If Chart.yaml cannot be written
+     * @since 2.8.0+
+     */
     private static writeChartYaml;
+    /**
+     * Writes values.yaml and environment-specific values files
+     *
+     * @private
+     * @param {string} outDir - Output directory path
+     * @param {Record<string, unknown>} defaultValues - Default values
+     * @param {EnvValuesMap} envValues - Environment-specific values
+     * @throws {Error} If values files cannot be written
+     * @since 2.8.0+
+     */
     private static writeValuesFiles;
+    /**
+     * Writes Kubernetes manifest assets to templates directory
+     *
+     * @private
+     * @param {string} outDir - Output directory path
+     * @param {SynthAsset[]} assets - Kubernetes manifests to write
+     * @since 2.8.0+
+     */
     private static writeAssets;
+    /**
+     * Writes Helm template helpers to _helpers.tpl file
+     *
+     * @private
+     * @param {string} outDir - Output directory path
+     * @param {string | HelperDefinition[]} [helpersTpl] - Helpers content
+     * @since 2.8.0+
+     */
     private static writeHelpers;
+    /**
+     * Writes NOTES.txt file for post-install instructions
+     *
+     * @private
+     * @param {string} outDir - Output directory path
+     * @param {string} [notesTpl] - Notes content
+     * @since 2.8.0+
+     */
     private static writeNotes;
+    /**
+     * Writes values.schema.json for values validation
+     *
+     * @private
+     * @param {string} outDir - Output directory path
+     * @param {Record<string, unknown>} [valuesSchema] - JSON schema
+     * @since 2.8.0+
+     */
     private static writeSchema;
+    /**
+     * Writes .helmignore file with common ignore patterns
+     *
+     * @private
+     * @param {string} outDir - Output directory path
+     * @since 2.8.0+
+     */
     private static writeHelmIgnore;
 }

package/dist/lib/helmChartWriter.js

@@ -1,9 +1,38 @@
+/**
+ * @fileoverview Helm chart writer for generating complete Helm chart structures
+ * @since 2.8.0+
+ */
 import * as fs from 'fs';
 import * as path from 'path';
 import { SecurityUtils } from './security.js';
 import { createLogger } from './utils/logger.js';
 import { dumpHelmAwareYaml, postProcessFieldConditionals } from './utils/helmYamlSerializer.js';
+/**
+ * Helm chart writer for generating complete chart structures
+ *
+ * This class provides static methods to generate a complete Helm chart
+ * including Chart.yaml, values.yaml, templates, and auxiliary files.
+ *
+ * @class HelmChartWriter
+ * @since 2.8.0+
+ *
+ * @example
+ * ```typescript
+ * HelmChartWriter.write({
+ *   outDir: './dist/my-chart',
+ *   meta: { name: 'my-app', version: '1.0.0' },
+ *   assets: []
+ * });
+ * ```
+ */
 export class HelmChartWriter {
+    /**
+     * Writes a complete Helm chart to the specified directory
+     *
+     * @param {HelmChartWriteOptions} opts - Chart writing options
+     * @throws {Error} If chart cannot be written
+     * @since 2.8.0+
+     */
     static write(opts) {
         const { outDir, meta, defaultValues = {}, envValues = {}, assets, helpersTpl, notesTpl, valuesSchema, logger: customLogger, } = opts;
         const logger = customLogger ?? createLogger('helm-chart-writer');
@@ -15,10 +44,13 @@ export class HelmChartWriter {
             assetCount: assets.length,
             operation: 'helm_write_start',
         });
+        // Validate output directory path
         const validatedOutDir = SecurityUtils.validatePath(outDir, process.cwd(), {
             allowAbsolute: true,
         });
+        // Create directory structure
         this.createDirectories(validatedOutDir);
+        // Write chart files
         this.writeChartYaml(validatedOutDir, meta);
         this.writeValuesFiles(validatedOutDir, defaultValues, envValues);
         this.writeAssets(validatedOutDir, assets);
@@ -32,12 +64,31 @@ export class HelmChartWriter {
             outputDirectory: validatedOutDir,
             operation: 'helm_write_complete',
         });
-        timer();
+        timer(); // Complete timing measurement
     }
+    /**
+     * Creates the necessary directory structure for the chart
+     *
+     * @private
+     * @param {string} outDir - Output directory path (must be pre-validated)
+     * @throws {Error} If directories cannot be created
+     * @since 2.8.0+
+     */
     static createDirectories(outDir) {
         const templatesDir = SecurityUtils.validatePath(path.join(outDir, 'templates'), outDir);
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- Path validated by SecurityUtils
         fs.mkdirSync(templatesDir, { recursive: true });
+        // Create crds directory only if needed later
     }
+    /**
+     * Writes the Chart.yaml file with chart metadata
+     *
+     * @private
+     * @param {string} outDir - Output directory path
+     * @param {HelmChartMeta} meta - Chart metadata
+     * @throws {Error} If Chart.yaml cannot be written
+     * @since 2.8.0+
+     */
     static writeChartYaml(outDir, meta) {
         const chartYaml = dumpHelmAwareYaml({
             apiVersion: 'v2',
@@ -55,20 +106,50 @@ export class HelmChartWriter {
             dependencies: meta.dependencies,
         });
         const chartYamlPath = SecurityUtils.validatePath(path.join(outDir, 'Chart.yaml'), outDir);
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- Path validated by SecurityUtils
         fs.writeFileSync(chartYamlPath, chartYaml);
     }
+    /**
+     * Writes values.yaml and environment-specific values files
+     *
+     * @private
+     * @param {string} outDir - Output directory path
+     * @param {Record<string, unknown>} defaultValues - Default values
+     * @param {EnvValuesMap} envValues - Environment-specific values
+     * @throws {Error} If values files cannot be written
+     * @since 2.8.0+
+     */
     static writeValuesFiles(outDir, defaultValues, envValues) {
         const valuesPath = SecurityUtils.validatePath(path.join(outDir, 'values.yaml'), outDir);
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- Path validated by SecurityUtils
         fs.writeFileSync(valuesPath, dumpHelmAwareYaml(defaultValues));
         for (const [env, values] of Object.entries(envValues)) {
+            // Use centralized environment name sanitization
             const sanitizedEnv = SecurityUtils.sanitizeEnvironmentName(env);
             const envValuesPath = SecurityUtils.validatePath(path.join(outDir, `values-${sanitizedEnv}.yaml`), outDir);
+            // eslint-disable-next-line security/detect-non-literal-fs-filename -- Path validated by SecurityUtils
             fs.writeFileSync(envValuesPath, dumpHelmAwareYaml(values));
         }
     }
+    /**
+     * Writes Kubernetes manifest assets to templates directory
+     *
+     * @private
+     * @param {string} outDir - Output directory path
+     * @param {SynthAsset[]} assets - Kubernetes manifests to write
+     * @since 2.8.0+
+     */
     static writeAssets(outDir, assets) {
         writeAssets(outDir, assets);
     }
+    /**
+     * Writes Helm template helpers to _helpers.tpl file
+     *
+     * @private
+     * @param {string} outDir - Output directory path
+     * @param {string | HelperDefinition[]} [helpersTpl] - Helpers content
+     * @since 2.8.0+
+     */
     static writeHelpers(outDir, helpersTpl) {
         if (!helpersTpl)
             return;
@@ -82,22 +163,49 @@ export class HelmChartWriter {
                 .join('\n');
         }
         const helpersPath = SecurityUtils.validatePath(path.join(outDir, 'templates', '_helpers.tpl'), outDir);
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- Path validated by SecurityUtils
         fs.writeFileSync(helpersPath, content);
     }
+    /**
+     * Writes NOTES.txt file for post-install instructions
+     *
+     * @private
+     * @param {string} outDir - Output directory path
+     * @param {string} [notesTpl] - Notes content
+     * @since 2.8.0+
+     */
     static writeNotes(outDir, notesTpl) {
         if (!notesTpl)
             return;
         const notesPath = SecurityUtils.validatePath(path.join(outDir, 'templates', 'NOTES.txt'), outDir);
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- Path validated by SecurityUtils
         fs.writeFileSync(notesPath, notesTpl.endsWith('\n') ? notesTpl : notesTpl + '\n');
     }
+    /**
+     * Writes values.schema.json for values validation
+     *
+     * @private
+     * @param {string} outDir - Output directory path
+     * @param {Record<string, unknown>} [valuesSchema] - JSON schema
+     * @since 2.8.0+
+     */
     static writeSchema(outDir, valuesSchema) {
         if (!valuesSchema)
             return;
         const schemaPath = SecurityUtils.validatePath(path.join(outDir, 'values.schema.json'), outDir);
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- Path validated by SecurityUtils
         fs.writeFileSync(schemaPath, JSON.stringify(valuesSchema, null, 2) + '\n');
     }
+    /**
+     * Writes .helmignore file with common ignore patterns
+     *
+     * @private
+     * @param {string} outDir - Output directory path
+     * @since 2.8.0+
+     */
     static writeHelmIgnore(outDir) {
         const helmIgnorePath = SecurityUtils.validatePath(path.join(outDir, '.helmignore'), outDir);
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- Path validated by SecurityUtils
         if (!fs.existsSync(helmIgnorePath)) {
             const helmIgnore = [
                 '# VCS',
@@ -121,16 +229,34 @@ export class HelmChartWriter {
                 '*.tgz',
                 '',
             ].join('\n');
+            // eslint-disable-next-line security/detect-non-literal-fs-filename -- Chart writer needs dynamic paths
             fs.writeFileSync(helmIgnorePath, helmIgnore);
         }
     }
 }
+/**
+ * Splits YAML string into individual documents
+ *
+ * @private
+ * @param {string} yamlStr - YAML string with potential document separators
+ * @returns {string[]} Array of individual YAML documents
+ * @since 2.8.0+
+ */
 function splitDocs(yamlStr) {
     return yamlStr
         .split(/^---\s*$/m)
         .map((p) => p.trim())
         .filter((p) => p.length);
 }
+/**
+ * Writes all synthesized assets to the chart directory
+ *
+ * @private
+ * @param {string} outDir - Output directory path
+ * @param {SynthAsset[]} assets - Assets to write
+ * @throws {Error} If asset ID contains invalid characters
+ * @since 2.8.0+
+ */
 function writeAssets(outDir, assets) {
     for (const asset of assets) {
         const targetDir = getTargetDirectory(asset.target);
@@ -149,45 +275,89 @@ function writeAssets(outDir, assets) {
         }
     }
 }
+/**
+ * Gets the target directory for an asset
+ *
+ * @private
+ * @param {('templates' | 'crds')} [target] - Target directory type
+ * @returns {string} Directory name
+ * @since 2.8.0+
+ */
 function getTargetDirectory(target) {
     return target === 'crds' ? 'crds' : 'templates';
 }
+/**
+ * Writes a single asset file without document splitting
+ *
+ * @private
+ * @param {string} outDir - Output directory path
+ * @param {string} targetDir - Target subdirectory
+ * @param {string} assetId - Asset identifier
+ * @param {string} yaml - YAML content
+ * @since 2.8.0+
+ */
 function writeSingleAssetFile(outDir, targetDir, directorySegments, fileBaseName, yaml) {
     const chartSubdir = path.join(outDir, targetDir, ...directorySegments);
     SecurityUtils.validatePath(chartSubdir, outDir);
+    // eslint-disable-next-line security/detect-non-literal-fs-filename -- Path validated by SecurityUtils
     fs.mkdirSync(chartSubdir, { recursive: true });
+    // Validate fileBaseName to prevent path traversal
     if (fileBaseName.includes('..') || fileBaseName.includes('/') || fileBaseName.includes('\\')) {
         throw new Error(`Invalid fileBaseName: ${fileBaseName}`);
     }
     const filename = `${fileBaseName}.yaml`;
+    // Validate filename to prevent path traversal
     if (filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
         throw new Error(`Invalid filename: ${filename}`);
     }
     const absolutePath = path.join(chartSubdir, filename);
     SecurityUtils.validatePath(absolutePath, outDir);
+    // Post-process YAML to transform field-level conditionals
     const processedYaml = postProcessFieldConditionals(yaml);
+    // eslint-disable-next-line security/detect-non-literal-fs-filename -- Path validated by SecurityUtils
     fs.writeFileSync(absolutePath, processedYaml.endsWith('\n') ? processedYaml : `${processedYaml}\n`);
 }
+/**
+ * Writes multiple asset files by splitting YAML documents
+ *
+ * @private
+ * @param {string} outDir - Output directory path
+ * @param {string} targetDir - Target subdirectory
+ * @param {string} assetId - Asset identifier
+ * @param {string} yaml - YAML content with potential multiple documents
+ * @since 2.8.0+
+ */
 function writeMultipleAssetFiles(outDir, targetDir, directorySegments, fileBaseName, yaml) {
     const chartSubdir = path.join(outDir, targetDir, ...directorySegments);
     SecurityUtils.validatePath(chartSubdir, outDir);
+    // eslint-disable-next-line security/detect-non-literal-fs-filename -- Chart writer needs dynamic paths
     fs.mkdirSync(chartSubdir, { recursive: true });
+    // Post-process YAML to transform field-level conditionals
     const processedYaml = postProcessFieldConditionals(yaml);
     const parts = splitDocs(processedYaml);
     parts.forEach((doc, index) => {
+        // Validate fileBaseName to prevent path traversal
         if (fileBaseName.includes('..') || fileBaseName.includes('/') || fileBaseName.includes('\\')) {
             throw new Error(`Invalid fileBaseName: ${fileBaseName}`);
         }
         const suffix = parts.length > 1 ? `-${index + 1}` : '';
         const filename = `${fileBaseName}${suffix}.yaml`;
+        // Validate filename to prevent path traversal
         if (filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
             throw new Error(`Invalid filename: ${filename}`);
         }
         const absolutePath = path.join(chartSubdir, filename);
         SecurityUtils.validatePath(absolutePath, outDir);
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- Path validated by SecurityUtils
         fs.writeFileSync(absolutePath, doc.endsWith('\n') ? doc : `${doc}\n`);
     });
 }
+/**
+ * Validates an asset identifier and converts it into directory segments and file basename.
+ * @param assetId - Identifier provided by the synthesizer.
+ * @returns Normalized directory segments and filename stem.
+ * @since 2.12.2 Preserves human-friendly asset identifiers without compromising safety.
+ */
 function resolveAssetPath(assetId) {
     if (!assetId || typeof assetId !== 'string') {
         throw new Error('Asset ID must be a non-empty string');

package/dist/lib/policy/configurationLoader.d.ts

@@ -1,46 +1,178 @@
+/**
+ * Configuration Loader
+ *
+ * This module provides configuration loading and validation for policy plugins.
+ * It supports environment-specific configuration, schema validation, and
+ * configuration inheritance.
+ *
+ * @since 3.0.0
+ */
 import type { JSONSchema, PolicyPlugin, ConfigurationLoaderOptions } from './types.js';
+/**
+ * Configuration source types
+ */
 export type ConfigurationSource = 'environment' | 'file' | 'inline' | 'default';
+/**
+ * Configuration entry with metadata
+ */
 export interface ConfigurationEntry {
+    /** Configuration value */
     readonly value: unknown;
+    /** Source of the configuration */
     readonly source: ConfigurationSource;
+    /** Environment this configuration applies to */
     readonly environment?: string;
+    /** Priority for configuration merging (higher wins) */
     readonly priority: number;
+    /** Validation schema for this configuration */
     readonly schema?: JSONSchema;
 }
+/**
+ * Plugin configuration with validation
+ */
 export interface PluginConfiguration {
+    /** Plugin name */
     readonly pluginName: string;
+    /** Merged configuration value */
     readonly config: Record<string, unknown>;
+    /** Configuration entries that were merged */
     readonly entries: ConfigurationEntry[];
+    /** Whether configuration was validated */
     readonly validated: boolean;
+    /** Validation errors if any */
     readonly validationErrors?: string[];
 }
+/**
+ * Environment-specific configuration
+ */
 export interface EnvironmentConfiguration {
+    /** Environment name (e.g., 'development', 'production') */
     readonly environment: string;
+    /** Plugin configurations for this environment */
     readonly plugins: Record<string, unknown>;
+    /** Global configuration options */
     readonly global?: Record<string, unknown>;
 }
+/**
+ * Configuration loader for policy plugins
+ */
 export declare class ConfigurationLoader {
     private readonly options;
     private readonly logger;
     private readonly configurations;
     private readonly environmentConfigs;
     constructor(options?: ConfigurationLoaderOptions);
+    /**
+     * Loads configuration for a plugin
+     * @param plugin - Plugin to load configuration for
+     * @param environment - Target environment
+     * @param inlineConfig - Inline configuration to merge
+     * @returns Plugin configuration
+     */
     loadPluginConfiguration(plugin: PolicyPlugin, environment?: string, inlineConfig?: Record<string, unknown>): Promise<PluginConfiguration>;
+    /**
+     * Collects configuration entries from all sources
+     * @private
+     */
     private collectConfigurationEntries;
+    /**
+     * Validates plugin configuration
+     * @private
+     */
     private validatePluginConfiguration;
+    /**
+     * Loads environment-specific configuration
+     * @param environment - Environment name
+     * @returns Environment configuration
+     */
     loadEnvironmentConfiguration(environment: string): Promise<EnvironmentConfiguration | undefined>;
+    /**
+     * Validates configuration against a JSON schema
+     * @param config - Configuration to validate
+     * @param schema - JSON schema to validate against
+     * @param pluginName - Plugin name for error reporting
+     * @throws {PluginConfigurationError} When validation fails
+     */
     validateConfiguration(config: Record<string, unknown>, schema: JSONSchema, pluginName: string): void;
+    /**
+     * Adds a configuration entry for a plugin
+     * @param pluginName - Plugin name
+     * @param entry - Configuration entry to add
+     */
     addConfigurationEntry(pluginName: string, entry: ConfigurationEntry): void;
+    /**
+     * Gets all configuration entries for a plugin
+     * @param pluginName - Plugin name
+     * @returns Array of configuration entries
+     */
     getConfigurationEntries(pluginName: string): ConfigurationEntry[];
+    /**
+     * Clears all cached configurations
+     */
     clearCache(): void;
+    /**
+     * Loads file-based configuration for a plugin
+     * @param _pluginName - Plugin name (unused)
+     * @param _environment - Target environment (unused)
+     * @returns Configuration object or undefined
+     * @private
+     */
     private loadFileConfiguration;
+    /**
+     * Loads environment variable configuration for a plugin
+     * @param pluginName - Plugin name
+     * @returns Configuration object or undefined
+     * @private
+     */
     private loadEnvironmentVariableConfiguration;
+    /**
+     * Loads environment configuration from files
+     * @param _environment - Environment name (unused)
+     * @returns Environment configuration or undefined
+     * @private
+     */
     private loadEnvironmentFromFiles;
+    /**
+     * Merges configuration entries by priority
+     * @param entries - Configuration entries to merge
+     * @returns Merged configuration
+     * @private
+     */
     private mergeConfigurations;
+    /**
+     * Parses environment variable value to appropriate type
+     * @param value - Environment variable value
+     * @returns Parsed value
+     * @private
+     */
     private parseEnvironmentValue;
+    /**
+     * Validates a configuration object against a JSON schema
+     * @param config - Configuration to validate
+     * @param schema - JSON schema
+     * @param path - Current path for error reporting
+     * @throws {Error} When validation fails
+     * @private
+     */
     private validateAgainstSchema;
+    /**
+     * Validates basic type constraints
+     * @private
+     */
     private validateBasicType;
+    /**
+     * Validates object properties
+     * @private
+     */
     private validateObjectProperties;
+    /**
+     * Validates required properties
+     * @private
+     */
     private validateRequiredProperties;
+    /**
+     * Validates each property in the object
+     * @private
+     */
     private validateEachProperty;
 }