kanun 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1435 @@
+//#region src/Rules/baseRule.d.ts
+declare class BaseRule {}
+//#endregion
+//#region src/Contracts/IGeneric.d.ts
+interface GenericObject {
+  [key: string]: any;
+}
+interface GenericCallable {
+  (...args: any[]): any;
+}
+//#endregion
+//#region src/Rules/IRuleContract.d.ts
+declare abstract class IRuleContract {
+  /**
+   * The validation error message.
+   */
+  message: string | object;
+  /**
+   * All of the data under validation.
+   */
+  data: object;
+  /**
+   * The lang used to return error messages
+   */
+  lang: string;
+  /**
+   *  Determine if the validation rule passes.
+   */
+  passes(_value: any, _attribute: string): boolean | Promise<boolean>;
+  /**
+   * Get the validation error message.
+   */
+  getMessage(): string | object;
+  /**
+   * Set the data under validation.
+   */
+  setData(data: object): this;
+  /**
+   * Set the tranlation language
+   */
+  setLang(lang: string): this;
+  /**
+   * Get the translated error message based on the specified path
+   */
+  trans(path: string, params?: GenericObject): string;
+}
+//#endregion
+//#region src/payloads/replaceAttributePayload.d.ts
+declare class replaceAttributePayload {
+  /**
+   * Stores the data object
+   */
+  data: GenericObject;
+  /**
+   * The message in which attributes will be replaced
+   */
+  message: string;
+  /**
+   * Parameters that will be used to replace the attributes
+   */
+  parameters: string[];
+  /**
+   * Flag that identifies wether the numeric rule exists or not
+   */
+  hasNumericRule: boolean;
+  /**
+   * The function that will be used to format attributes
+   */
+  getDisplayableAttribute: (key: string) => string;
+  constructor(data: GenericObject, message: string, parameters: string[], hasNumericRule: boolean, getDisplayableAttribute: (key: string) => string);
+}
+//#endregion
+//#region src/Contracts/BaseContract.d.ts
+type InitialRule = string | ValidationCallback | IRuleContract | BaseRule;
+type TRule = string | IRuleContract;
+interface InitialRules extends GenericObject {
+  [key: string]: InitialRule | InitialRule[];
+}
+interface Rules extends GenericObject {
+  [key: string]: TRule[];
+}
+interface ImplicitAttributes {
+  [key: string]: string[];
+}
+type CustomMessages = GenericObject & {};
+type CustomAttributes = GenericObject & {};
+interface ErrorMessage {
+  error_type?: string;
+  message: string;
+}
+interface Errors {
+  [key: string]: ErrorMessage[];
+}
+interface Messages {
+  [key: string]: string[];
+}
+interface CustomErrors {
+  [key: string]: string | string[];
+}
+interface ValidationRuleParserInterface {
+  /**
+   * Convert rules to array
+   *
+   * @param rules
+   * @param data
+   * @returns
+   */
+  explodeRules: (rules: Rules | InitialRule[], data?: GenericObject) => {
+    rules: Rules;
+    implicitAttributes: ImplicitAttributes;
+  };
+  /**
+   * Define a set of rules that apply to each element in an array attribute.
+   *
+   * @param results
+   * @param attribute
+   * @param data
+   * @param implicitAttributes
+   * @returns
+   */
+  explodeWildCardRules: (results: GenericObject, attribute: string, data: GenericObject, implicitAttributes: ImplicitAttributes) => GenericObject;
+  /**
+   * Explode rules that are in string format into array format.
+   *
+   * @param rule
+   * @returns
+   */
+  explodeExplicitRules: (rule: string | InitialRule[]) => TRule[];
+  /**
+   * Prepare the given rule for validation.
+   *
+   * @param rule
+   * @returns
+   */
+  prepareRule: (rule: InitialRule) => TRule;
+  /**
+   * Merge the given rules with any existing rules for the attribute.
+   *
+   * @param results
+   * @param attribute
+   * @param rules
+   * @returns
+   */
+  mergeRulesForAttribute: (results: GenericObject, attribute: string, rules: string | InitialRule[]) => GenericObject;
+  /**
+   * Parse a rule into its name and parameters.
+   *
+   * @param rule
+   * @returns
+   */
+  parse: (rule: TRule) => [TRule, string[]];
+  /**
+   * Parse a string rule into its name and parameters.
+   *
+   * @param rule
+   * @returns
+   */
+  parseStringRule: (rule: string) => [string, string[]];
+  /**
+   * Get a specific rule from the ruleset for an attribute.
+   *
+   * @param attribute
+   * @param searchRules
+   * @param availableRules
+   * @returns
+   */
+  getRule: (attribute: string, searchRules: string | string[], availableRules: Rules) => Partial<[string, string[]]>;
+  /**
+   * Determine if a rule exists in the ruleset for an attribute.
+   *
+   * @param attribute
+   * @param searchRules
+   * @param availableRules
+   * @returns
+   */
+  hasRule: (attribute: string, searchRules: string | string[], availableRules: Rules) => boolean;
+}
+interface ValidationDataInterface {
+  initializeAndGatherData: (attribute: string, masterData: object) => object;
+  initializeAttributeOnData: (attribute: string, masterData: object) => object;
+  extractValuesFromWildCards: (masterData: object, data: object, attribute: string) => object;
+  getLeadingExplicitAttributePath: (attribute: string) => string;
+  extractDataFromPath: (path: string, masterData: object) => object;
+}
+interface ReplaceAttributeInterface {
+  replaceAcceptedIf: (payload: replaceAttributePayload) => string;
+  replaceBefore: (payload: replaceAttributePayload) => string;
+  replaceBeforeOrEqual: (payload: replaceAttributePayload) => string;
+  replaceAfter: (payload: replaceAttributePayload) => string;
+  replaceAfterOrEqual: (payload: replaceAttributePayload) => string;
+  replaceBetween: (payload: replaceAttributePayload) => string;
+  replaceDateEquals: (payload: replaceAttributePayload) => string;
+  replaceDeclinedIf: (payload: replaceAttributePayload) => string;
+  replaceDigits: (payload: replaceAttributePayload) => string;
+  replaceDigitsBetween: (payload: replaceAttributePayload) => string;
+  replaceDifferent: (payload: replaceAttributePayload) => string;
+  replaceEndsWith: (payload: replaceAttributePayload) => string;
+  replaceIn: (payload: replaceAttributePayload) => string;
+  replaceMin: (payload: replaceAttributePayload) => string;
+  replaceMax: (payload: replaceAttributePayload) => string;
+  replaceRequiredWith: (payload: replaceAttributePayload) => string;
+  replaceRequiredWithAll: (payload: replaceAttributePayload) => string;
+  replaceRequiredWithout: (payload: replaceAttributePayload) => string;
+  replaceRequiredWithoutAll: (payload: replaceAttributePayload) => string;
+  replaceGt: (payload: replaceAttributePayload) => string;
+  replaceLt: (payload: replaceAttributePayload) => string;
+  replaceGte: (payload: replaceAttributePayload) => string;
+  replaceLte: (payload: replaceAttributePayload) => string;
+  replaceRequiredIf: (payload: replaceAttributePayload) => string;
+  replaceStartsWith: (payload: replaceAttributePayload) => string;
+  replaceRequiredUnless: (payload: replaceAttributePayload) => string;
+  replaceSame: (payload: replaceAttributePayload) => string;
+  replaceSize: (payload: replaceAttributePayload) => string;
+}
+type ValidationCallback = (value: any, fail: (message: string) => void, attribute: string) => void;
+//#endregion
+//#region src/validators/errorBag.d.ts
+declare class ErrorBag {
+  /**
+   * All of the registered messages.
+   */
+  errors: Errors;
+  /**
+   * All Messages
+   */
+  messages: Messages;
+  /**
+   * Stores the first error message
+   */
+  firstMessage: string;
+  /**
+   * Specify whether error types should be returned or no
+   */
+  withErrorTypes: boolean;
+  constructor(errors?: Errors, messages?: Messages, firstMessage?: string, withErrorTypes?: boolean);
+  /**
+   * Set withErrorTypes attribute to true
+   */
+  addErrorTypes(): ErrorBag;
+  /**
+   * Add new recodrs to the errors and messages objects
+   */
+  add(key: string, error: ErrorMessage): void;
+  /**
+   * Get the first error related to a specific key
+   */
+  first(key?: string | null): string;
+  /**
+   * Get the error messages keys
+   */
+  keys(): string[];
+  /**
+   * Get all the messages related to a specific key
+   */
+  get(key: string, withErrorTypes?: boolean): ErrorMessage[] | string[];
+  /**
+   * Check if key exists in messages
+   */
+  has(key: string): boolean;
+  /**
+   * Get all error messages
+   */
+  all(allMessages?: boolean, withErrorTypes?: boolean): GenericObject;
+  /**
+   * Remove error messages
+   */
+  clear(keys: string[]): ErrorBag;
+  /**
+   * Clone ErrorBag Instance
+   */
+  clone(): ErrorBag;
+}
+//#endregion
+//#region src/BaseValidator.d.ts
+declare class BaseValidator {
+  /**
+   * The lang used to return error messages
+   */
+  private lang;
+  /**
+   * The data object that will be validated
+   */
+  private data;
+  /**
+   * The rules that will be used to check the validity of the data
+   */
+  private rules;
+  /**
+   * This is an unchanged version of the inital rules before being changed for wildcard validations
+   */
+  private initalRules;
+  /**
+   * The array of wildcard attributes with their asterisks expanded.
+   */
+  private implicitAttributes;
+  /**
+   * Hold the error messages
+   */
+  private messages;
+  /**
+   * Stores an instance of the validateAttributes class
+   */
+  private validateAttributes;
+  /**
+   * Flag that defines wether or not validation should stop on first failure
+   */
+  private stopOnFirstFailureFlag;
+  /**
+   * Custom messages returned based on the error
+   */
+  customMessages: CustomMessages;
+  /**
+   * Object of custom attribute name;
+   */
+  customAttributes: CustomAttributes;
+  constructor(data: object, rules: InitialRules, customMessages?: CustomMessages, customAttributes?: CustomAttributes);
+  setData(data: object): this;
+  setRules(rules: InitialRules): this;
+  setLang(lang: string): this;
+  getLang(): string;
+  setCustomMessages(customMessages?: CustomMessages): this;
+  setCustomAttributes(customAttributes?: CustomAttributes): this;
+  stopOnFirstFailure(stopOnFirstFailure?: boolean): this;
+  errors(): ErrorBag;
+  clearErrors(keys?: string[]): ErrorBag;
+  /**
+   * Create a new ErrorBag instance and set the custom errors, thus removing previous error messages
+   */
+  setErrors(errors: CustomErrors): ErrorBag;
+  /**
+   * Append the error messages to the existing ErrorBag instance, thus preserving the old error messages if any
+   */
+  appendErrors(errors: CustomErrors): ErrorBag;
+  /**
+   * Run the validator's rules against its data.
+   */
+  validate(key?: string, value?: any): boolean;
+  /**
+   * Run the validator's rules against its data asynchronously.
+   */
+  validateAsync(key?: string, value?: any): Promise<boolean>;
+  /**
+   * Get the displayable name of the attribute.
+   */
+  getDisplayableAttribute(attribute: string): string;
+  private addCustomErrors;
+  /**
+   * Replace all error message place-holders with actual values.
+   */
+  private makeReplacements;
+  /**
+   * Loop through all rules and run validation against each one of them
+   */
+  private runAllValidations;
+  /**
+   * Loop through all rules and run validation against each one of them asynchronously.
+   */
+  private runAllValidationsAsync;
+  /**
+   * Run validation for one specific attribute
+   */
+  private runSingleValidation;
+  /**
+   * Run validation for one specific attribute asynchronously.
+   */
+  private runSingleValidationAsync;
+  /**
+   * Run validation rules for the specified property and stop validation if needed
+   */
+  private runValidation;
+  /**
+   * Run validation rules for the specified property asynchronously and stop validation if needed
+   */
+  private runValidationAsync;
+  /**
+   * Check if we should stop further validations on a given attribute.
+   */
+  private shouldStopValidating;
+  /**
+   * Parse the given rules add assign them to the current rules
+   */
+  private addRules;
+  /**
+   * validate a given attribute against a rule.
+   */
+  private validateAttribute;
+  /**
+   * Validate an attribute using a custom rule object
+   */
+  private validateUsingCustomRule;
+  /**
+   * Set the error message linked to a custom validation rule
+   */
+  private setCustomRuleErrorMessages;
+  /**
+   * Add a new error message to the messages object
+   */
+  private addFailure;
+  /**
+   * Replace each field parameter which has asterisks with the given keys.
+   *
+   * Example: parameters = [name.*.first] and keys = [1], then the result will be name.1.first
+   */
+  private replaceAsterisksInParameters;
+  /**
+   * Determine if the attribute is validatable.
+   */
+  private isValidatable;
+  /**
+   * Determine if the field is present, or the rule implies required.
+   */
+  private presentOrRuleIsImplicit;
+  /**
+   * Determine if the attribute passes any optional check.
+   */
+  private passesOptionalCheck;
+  /**
+   * Determine if the attribute fails the nullable check.
+   */
+  private isNotNullIfMarkedAsNullable;
+  /**
+   * Get the primary attribute name
+   *
+   * Example:  if "name.0" is given, "name.*" will be returned
+   */
+  private getPrimaryAttribute;
+  /**
+   * Get the explicit keys from an attribute flattened with dot notation.
+   *
+   * Example: 'foo.1.bar.spark.baz' -> [1, 'spark'] for 'foo.*.bar.*.baz'
+   */
+  private getExplicitKeys;
+}
+//#endregion
+//#region src/Contracts/IDatabaseDriver.d.ts
+interface ValidationDatabaseExistsInput {
+  table: string;
+  column: string;
+  value: any;
+  ignore?: any;
+  connection?: string;
+  attribute?: string;
+  data?: Record<string, any>;
+}
+declare abstract class IDatabaseDriver {
+  abstract exists(input: ValidationDatabaseExistsInput): boolean | Promise<boolean>;
+}
+//#endregion
+//#region src/Contracts/IMessageBag.d.ts
+declare class ValidationMessageProvider {
+  getMessageBag(): IMessageBag;
+}
+declare class IMessageBag implements ValidationMessageProvider {
+  /**
+   * Create a new message bag instance.
+   */
+  constructor(messages: Record<string, string[] | string>);
+  getMessageBag(): IMessageBag;
+  /**
+   * Get all message keys.
+   */
+  keys(): string[];
+  /**
+   * Add a message.
+   */
+  add(key: string, message: string): this;
+  /**
+   * Add a message conditionally.
+   */
+  addIf(condition: boolean, key: string, message: string): this;
+  /**
+   * Merge another message source into this one.
+   */
+  merge(messages: Record<string, string[]> | ValidationMessageProvider): this;
+  /**
+   * Determine if messages exist for all given keys.
+   */
+  has(key?: string | string[] | null): boolean;
+  /**
+   * Determine if messages exist for any given key.
+   */
+  hasAny(keys: string | string[]): boolean;
+  /**
+   * Determine if messages don't exist for given keys.
+   */
+  missing(key: string | string[]): boolean;
+  /**
+   * Get the first message for a given key.
+   */
+  first(key?: string | null, format?: string | null): string;
+  /**
+   * Get all messages for a given key.
+   */
+  get(key: string, format?: string | null): string[] | Record<string, string[]>;
+  /**
+   * Get all messages.
+   */
+  all(format?: string): string[];
+  /**
+   * Get unique messages.
+   */
+  unique(format?: string | null): string[];
+  /**
+   * Remove messages for a key.
+   */
+  forget(key: string): this;
+  /**
+   * Get raw messages.
+   */
+  messagesRaw(): Record<string, string[]>;
+  /**
+   * Alias for messagesRaw().
+   */
+  getMessages(): Record<string, string[]>;
+  /**
+   * Return message bag instance.
+   */
+  getMessageBag(): IMessageBag;
+  /**
+   * Get format string.
+   */
+  getFormat(): string;
+  /**
+   * Set default message format.
+   */
+  setFormat(format: string): this;
+  /**
+   * Empty checks.
+   */
+  isEmpty(): boolean;
+  isNotEmpty(): boolean;
+  any(): boolean;
+  /**
+   * Count total messages.
+   */
+  count(): number;
+  /**
+   * Array & JSON conversions.
+   */
+  toArray(): Record<string, string[]>;
+  jsonSerialize(): any;
+  toJson(options: number): string;
+  toPrettyJson(): string;
+  /**
+   * String representation.
+   */
+  toString(): string;
+}
+//#endregion
+//#region src/Contracts/RuleBuilder.d.ts
+interface ValidationRuleCallable {
+  name: string;
+  validator: (value: any, parameters?: string[], attribute?: string) => boolean | Promise<boolean>;
+  message?: string;
+}
+type CustomValidationRules = IValidationRule | ValidationRuleCallable;
+declare class BaseValidationRuleClass {}
+//#endregion
+//#region src/Contracts/IValidationRule.d.ts
+declare abstract class IValidationRule {
+  rules: ValidationRuleCallable[];
+  /**
+   * Run the validation rule.
+   */
+  abstract validate(attribute: string, value: any, fail: (msg: string) => any): void;
+  /**
+   * Set the current validator.
+   */
+  /**
+   * Set the data under validation.
+   */
+  setData(_data: Record<string, any>): this;
+  passes(value: any, attribute: string): boolean | Promise<boolean>;
+}
+//#endregion
+//#region src/Rules/in.d.ts
+declare class In extends BaseRule {
+  /**
+   * The name of the rule.
+   */
+  rule: string;
+  /**
+   * The accepted values.
+   */
+  values: (string | number)[];
+  /**
+   * Create a new In rule instance.
+   */
+  constructor(values: (string | number)[]);
+  /**
+   * Convert the rule to a validation string.
+   */
+  toString(): string;
+}
+//#endregion
+//#region src/Rules/notIn.d.ts
+declare class NotIn extends BaseRule {
+  /**
+   * The name of the rule.
+   */
+  rule: string;
+  /**
+   * The accepted values.
+   */
+  values: (string | number)[];
+  /**
+   * Create a new NotIn rule instance.
+   */
+  constructor(values: (string | number)[]);
+  /**
+   * Convert the rule to a validation string.
+   */
+  toString(): string;
+}
+//#endregion
+//#region src/Rules/regex.d.ts
+declare class Regex extends IRuleContract {
+  /**
+   * The Regular expression to validate
+   */
+  regex: RegExp;
+  /**
+   * Flag that decides whether the value should match the regular expression or not
+   */
+  shouldMatch: boolean;
+  constructor(regex: RegExp, shouldMatch?: boolean);
+  passes(value: any): boolean;
+  getMessage(): string;
+}
+//#endregion
+//#region src/Rules/requiredIf.d.ts
+declare class RequiredIf extends BaseRule {
+  /**
+   * The condition that validates the attribute
+   */
+  condition: boolean | CallableFunction;
+  /**
+   * Create a new required validation rule based on a condition.
+   */
+  constructor(condition: boolean | CallableFunction);
+  /**
+   * Convert the rule to a validation string.
+   */
+  toString(): string;
+}
+//#endregion
+//#region src/Contracts/ValidationRuleName.d.ts
+type ParamableValidationRuleName = 'accepted_if' | 'after' | 'after_or_equal' | 'before' | 'before_or_equal' | 'between' | 'date_equals' | 'datetime' | 'declined_if' | 'digits_between' | 'different' | 'exists' | 'ends_with' | 'gt' | 'gte' | 'in' | 'includes' | 'lt' | 'lte' | 'max' | 'min' | 'not_in' | 'not_includes' | 'required_if' | 'required_unless' | 'required_with' | 'required_with_all' | 'required_without' | 'required_without_all' | 'same' | 'size' | 'starts_with' | 'unique';
+type PlainRuleName = 'accepted' | 'alpha' | 'alpha_dash' | 'alpha_num' | 'array' | 'array_unique' | 'bail' | 'boolean' | 'confirmed' | 'date' | 'declined' | 'digits' | 'email' | 'integer' | 'json' | 'not_regex' | 'nullable' | 'numeric' | 'object' | 'present' | 'regex' | 'required' | 'sometimes' | 'string' | 'url' | 'hex' | 'uuid';
+type ValidationRuleName = ParamableValidationRuleName | PlainRuleName;
+type MethodRules = Regex | In | NotIn | RequiredIf;
+/**
+ * Single rule value (supports autocomplete + arbitrary strings + RuleContract instances)
+ */
+type RuleName = ValidationRuleName | `${ParamableValidationRuleName}:${string}` | IRuleContract | MethodRules;
+type ValidationRuleSet = RuleName | RuleName[] | `${ValidationRuleName}${string & `|${string}`}`;
+//#endregion
+//#region src/Contracts/ValidatorContracts.d.ts
+/**
+ * Parse rule names from rule string or string[] definitions
+ */
+type ExtractRules<R> = R extends string ? R extends `${infer Head}|${infer Tail}` ? Head extends `${infer Rule}:${string}` ? Rule | ExtractRules<Tail> : Head | ExtractRules<Tail> : R extends `${infer Rule}:${string}` ? Rule : R : R extends string[] ? ExtractRules<R[number]> : never;
+/**
+ * Flatten data structure into dot-notation keys
+ * including wildcards (*) for arrays.
+ */
+type DotPaths<T, Prefix extends string = ''> = { [K in keyof T & string]: T[K] extends (infer A)[] ? `${Prefix}${K}` | `${Prefix}${K}.*` | (A extends Record<string, any> ? `${Prefix}${K}.*.${DotPaths<A>}` : never) : T[K] extends Record<string, any> ? `${Prefix}${K}` | `${Prefix}${K}.${DotPaths<T[K]>}` : `${Prefix}${K}` }[keyof T & string];
+/**
+* Builds message keys only for rules used on that field
+*/
+type FieldMessages<Field extends string, R> = `${Field}` | `${Field}.${ExtractRules<R> & ValidationRuleName}`;
+/**
+* Build all valid message keys for a given rules object
+*/
+type MessagesForRules<Rules extends Record<string, any>> = { [K in keyof Rules & string]: FieldMessages<K, Rules[K]> }[keyof Rules & string];
+/**
+ * Make rules align with keys in the data object
+ */
+type RulesForData<D extends Record<string, any>> = Partial<Record<DotPaths<D>, ValidationRuleSet>>;
+//#endregion
+//#region src/Contracts/IValidator.d.ts
+declare class IValidator<D extends Record<string, any> = any, R extends RulesForData<D> = RulesForData<D>> {
+  constructor(data: D, rules: R, messages: Partial<Record<MessagesForRules<R>, string>>);
+  /**
+   * Validate the data and return the instance
+   */
+  static make<D extends Record<string, any>, R extends RulesForData<D>>(data: D, rules: R, messages: Partial<Record<MessagesForRules<R>, string>>): IValidator<D, R>;
+  static useDatabase(driver: IDatabaseDriver): typeof IValidator;
+  /**
+   * Run the validator and store results.
+   */
+  passes(): Promise<boolean>;
+  /**
+   * Opposite of passes()
+   */
+  fails(): Promise<boolean>;
+  /**
+   * Throw if validation fails, else return executed data
+   *
+   * @throws ValidationException if validation fails
+   */
+  validate(): Promise<Record<string, any>>;
+  /**
+   * Run the validator's rules against its data.
+   * @param bagName
+   * @returns
+   */
+  validateWithBag(bagName: string): Promise<Record<string, any>>;
+  /**
+   * Stop validation on first failure.
+   */
+  stopOnFirstFailure(): this;
+  /**
+   * Get the data that passed validation.
+   */
+  validatedData(): Record<string, any>;
+  /**
+   * Return all validated input.
+   */
+  validated(): Partial<D>;
+  /**
+   * Return a portion of validated input
+   */
+  safe(): {
+    only: (keys: string[]) => Partial<D>;
+    except: (keys: string[]) => Partial<D>;
+  };
+  /**
+   * Get the message container for the validator.
+   */
+  messages(): Promise<Partial<Record<MessagesForRules<R>, string>>>;
+  /**
+   * Add an after validation callback.
+   *
+   * @param  callback
+   */
+  after<C extends ((validator: IValidator<D, R>) => void) | BaseValidationRuleClass>(callback: C | C[]): this;
+  /**
+   * Get all errors.
+   */
+  errors(): IMessageBag;
+  errorBag(): string;
+  /**
+   * Reset validator with new data.
+   */
+  setData(data: D): this;
+  /**
+   * Set validation rules.
+   */
+  setRules(rules: R): this;
+  /**
+   * Add a single rule to existing rules.
+   */
+  addRule(key: DotPaths<D>, rule: ValidationRuleSet): this;
+  /**
+   * Merge additional rules.
+   */
+  mergeRules(rules: Record<string, string>): this;
+  /**
+   * Get current data.
+   */
+  getData(): Record<string, any>;
+  /**
+   * Get current rules.
+   */
+  getRules(): R;
+  database(driver: IDatabaseDriver): this;
+  getDatabaseDriver(): IDatabaseDriver | undefined;
+}
+//#endregion
+//#region src/Rules/password.d.ts
+declare class Password$1 extends IRuleContract {
+  /**
+   * The validator performing the validation.
+   */
+  private validator;
+  /**
+   * The minimum size of the password.
+   */
+  private minLength;
+  /**
+   * The min amount of lower case letters required in the password
+   */
+  private minLowerCase;
+  /**
+   * The min amount of uppercase letters required in the password
+   */
+  private minUpperCase;
+  /**
+   * The min amount of letters required in the password
+   */
+  private minLetters;
+  /**
+   * The min amount of letters required in the password
+   */
+  private minNumbers;
+  /**
+   * The min amount of symbols required in the password
+   */
+  private minSymbols;
+  /**
+   * Additional validation rules that should be merged into the default rules during validation.
+   */
+  private customRules;
+  /**
+   * The callback that will generate the "default" version of the password rule.
+   */
+  static defaultCallback: GenericCallable | Password$1;
+  /**
+   * Create a new instance of the password class
+   */
+  static create(): Password$1;
+  /**
+   * Set the minimum length of the password
+   */
+  min(min: number): Password$1;
+  /**
+   * Set the min amount of letters required in the password
+   */
+  letters(letters?: number): Password$1;
+  /**
+   * Set the min amount of upper and lower case letters required in the password
+   */
+  mixedCase(upperCase?: number, lowerCase?: number): Password$1;
+  /**
+   * Set the min amount of numbers required in the password
+   */
+  numbers(numbers?: number): Password$1;
+  /**
+   * Set the min amount of symbols required in the password
+   */
+  symbols(symbols?: number): Password$1;
+  /**
+   * Determine if the validation rule passes.
+   */
+  passes(value: any, attribute: string): boolean;
+  /**
+   * Specify additional validation rules that should be merged with the default rules during validation.
+   */
+  rules(rules: InitialRule[]): Password$1;
+  /**
+   * Get all the validation error messages related to the password
+   */
+  getMessage(): object;
+  /**
+   * Set the validator instance used to validate the password
+   */
+  setValidator(validator: BaseValidator): Password$1;
+  /**
+   * Set the default callback to be used for determining a password's default rules.
+   */
+  static setDefault(callback?: GenericCallable | Password$1 | null): void;
+  /**
+   * Get the default configuration of the password rule.
+   */
+  static default(): IRuleContract | Password$1;
+}
+//#endregion
+//#region src/Rules/registerRule.d.ts
+declare function register(rule: string, validate: (value: any, parameters?: string[], attribute?: string) => boolean | Promise<boolean>, replaceMessage?: (message: string, paramters: string[], data?: object, getDisplayableAttribute?: GenericCallable) => string): boolean;
+declare function registerImplicit(rule: string, validate: (value: any, parameters?: string[] | number[], attribute?: string) => boolean | Promise<boolean>, replaceMessage?: (message: string, paramters: string[], data?: object, getDisplayableAttribute?: GenericCallable) => string): void;
+//#endregion
+//#region src/rule.d.ts
+declare function requiredIf(callback: boolean | CallableFunction): RequiredIf;
+declare function ruleIn(values: (string | number)[]): In;
+declare function ruleNotIn(values: (string | number)[]): NotIn;
+declare function regex(value: RegExp): Regex;
+declare function notRegex(value: RegExp): Regex;
+//#endregion
+//#region src/Core.d.ts
+declare class Password extends Password$1 {}
+declare function make(data?: GenericObject, rules?: InitialRules, customMessages?: CustomMessages, customAttributes?: CustomAttributes): BaseValidator;
+//#endregion
+//#region src/Rules/IImplicitRule.d.ts
+declare class IImplicitRule extends IRuleContract {
+  readonly __isImplicitRule = true;
+}
+//#endregion
+//#region src/utilities/MessageBag.d.ts
+declare class MessageBag implements IMessageBag {
+  /**
+   * All of the registered messages.
+   */
+  protected messages: Record<string, string[]>;
+  /**
+   * Default format for message output.
+   */
+  protected format: string;
+  /**
+   * Create a new message bag instance.
+   */
+  constructor(messages?: Record<string, string[] | string>);
+  /**
+   * Get all message keys.
+   */
+  keys(): string[];
+  /**
+   * Add a message.
+   */
+  add(key: string, message: string): this;
+  /**
+   * Add a message conditionally.
+   */
+  addIf(condition: boolean, key: string, message: string): this;
+  /**
+   * Check uniqueness of key/message pair.
+   */
+  protected isUnique(key: string, message: string): boolean;
+  /**
+   * Merge another message source into this one.
+   */
+  merge(messages: Record<string, string[]> | ValidationMessageProvider): this;
+  /**
+   * Determine if messages exist for all given keys.
+   */
+  has(key: string | string[] | null): boolean;
+  /**
+   * Determine if messages exist for any given key.
+   */
+  hasAny(keys?: string | string[]): boolean;
+  /**
+   * Determine if messages don't exist for given keys.
+   */
+  missing(key: string | string[]): boolean;
+  /**
+   * Get the first message for a given key.
+   */
+  first(key?: string | null, format?: string | null): string;
+  /**
+   * Get all messages for a given key.
+   */
+  get(key: string, format?: string | null): string[] | Record<string, string[]>;
+  /**
+   * Wildcard key match.
+   */
+  protected getMessagesForWildcardKey(key: string, format: string | null): Record<string, string[]>;
+  /**
+   * Get all messages.
+   */
+  all(format?: string | null): string[];
+  /**
+   * Get unique messages.
+   */
+  unique(format?: string | null): string[];
+  /**
+   * Remove messages for a key.
+   */
+  forget(key: string): this;
+  /**
+   * Format an array of messages.
+   */
+  protected transform(messages: string[], format: string, messageKey: string): string[];
+  /**
+   * Get proper format string.
+   */
+  protected checkFormat(format?: string | null): string;
+  /**
+   * Get raw messages.
+   */
+  messagesRaw(): Record<string, string[]>;
+  /**
+   * Alias for messagesRaw().
+   */
+  getMessages(): Record<string, string[]>;
+  /**
+   * Return message bag instance.
+   */
+  getMessageBag(): MessageBag;
+  /**
+   * Get format string.
+   */
+  getFormat(): string;
+  /**
+   * Set default message format.
+   */
+  setFormat(format?: string): this;
+  /**
+   * Empty checks.
+   */
+  isEmpty(): boolean;
+  isNotEmpty(): boolean;
+  any(): boolean;
+  /**
+   * Count total messages.
+   */
+  count(): number;
+  /**
+   * Array & JSON conversions.
+   */
+  toArray(): Record<string, string[]>;
+  jsonSerialize(): any;
+  toJson(options?: number): string;
+  toPrettyJson(): string;
+  /**
+   * String representation.
+   */
+  toString(): string;
+}
+//#endregion
+//#region src/Validator.d.ts
+declare class Validator<D extends Record<string, any> = any, R extends RulesForData<D> = RulesForData<D>> implements IValidator<D, R> {
+  #private;
+  private static defaultDatabaseDriver?;
+  private data;
+  private rules;
+  private _errors;
+  private passing;
+  private executed;
+  private instance?;
+  private databaseDriver?;
+  private errorBagName;
+  private registeredCustomRules;
+  private shouldStopOnFirstFailure;
+  constructor(data: D, rules: R, messages?: Partial<Record<MessagesForRules<R>, string>>);
+  /**
+   * Validate the data and return the instance
+   */
+  static make<D extends Record<string, any>, R extends RulesForData<D>>(data: D, rules: R, messages?: Partial<Record<MessagesForRules<R>, string>>): Validator<D, R>;
+  static useDatabase(driver: IDatabaseDriver): typeof Validator;
+  /**
+   * Run the validator and store results.
+   */
+  passes(): Promise<boolean>;
+  /**
+   * Opposite of passes()
+   */
+  fails(): Promise<boolean>;
+  /**
+   * Throw if validation fails, else return executed data
+   *
+   * @throws ValidationException if validation fails
+   */
+  validate(): Promise<Record<string, any>>;
+  /**
+   * Run the validator's rules against its data.
+   * @param bagName
+   * @returns
+   */
+  validateWithBag(bagName: string): Promise<Record<string, any>>;
+  /**
+   * Stop validation on first failure.
+   */
+  stopOnFirstFailure(): this;
+  /**
+   * Get the data that passed validation.
+   */
+  validatedData(): Record<string, any>;
+  /**
+   * Return all validated input.
+   */
+  validated(): Partial<D>;
+  /**
+   * Return a portion of validated input
+   */
+  safe(): {
+    only: (keys: string[]) => Partial<D>;
+    except: (keys: string[]) => Partial<D>;
+  };
+  /**
+   * Get the message container for the validator.
+   */
+  messages(): Promise<Partial<Record<MessagesForRules<R>, string>>>;
+  /**
+   * Add an after validation callback.
+   *
+   * @param  callback
+   */
+  after<C extends ((validator: Validator<D, R>) => void) | BaseValidationRuleClass>(callback: C | C[]): this;
+  /**
+   * Get all errors.
+   */
+  errors(): MessageBag;
+  errorBag(): string;
+  /**
+   * Reset validator with new data.
+   */
+  setData(data: D): this;
+  /**
+   * Set validation rules.
+   */
+  setRules(rules: R): this;
+  /**
+   * Add a single rule to existing rules.
+   */
+  addRule(key: DotPaths<D>, rule: ValidationRuleSet): this;
+  /**
+   * Merge additional rules.
+   */
+  mergeRules(rules: Record<string, string>): this;
+  /**
+   * Get current data.
+   */
+  getData(): Record<string, any>;
+  /**
+   * Get current rules.
+   */
+  getRules(): R;
+  database(driver: IDatabaseDriver): this;
+  getDatabaseDriver(): IDatabaseDriver | undefined;
+  /**
+   * Bind all required services here.
+   */
+  private bindServices;
+  private execute;
+}
+//#endregion
+//#region src/ImplicitRule.d.ts
+declare abstract class ImplicitRule extends IImplicitRule {
+  rules: ValidationRuleCallable[];
+  /**
+   * Run the validation rule.
+   */
+  abstract validate(attribute: string, value: any, fail: (msg: string) => any): void;
+  /**
+   * Set the current validator.
+   */
+  setValidator?(validator: Validator<any, any>): this;
+}
+//#endregion
+//#region src/Lang.d.ts
+declare class Lang {
+  /**
+   * Default lang to be used, when lang is not specified
+   */
+  static defaultLang: string;
+  /**
+   * Determines the locale to be used when tu current one is not available
+   */
+  static fallbackLang: string;
+  /**
+   * The existing langs that are supported by the library
+   */
+  static existingLangs: string[];
+  /**
+   * Store the translations passed by the user
+   */
+  static translations: GenericObject;
+  /**
+   * Stores the messages that are already loaded
+   */
+  static messages: GenericObject;
+  /**
+   * Stores the default messages
+   */
+  static defaultMessages: GenericObject;
+  /**
+   * Stores the fallback messages
+   */
+  static fallbackMessages: GenericObject;
+  /**
+   * Get messages for lang
+   *
+   * @param lang
+   * @returns
+   */
+  static get(lang?: string): GenericObject;
+  /**
+   * Set the translation object passed by the user
+   *
+   * @param translations
+   */
+  static setTranslationObject(translations: GenericObject): void;
+  /**
+   * Set the default lang that should be used. And assign the default messages
+   *
+   * @param lang
+   */
+  static setDefaultLang(lang: string): void;
+  /**
+   * Set the fallback lang to be used. And assign the fallback messages
+   *
+   * @param lang
+   */
+  static setFallbackLang(lang: string): void;
+  /**
+   * Get the default language
+   *
+   * @returns
+   */
+  static getDefaultLang(): string;
+  /**
+   * Load the messages based on the specified language
+   *
+   * @param lang
+   * @returns
+   */
+  static load(lang: string): void;
+}
+//#endregion
+//#region src/Providers/ValidationServiceProvider.d.ts
+/**
+ * Service provider for Validation utilities
+ */
+declare class ValidationServiceProvider {
+  private app;
+  registeredCommands?: (new (app: any, kernel: any) => any)[];
+  static priority: number;
+  constructor(app: any);
+  /**
+   * Register URL services in the container
+   */
+  register(): void;
+  /**
+   * Boot URL services
+   */
+  boot(): void;
+}
+//#endregion
+//#region src/ValidationRule.d.ts
+declare abstract class ValidationRule<D extends Record<string, any> = any, R extends RulesForData<D> = any> extends IRuleContract implements IValidationRule {
+  rules: ValidationRuleCallable[];
+  private passing;
+  /**
+   * Run the validation rule.
+   */
+  abstract validate(attribute: string, value: any, fail: (msg: string) => any): void;
+  /**
+   * Set the current validator.
+   */
+  setValidator?(validator: Validator<D, R>): this;
+  /**
+   * Set the data under validation.
+   */
+  setData(_data: Record<string, any>): this;
+  passes(value: any, attribute: string): boolean | Promise<boolean>;
+}
+//#endregion
+//#region src/Rules/ExtendedRules.d.ts
+declare class ExtendedRules extends ValidationRule {
+  /**
+   * The validator instance.
+   */
+  protected validator: Validator<any, any>;
+  setValidator(validator: Validator<any, any>): this;
+  private resolveTarget;
+  rules: ValidationRuleCallable[];
+  validate(): void;
+}
+//#endregion
+//#region src/utilities/build.d.ts
+declare function buildValidationMethodName(rule: string): string;
+//#endregion
+//#region src/utilities/date.d.ts
+/**
+ * Convert value to date instance
+ */
+declare function toDate(value: any): Date | null;
+//#endregion
+//#region src/utilities/formatMessages.d.ts
+/**
+ * Get the validation message for an attribute and rule.
+ */
+declare function getMessage(attributes: string[], rule: string, value: any, customMessages: CustomMessages, hasNumericRule: boolean, lang: string): string;
+/**
+ * Convert a string to snake case.
+ */
+declare function toSnakeCase(string: string): string;
+/**
+ * Get the formatted name of the attribute
+ */
+declare function getFormattedAttribute(attribute: string): string;
+/**
+ * Get the combinations of keys from a main key. For example if the main key is 'user.info.name',
+ * the combination will be [user.info.name, info.name, name]
+ */
+declare function getKeyCombinations(key: string): string[];
+//#endregion
+//#region src/utilities/general.d.ts
+/**
+ * Get the size of a value based on its type
+ */
+declare function getSize(value: any, hasNumericRule?: boolean): number;
+/**
+ * Check if two values are of the same type
+ */
+declare function sameType(value: any, otherValue: any): boolean;
+/**
+ * Check if Value is an Ineteger
+ */
+declare function isInteger(value: any): boolean;
+/**
+ * Check if the value can be considered as rule
+ */
+declare function isRule(value: any): boolean;
+/**
+ * Check if the array contain any potentiel valid rule
+ */
+declare function isArrayOfRules(values: any[]): boolean;
+/**
+ * Check if the rule is related to size
+ */
+declare function isSizeRule(rule: string): boolean;
+/**
+ * Check if rule implies that the field is required
+ */
+declare function isImplicitRule(rule: TRule): boolean;
+/**
+ * Add a new implicit rule
+ */
+declare function addImplicitRule(rule: string): void;
+/**
+ * Returns the numeric rules
+ */
+declare function getNumericRules(): string[];
+/**
+ * Check if the rule is numeric
+ */
+declare function isNumericRule(rule: string): boolean;
+/**
+ * Determine if a comparison passes between the given values.
+ */
+declare function compare(first: any, second: any, operator: string, strict?: boolean): boolean;
+/**
+ * Convert the given values to boolean if they are string "true" / "false".
+ */
+declare function convertValuesToBoolean(values: string[]): (string | boolean)[];
+/**
+ * Convert the given values to numbers if they are numbers in a string "1", "2"
+ */
+declare function convertValuesToNumber(values: string[]): (string | number)[];
+/**
+ * Convert the given values to null if they have null values in a string "null", "NULL"
+ */
+declare function convertValuesToNull(values: string[]): (string | null)[];
+//#endregion
+//#region src/utilities/helpers.d.ts
+/**
+ * Pluralizes a word based on the count.
+ *
+ * @param word
+ * @param count
+ * @returns
+ */
+declare const plural: (word: string, count: number) => string;
+//#endregion
+//#region src/utilities/object.d.ts
+/**
+ * Get value at path of object. If the resolved value is undifined, the returned result will be undefined
+ *
+ * @param obj
+ * @param path
+ * @returns
+ */
+declare function deepFind(obj: GenericObject, path: string): any;
+/**
+ * Set value at path of object.
+ *
+ * @param target
+ * @param path
+ * @param value
+ */
+declare function deepSet(target: any, path: string | string[], value: any): void;
+/**
+ * Flatten a multi-dimensional associative array with dots.
+ *
+ * @param obj
+ * @param ignoreRulesArray
+ * @param withBaseObjectType
+ * @returns
+ */
+declare function dotify(obj: GenericObject, ignoreRulesArray?: boolean, withBaseObjectType?: boolean): GenericObject;
+/**
+ * Check if the value is an object
+ *
+ * @param value
+ * @returns
+ */
+declare function isObject(value: any): any;
+/**
+ * Deeply merge nested objects
+ *
+ * @param target
+ * @param source
+ * @returns
+ */
+declare function mergeDeep(target: GenericObject, source: GenericObject): GenericObject;
+/**
+ * Check if objects are deep equal
+ *
+ * @param firstParam
+ * @param secondParam
+ * @returns
+ */
+declare function deepEqual(firstParam: GenericObject, secondParam: GenericObject): boolean;
+//#endregion
+//#region src/ValidationException.d.ts
+declare class ValidationException extends Error {
+  validator: Validator<any, any>;
+  response?: any;
+  status: number;
+  errorBag: string;
+  redirectTo?: string;
+  name: string;
+  constructor(validator: Validator<any, any>, response?: any, errorBag?: string);
+  /**
+   * Send a custom response body for this exception
+   *
+   * @param request
+   * @returns
+   */
+  toResponse(): {
+    message: string;
+    errors: Record<string, string[]>;
+  };
+  /**
+   * Create a new validation exception from a plain array of messages.
+   */
+  static withMessages(messages: Record<string, string[] | string>): ValidationException;
+  /**
+   * Create a readable summary message from the validation errors.
+   */
+  protected static summarize(validator: Validator<any, any>): string;
+  /**
+   * Get all of the validation error messages.
+   */
+  errors(): Record<string, string[]>;
+  /**
+   * Set the HTTP status code to be used for the response.
+   */
+  setStatus(status: number): this;
+  /**
+   * Set the error bag on the exception.
+   */
+  setErrorBag(errorBag: string): this;
+  /**
+   * Set the URL to redirect to on a validation error.
+   */
+  setRedirectTo(url: string): this;
+  /**
+   * Get the underlying response instance.
+   */
+  getResponse(): any;
+}
+//#endregion
+export { BaseValidationRuleClass, BaseValidator, CustomAttributes, CustomErrors, CustomMessages, CustomValidationRules, DotPaths, ErrorBag, ErrorMessage, Errors, ExtendedRules, ExtractRules, FieldMessages, GenericCallable, GenericObject, IDatabaseDriver, IMessageBag, IValidationRule, IValidator, ImplicitAttributes, ImplicitRule, InitialRule, InitialRules, Lang, MessageBag, Messages, MessagesForRules, ParamableValidationRuleName, Password, PlainRuleName, ReplaceAttributeInterface, Rules, RulesForData, TRule, ValidationCallback, ValidationDataInterface, ValidationDatabaseExistsInput, ValidationException, ValidationMessageProvider, ValidationRule, ValidationRuleCallable, ValidationRuleName, ValidationRuleParserInterface, ValidationRuleSet, ValidationServiceProvider, Validator, addImplicitRule, buildValidationMethodName, compare, convertValuesToBoolean, convertValuesToNull, convertValuesToNumber, deepEqual, deepFind, deepSet, dotify, getFormattedAttribute, getKeyCombinations, getMessage, getNumericRules, getSize, isArrayOfRules, isImplicitRule, isInteger, isNumericRule, isObject, isRule, isSizeRule, make, mergeDeep, notRegex, plural, regex, register, registerImplicit, requiredIf, ruleIn, ruleNotIn, sameType, toDate, toSnakeCase };