@maroonedog/luq 0.1.2-alpha → 2.1.0

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

@@ -1,41 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,42 +0,0 @@
-/**
- * @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

@@ -1,40 +0,0 @@
-/**
- * @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

@@ -1,42 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,46 +0,0 @@
-/**
- * @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

@@ -1,36 +0,0 @@
-/**
- * @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">;