@maroonedog/luq 0.1.0-alpha

package/dist/core/plugin/numberInteger.d.ts

@@ -0,0 +1,41 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name numberInteger
+ * @category standard
+ * @description Validates that a number is an integer (whole number without decimals)
+ * @allowedTypes ["number"]
+ * @example
+ * ```typescript
+ * // Basic usage - ensures number is an integer
+ * const validator = Builder()
+ *   .use(numberIntegerPlugin)
+ *   .for<OrderData>()
+ *   .v("quantity", (b) => b.number.integer())
+ *   .v("count", (b) => b.number.required().integer())
+ *   .build();
+ *
+ * // Combined with range validation
+ * builder.v("score", b => b.number.integer().min(0).max(100))
+ *
+ * // For ID validation
+ * builder.v("userId", b => b.number.required().integer().positive())
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if number is an integer
+ * @customError
+ * ```typescript
+ * .integer({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be a whole number (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const numberIntegerPlugin: import("../..").TypedPlugin<"numberInteger", "integer", (options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: ValidationOptions<{}>[];
+}, readonly ["number"], "validator", "standard">;

package/dist/core/plugin/numberMax.d.ts

@@ -0,0 +1,49 @@
+import { ValidationOptions, MessageContext } from "./types";
+export interface NumberMaxContext extends MessageContext {
+    max: number;
+    actual: number;
+    exclusive: boolean;
+}
+/**
+ * @luq-plugin
+ * @name numberMax
+ * @category standard
+ * @description Validates that a number is less than or equal to the specified maximum value
+ * @allowedTypes ["number"]
+ * @example
+ * ```typescript
+ * // Basic usage - set maximum allowed value
+ * const validator = Builder()
+ *   .use(numberMaxPlugin)
+ *   .for<Settings>()
+ *   .v("percentage", (b) => b.number.max(100))
+ *   .v("discount", (b) => b.number.max(50))
+ *   .v("temperature", (b) => b.number.max(40))
+ *   .build();
+ *
+ * // For percentages with range
+ * builder.v("successRate", b => b.number.min(0).max(100))
+ * ```
+ * @params
+ * - max: number - Maximum allowed value (inclusive)
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if number is less than or equal to maximum
+ * @customError
+ * ```typescript
+ * .max(100, {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must not exceed ${params.max} (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const numberMaxPlugin: import("../..").TypedPlugin<"numberMax", "max", (maxValue: number, options?: ValidationOptions<NumberMaxContext> & {
+    exclusive?: boolean;
+}) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (number | (ValidationOptions<NumberMaxContext> & {
+        exclusive?: boolean;
+    }))[];
+}, readonly ["number"], "validator", "standard">;

package/dist/core/plugin/numberMin.d.ts

@@ -0,0 +1,49 @@
+import { ValidationOptions, MessageContext } from "./types";
+export interface NumberMinContext extends MessageContext {
+    min: number;
+    actual: number;
+    exclusive: boolean;
+}
+/**
+ * @luq-plugin
+ * @name numberMin
+ * @category standard
+ * @description Validates that a number is greater than or equal to the specified minimum value
+ * @allowedTypes ["number"]
+ * @example
+ * ```typescript
+ * // Basic usage - set minimum allowed value
+ * const validator = Builder()
+ *   .use(numberMinPlugin)
+ *   .for<OrderForm>()
+ *   .v("age", (b) => b.number.min(18))
+ *   .v("quantity", (b) => b.number.min(1))
+ *   .v("price", (b) => b.number.min(0.01))
+ *   .build();
+ *
+ * // Combined with max for range validation
+ * builder.v("percentage", b => b.number.min(0).max(100))
+ * ```
+ * @params
+ * - min: number - Minimum allowed value (inclusive)
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if number is greater than or equal to minimum
+ * @customError
+ * ```typescript
+ * .min(18, {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must be at least ${params.min} (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const numberMinPlugin: import("../..").TypedPlugin<"numberMin", "min", (minValue: number, options?: ValidationOptions<NumberMinContext> & {
+    exclusive?: boolean;
+}) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (number | (ValidationOptions<NumberMinContext> & {
+        exclusive?: boolean;
+    }))[];
+}, readonly ["number"], "validator", "standard">;

package/dist/core/plugin/numberMultipleOf.d.ts

@@ -0,0 +1,42 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name numberMultipleOf
+ * @category standard
+ * @description Validates that a number is a multiple of a specified divisor
+ * @allowedTypes ["number"]
+ * @example
+ * ```typescript
+ * // Basic usage - ensures number is a multiple of divisor
+ * const validator = Builder()
+ *   .use(numberMultipleOfPlugin)
+ *   .for<PricingData>()
+ *   .v("quantity", (b) => b.number.multipleOf(5))
+ *   .v("price", (b) => b.number.required().multipleOf(0.25))
+ *   .build();
+ *
+ * // For time intervals (minutes)
+ * builder.v("duration", b => b.number.multipleOf(15).min(0).max(240))
+ *
+ * // For currency with cents
+ * builder.v("amount", b => b.number.multipleOf(0.01).positive())
+ * ```
+ * @params
+ * - divisor: number - The number that the value must be divisible by
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if number is a multiple of divisor
+ * @customError
+ * ```typescript
+ * .multipleOf(0.25, {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must be in increments of ${params.divisor} (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const numberMultipleOfPlugin: import("../..").TypedPlugin<"numberMultipleOf", "multipleOf", (divisor: number, options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (number | ValidationOptions<{}>)[];
+}, readonly ["number"], "validator", "standard">;

package/dist/core/plugin/numberNegative.d.ts

@@ -0,0 +1,41 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name numberNegative
+ * @category standard
+ * @description Validates that a number is strictly negative (less than zero)
+ * @allowedTypes ["number"]
+ * @example
+ * ```typescript
+ * // Basic usage - ensures number is negative (< 0)
+ * const validator = Builder()
+ *   .use(numberNegativePlugin)
+ *   .for<TemperatureData>()
+ *   .v("temperature", (b) => b.number.negative())
+ *   .v("debt", (b) => b.number.required().negative())
+ *   .build();
+ *
+ * // For temperature below freezing
+ * builder.v("celsius", b => b.number.negative().max(-1))
+ *
+ * // For negative offsets or adjustments
+ * builder.v("adjustment", b => b.number.negative().integer())
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if number is less than zero
+ * @customError
+ * ```typescript
+ * .negative({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be negative (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const numberNegativePlugin: import("../..").TypedPlugin<"numberNegative", "negative", (options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: ValidationOptions<{}>[];
+}, readonly ["number"], "validator", "standard">;

package/dist/core/plugin/numberPositive.d.ts

@@ -0,0 +1,41 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name numberPositive
+ * @category standard
+ * @description Validates that a number is strictly positive (greater than zero)
+ * @allowedTypes ["number"]
+ * @example
+ * ```typescript
+ * // Basic usage - ensures number is positive (> 0)
+ * const validator = Builder()
+ *   .use(numberPositivePlugin)
+ *   .for<PricingData>()
+ *   .v("price", (b) => b.number.positive())
+ *   .v("quantity", (b) => b.number.required().positive())
+ *   .build();
+ *
+ * // For monetary values
+ * builder.v("payment", b => b.number.positive().multipleOf(0.01))
+ *
+ * // For counts and quantities
+ * builder.v("itemCount", b => b.number.positive().integer())
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if number is greater than zero
+ * @customError
+ * ```typescript
+ * .positive({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be positive (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const numberPositivePlugin: import("../..").TypedPlugin<"numberPositive", "positive", (options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: ValidationOptions<{}>[];
+}, readonly ["number"], "validator", "standard">;

package/dist/core/plugin/numberRange.d.ts

@@ -0,0 +1,48 @@
+import { ValidationOptions, MessageContext } from "./types";
+export interface NumberRangeContext extends MessageContext {
+    min: number;
+    max: number;
+    actual: number;
+}
+/**
+ * @luq-plugin
+ * @name numberRange
+ * @category standard
+ * @description Validates that a number is within a specified range (inclusive)
+ * @allowedTypes ["number"]
+ * @example
+ * ```typescript
+ * // Basic usage - ensures number is within range
+ * const validator = Builder()
+ *   .use(numberRangePlugin)
+ *   .for<FormData>()
+ *   .v("age", (b) => b.number.range(18, 65))
+ *   .v("percentage", (b) => b.number.required().range(0, 100))
+ *   .build();
+ *
+ * // For ratings
+ * builder.v("rating", b => b.number.range(1, 5).integer())
+ *
+ * // For temperature ranges
+ * builder.v("celsius", b => b.number.range(-273.15, 100))
+ * ```
+ * @params
+ * - min: number - Minimum value (inclusive)
+ * - max: number - Maximum value (inclusive)
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if number is within range
+ * @customError
+ * ```typescript
+ * .range(0, 100, {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must be between ${params.min} and ${params.max} (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const numberRangePlugin: import("../..").TypedPlugin<"numberRange", "range", (min: number, max: number, options?: ValidationOptions<NumberRangeContext>) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (number | ValidationOptions<NumberRangeContext>)[];
+}, readonly ["number"], "validator", "standard">;

package/dist/core/plugin/object.d.ts

@@ -0,0 +1,43 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name object
+ * @category standard
+ * @description Validates that a value is a plain object (not null, array, or other types)
+ * @allowedTypes ["object"]
+ * @example
+ * ```typescript
+ * // Basic usage - validates that value is an object
+ * const validator = Builder()
+ *   .use(objectPlugin)
+ *   .for<FormData>()
+ *   .v("settings", (b) => b.object.object())
+ *   .v("config", (b) => b.object.required().object())
+ *   .build();
+ *
+ * // For nested object validation
+ * builder.v("data", b => b.object.object())
+ *   .v("data.name", b => b.string.required())
+ *   .v("data.age", b => b.number.min(0))
+ *
+ * // Combined with required for mandatory objects
+ * builder.v("user", b => b.object.required().object())
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if value is a plain object
+ * @customError
+ * ```typescript
+ * .object({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be an object (received: ${typeof value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const objectPlugin: import("../..").TypedPlugin<"object", "object", (options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: ValidationOptions<{}>[];
+}, readonly ["object"], "validator", "standard">;

package/dist/core/plugin/objectAdditionalProperties.d.ts

@@ -0,0 +1,51 @@
+import { ValidationOptions } from "./types";
+import type { JSONSchema7 } from "json-schema";
+interface AdditionalPropertiesOptions extends ValidationOptions {
+    allowedProperties?: string[];
+    additionalPropertiesSchema?: JSONSchema7;
+    strict?: boolean;
+}
+/**
+ * @luq-plugin
+ * @name objectAdditionalProperties
+ * @category standard
+ * @description Validates additional properties in objects according to JSON Schema additionalProperties rules
+ * @allowedTypes ["object"]
+ * @example
+ * ```typescript
+ * // Strict mode - no additional properties allowed
+ * const validator = Builder()
+ *   .use(objectAdditionalPropertiesPlugin)
+ *   .for<UserData>()
+ *   .v("user", (b) => b.object.additionalProperties(false, {
+ *     allowedProperties: ["name", "age", "email"]
+ *   }))
+ *   .build();
+ *
+ * // With schema validation for additional properties
+ * builder.v("config", b => b.object.additionalProperties({
+ *   type: "string",
+ *   minLength: 1
+ * }))
+ * ```
+ * @params
+ * - allowed: boolean | JSONSchema7 - Whether additional properties are allowed or schema for validation
+ * - options?: AdditionalPropertiesOptions - Configuration including allowed property names
+ * @returns Validation function that validates additional properties according to rules
+ * @customError
+ * ```typescript
+ * .additionalProperties(false, {
+ *   allowedProperties: ["name", "age"],
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} has unexpected properties: ${Object.keys(value).filter(k => !allowedProps.includes(k)).join(", ")}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const objectAdditionalPropertiesPlugin: import("../..").TypedPlugin<"objectAdditionalProperties", "additionalProperties", (allowed: boolean | JSONSchema7, options?: AdditionalPropertiesOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (boolean | JSONSchema7 | AdditionalPropertiesOptions)[];
+}, readonly ["object"], "validator", "standard">;
+export {};

package/dist/core/plugin/objectDependentRequired.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @luq-plugin
+ * @name objectDependentRequired
+ * @category object
+ * @description Validates that when certain properties exist, other properties become required
+ * @allowedTypes ["object"]
+ * @example
+ * ```typescript
+ * // Dependent required fields
+ * const validator = Builder()
+ *   .use(objectDependentRequiredPlugin)
+ *   .for<{ name?: string; first?: string; last?: string; }>()
+ *   .v("", (b) => b.object.dependentRequired({
+ *     name: ["first", "last"],
+ *     credit_card: ["billing_address"]
+ *   }))
+ *   .build();
+ *
+ * // With custom error messages
+ * builder.v("", b => b.object.dependentRequired({
+ *   email: {
+ *     required: ["email_verified"],
+ *     message: "When email is provided, email_verified is required"
+ *   }
+ * }))
+ * ```
+ * @params
+ * - dependencies: Record<string, string[] | DependentRequiredSchema> - Property dependencies mapping
+ * @returns Validation function that checks dependent required fields
+ * @since 0.1.0-alpha
+ */
+export interface DependentRequiredSchema {
+    required: string[];
+    message?: string;
+}
+export type DependentRequiredMapping = Record<string, string[] | DependentRequiredSchema>;
+export declare const objectDependentRequiredPlugin: import("../..").TypedPlugin<"objectDependentRequired", "dependentRequired", (dependencies: DependentRequiredMapping) => {
+    check: (value: any, allValues?: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string, allValues?: any) => string;
+    params: DependentRequiredMapping[];
+}, readonly ["object"], "validator", "standard">;

package/dist/core/plugin/objectDependentSchemas.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @luq-plugin
+ * @name objectDependentSchemas
+ * @category object
+ * @description Validates object with dependent schemas that apply when certain properties exist
+ * @allowedTypes ["object"]
+ * @example
+ * ```typescript
+ * // Dependent schemas validation
+ * const validator = Builder()
+ *   .use(objectDependentSchemasPlugin)
+ *   .for<{ creditCard?: string; billingAddress?: string; zipCode?: string; }>()
+ *   .v("", (b) => b.object.dependentSchemas({
+ *     creditCard: {
+ *       properties: {
+ *         billingAddress: { type: "string", minLength: 10 },
+ *         zipCode: { type: "string", pattern: "^[0-9]{5}$" }
+ *       },
+ *       required: ["billingAddress", "zipCode"]
+ *     }
+ *   }))
+ *   .build();
+ * ```
+ * @params
+ * - schemas: Record<string, JSONSchema7 | SchemaValidator> - Property to schema mapping
+ * @returns Validation function that applies schemas when trigger properties exist
+ * @since 0.1.0-alpha
+ */
+import type { JSONSchema7 } from "json-schema";
+export interface SchemaValidator {
+    validator: (value: any) => boolean;
+    message?: string;
+}
+export type DependentSchemasMapping = Record<string, JSONSchema7 | SchemaValidator>;
+export declare const objectDependentSchemasPlugin: import("../..").TypedPlugin<"objectDependentSchemas", "dependentSchemas", (schemas: DependentSchemasMapping) => {
+    check: (value: any, allValues?: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string, allValues?: any) => string;
+    params: DependentSchemasMapping[];
+}, readonly ["object"], "validator", "standard">;

package/dist/core/plugin/objectMaxProperties.d.ts

@@ -0,0 +1,42 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name objectMaxProperties
+ * @category standard
+ * @description Validates that an object has at most the specified maximum number of properties
+ * @allowedTypes ["object"]
+ * @example
+ * ```typescript
+ * // Basic usage - ensure object doesn't exceed maximum properties
+ * const validator = Builder()
+ *   .use(objectMaxPropertiesPlugin)
+ *   .for<ConfigObject>()
+ *   .v("metadata", (b) => b.object.maxProperties(5))
+ *   .v("settings", (b) => b.object.maxProperties(10))
+ *   .build();
+ *
+ * // With custom error message
+ * builder.v("config", b => b.object.maxProperties(3, {
+ *   messageFactory: ({ path, params }) =>
+ *     `${path} can have at most ${params.max} properties`
+ * }))
+ * ```
+ * @params
+ * - max: number - Maximum number of properties allowed
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if object has at most maximum properties
+ * @customError
+ * ```typescript
+ * .maxProperties(3, {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} can have at most ${params.max} properties (has ${Object.keys(value).length})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const objectMaxPropertiesPlugin: import("../..").TypedPlugin<"objectMaxProperties", "maxProperties", (maxValue: number, options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (number | ValidationOptions<{}>)[];
+}, readonly ["object"], "validator", "standard">;

package/dist/core/plugin/objectMinProperties.d.ts

@@ -0,0 +1,42 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name objectMinProperties
+ * @category standard
+ * @description Validates that an object has at least the specified minimum number of properties
+ * @allowedTypes ["object"]
+ * @example
+ * ```typescript
+ * // Basic usage - ensure object has minimum properties
+ * const validator = Builder()
+ *   .use(objectMinPropertiesPlugin)
+ *   .for<ConfigObject>()
+ *   .v("metadata", (b) => b.object.minProperties(2))
+ *   .v("settings", (b) => b.object.minProperties(1))
+ *   .build();
+ *
+ * // With custom error message
+ * builder.v("config", b => b.object.minProperties(3, {
+ *   messageFactory: ({ path, params }) =>
+ *     `${path} must have at least ${params.min} properties`
+ * }))
+ * ```
+ * @params
+ * - min: number - Minimum number of properties required
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if object has at least minimum properties
+ * @customError
+ * ```typescript
+ * .minProperties(3, {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} requires at least ${params.min} properties (has ${Object.keys(value).length})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const objectMinPropertiesPlugin: import("../..").TypedPlugin<"objectMinProperties", "minProperties", (minValue: number, options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (number | ValidationOptions<{}>)[];
+}, readonly ["object"], "validator", "standard">;

package/dist/core/plugin/objectPatternProperties.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @luq-plugin
+ * @name objectPatternProperties
+ * @category object
+ * @description Validates object properties that match specific patterns with corresponding schemas
+ * @allowedTypes ["object"]
+ * @example
+ * ```typescript
+ * // Pattern-based property validation
+ * const validator = Builder()
+ *   .use(objectPatternPropertiesPlugin)
+ *   .for<{ [key: string]: any }>()
+ *   .v("config", (b) => b.object.patternProperties({
+ *     "^str_": (value) => typeof value === "string",
+ *     "^num_": (value) => typeof value === "number"
+ *   }))
+ *   .build();
+ *
+ * // With custom validators and messages
+ * builder.v("data", b => b.object.patternProperties({
+ *   "^email_": {
+ *     validator: (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value),
+ *     message: "Email properties must be valid email addresses"
+ *   },
+ *   "^id_": {
+ *     validator: (value) => typeof value === "string" && value.length > 0,
+ *     message: "ID properties must be non-empty strings"
+ *   }
+ * }))
+ * ```
+ * @params
+ * - patterns: Record<string, (value: any) => boolean | PatternValidator> - Pattern to validator mapping
+ * @returns Validation function that checks properties matching patterns
+ * @since 0.1.0-alpha
+ */
+export interface PatternValidator {
+    validator: (value: any) => boolean;
+    message?: string;
+}
+export type PatternPropertiesSchema = Record<string, ((value: any) => boolean) | PatternValidator>;
+export declare const objectPatternPropertiesPlugin: import("../..").TypedPlugin<"objectPatternProperties", "patternProperties", (patterns: PatternPropertiesSchema) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: PatternPropertiesSchema[];
+}, readonly ["object"], "validator", "standard">;

package/dist/core/plugin/objectPropertyNames.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @luq-plugin
+ * @name objectPropertyNames
+ * @category object
+ * @description Validates that all property names in an object match a specified pattern or schema
+ * @allowedTypes ["object"]
+ * @example
+ * ```typescript
+ * // Property names must match pattern
+ * const validator = Builder()
+ *   .use(objectPropertyNamesPlugin)
+ *   .for<{ [key: string]: any }>()
+ *   .v("config", (b) => b.object.propertyNames(/^[a-zA-Z_][a-zA-Z0-9_]*$/))
+ *   .build();
+ *
+ * // Property names with custom validator
+ * builder.v("data", b => b.object.propertyNames({
+ *   validator: (name) => name.length >= 3 && !name.startsWith('_'),
+ *   message: "Property names must be at least 3 characters and not start with underscore"
+ * }))
+ * ```
+ * @params
+ * - schema: RegExp | string | { validator: (name: string) => boolean, message?: string } - Pattern or validation schema for property names
+ * @returns Validation function that checks all property names
+ * @since 0.1.0-alpha
+ */
+export interface PropertyNamesSchema {
+    validator: (name: string) => boolean;
+    message?: string;
+}
+export declare const objectPropertyNamesPlugin: import("../..").TypedPlugin<"objectPropertyNames", "propertyNames", (schema: RegExp | string | PropertyNamesSchema) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (string | RegExp | PropertyNamesSchema)[];
+}, readonly ["object"], "validator", "standard">;