@re-shell/cli/dist/utils/plugin-command-validation.d.ts

Full-stack development platform uniting microservices and microfrontends. Build complete applications with .NET (ASP.NET Core Web API, Minimal API), Java (Spring Boot, Quarkus, Micronaut, Vert.x), Rust (Actix-Web, Warp, Rocket, Axum), Python (FastAPI, Dja

import { EventEmitter } from 'events';
import { PluginCommandContext } from './plugin-command-registry';
export declare enum ValidationRuleType {
    REQUIRED = "required",
    TYPE = "type",
    RANGE = "range",
    LENGTH = "length",
    PATTERN = "pattern",
    ENUM = "enum",
    CUSTOM = "custom",
    CONDITIONAL = "conditional",
    DEPENDENCY = "dependency",
    EXCLUSION = "exclusion"
}
export declare enum TransformationType {
    CASE = "case",
    TRIM = "trim",
    PARSE = "parse",
    FORMAT = "format",
    NORMALIZE = "normalize",
    CONVERT = "convert",
    SANITIZE = "sanitize",
    EXPAND = "expand",
    RESOLVE = "resolve",
    CUSTOM = "custom"
}
export declare enum ValidationSeverity {
    ERROR = "error",
    WARNING = "warning",
    INFO = "info"
}
export interface ValidationRule {
    type: ValidationRuleType;
    severity: ValidationSeverity;
    message?: string;
    condition?: ValidationCondition;
    validator?: ValidationFunction;
    options?: Record<string, any>;
}
export interface ParameterTransformation {
    type: TransformationType;
    order: number;
    transformer: TransformationFunction;
    options?: Record<string, any>;
    condition?: TransformationCondition;
}
export type ValidationCondition = (value: any, args: Record<string, any>, options: Record<string, any>, context: PluginCommandContext) => boolean;
export type ValidationFunction = (value: any, args: Record<string, any>, options: Record<string, any>, context: PluginCommandContext) => boolean | string;
export type TransformationCondition = (value: any, args: Record<string, any>, options: Record<string, any>, context: PluginCommandContext) => boolean;
export type TransformationFunction = (value: any, args: Record<string, any>, options: Record<string, any>, context: PluginCommandContext) => any;
export interface ValidationResult {
    valid: boolean;
    errors: ValidationIssue[];
    warnings: ValidationIssue[];
    info: ValidationIssue[];
    transformedArgs: Record<string, any>;
    transformedOptions: Record<string, any>;
}
export interface ValidationIssue {
    field: string;
    type: ValidationRuleType;
    severity: ValidationSeverity;
    message: string;
    value: any;
    rule?: ValidationRule;
}
export interface ValidationSchema {
    arguments?: Record<string, ArgumentValidationConfig>;
    options?: Record<string, OptionValidationConfig>;
    globalRules?: ValidationRule[];
    transformations?: ParameterTransformation[];
    strict?: boolean;
    allowUnknown?: boolean;
    failFast?: boolean;
}
export interface ArgumentValidationConfig {
    rules: ValidationRule[];
    transformations?: ParameterTransformation[];
    dependencies?: string[];
    conflicts?: string[];
}
export interface OptionValidationConfig {
    rules: ValidationRule[];
    transformations?: ParameterTransformation[];
    dependencies?: string[];
    conflicts?: string[];
    implies?: string[];
}
export interface BuiltInValidationRules {
    required: (message?: string) => ValidationRule;
    type: (type: string, message?: string) => ValidationRule;
    minLength: (min: number, message?: string) => ValidationRule;
    maxLength: (max: number, message?: string) => ValidationRule;
    min: (min: number, message?: string) => ValidationRule;
    max: (max: number, message?: string) => ValidationRule;
    pattern: (pattern: RegExp, message?: string) => ValidationRule;
    enum: (values: any[], message?: string) => ValidationRule;
    email: (message?: string) => ValidationRule;
    url: (message?: string) => ValidationRule;
    path: (mustExist?: boolean, message?: string) => ValidationRule;
    json: (message?: string) => ValidationRule;
    custom: (validator: ValidationFunction, message?: string) => ValidationRule;
}
export interface BuiltInTransformations {
    trim: (options?: {
        start?: boolean;
        end?: boolean;
    }) => ParameterTransformation;
    lowercase: () => ParameterTransformation;
    uppercase: () => ParameterTransformation;
    camelCase: () => ParameterTransformation;
    kebabCase: () => ParameterTransformation;
    snakeCase: () => ParameterTransformation;
    parseNumber: (options?: {
        float?: boolean;
        base?: number;
    }) => ParameterTransformation;
    parseBoolean: () => ParameterTransformation;
    parseJSON: () => ParameterTransformation;
    expandPath: (options?: {
        relative?: string;
    }) => ParameterTransformation;
    resolvePath: () => ParameterTransformation;
    sanitizeHtml: () => ParameterTransformation;
    normalizeUrl: () => ParameterTransformation;
    custom: (transformer: TransformationFunction, order?: number) => ParameterTransformation;
}
export declare class PluginCommandValidator extends EventEmitter {
    private schemas;
    private validationCache;
    private builtInRules;
    private builtInTransformations;
    private globalValidationConfig;
    constructor();
    private initializeBuiltInRules;
    private initializeBuiltInTransformations;
    registerSchema(commandId: string, schema: ValidationSchema): void;
    removeSchema(commandId: string): boolean;
    validateAndTransform(commandId: string, args: Record<string, any>, options: Record<string, any>, context: PluginCommandContext): Promise<ValidationResult>;
    private validateAndTransformArguments;
    private validateAndTransformOptions;
    private applyTransformationChain;
    private applyTransformations;
    private applyValidationRule;
    private applyGlobalRules;
    private checkDependencies;
    private checkConflicts;
    private checkImplications;
    private generateCacheKey;
    private addToCache;
    getBuiltInRules(): BuiltInValidationRules;
    getBuiltInTransformations(): BuiltInTransformations;
    getValidationStats(): any;
    clearCache(): void;
    updateConfiguration(config: Partial<typeof this.globalValidationConfig>): void;
}
export declare function createCommandValidator(): PluginCommandValidator;
export declare function createValidationSchema(config?: Partial<ValidationSchema>): ValidationSchema;
export declare function formatValidationResult(result: ValidationResult): string;