import { z } from 'zod';
import RTValueTypeBase from './value-type.js';
import type RepoTherapy from './repo-therapy.js';
import type { Options } from './value-type.js';
import type { ObjectDefinition } from './types.js';
export type StringMeta = {
    default?: string;
    optional?: boolean;
    minLength?: number;
    maxLength?: number;
    exactLength?: number;
    oneOf?: string[];
};
export declare class RTValueTypeString<Metadata extends Record<string, unknown> = {}, CustomOptions extends object = {}, Self extends RTValueTypeString<Metadata, CustomOptions, Self, keyof Self> = RTValueTypeString<Metadata, CustomOptions, any, any>, ForceReturn extends keyof Self = keyof Self> extends RTValueTypeBase<string, StringMeta & Metadata, CustomOptions, Self, ForceReturn> {
    protected _baseType: 'string';
    protected _type: string;
    protected _unstrict: StringConstructor;
    constructor(repoTherapy: RepoTherapy, description: string, options?: CustomOptions & Partial<Options<string, StringMeta & Metadata, CustomOptions, Self>>);
    protected _minLength(minLength: number): void;
    protected _maxLength(maxLength: number): void;
    protected _exactLength(): void;
    protected _init(): z.ZodString;
}
export type NumberMeta = {
    default?: number;
    optional?: boolean;
    decimals?: number;
    sign?: 'positive' | 'negative' | 'non-positive' | 'non-negative';
    min?: number;
    max?: number;
    oneOf?: number[];
};
export declare class RTValueTypeNumber<Metadata extends Record<string, unknown> = {}, CustomOptions extends object = {}, Self extends RTValueTypeNumber<Metadata, CustomOptions, Self, keyof Self> = RTValueTypeNumber<Metadata, CustomOptions, any, any>, ForceReturn extends keyof Self = keyof Self> extends RTValueTypeBase<number, NumberMeta & Metadata, CustomOptions, Self, ForceReturn> {
    protected _baseType: 'number';
    protected _type: string;
    protected _unstrict(value: unknown): number;
    constructor(repoTherapy: RepoTherapy, description: string, options?: CustomOptions & Partial<Options<number, NumberMeta & Metadata, CustomOptions, Self>>);
    integer(): void;
    float(decimals?: number): void;
    _init(): z.ZodNumber;
}
export type BooleanMeta = {
    default?: boolean;
    optional?: boolean;
};
export declare class RTValueTypeBoolean<Metadata extends Record<string, unknown> = {}, CustomOptions extends object = {}, Self extends RTValueTypeBoolean<Metadata, CustomOptions, Self, keyof Self> = RTValueTypeBoolean<Metadata, CustomOptions, any, any>, ForceReturn extends keyof Self = keyof Self> extends RTValueTypeBase<boolean, BooleanMeta & Metadata, CustomOptions, Self, ForceReturn> {
    protected _baseType: 'boolean';
    protected _type: string;
    constructor(repoTherapy: RepoTherapy, description: string, options?: CustomOptions & Partial<Options<boolean, BooleanMeta & Metadata, CustomOptions, Self>>);
    protected _unstrict(value: unknown): boolean;
    protected _init(): z.ZodBoolean;
}
type ArrrayItem<T> = ReturnType<RTValueTypeBase<T>['chainable']>;
export type ArrayMeta<T = unknown> = {
    default?: T[];
    optional?: boolean;
    minLength?: number;
    maxLength?: number;
    exactLength?: number;
    unique?: boolean;
};
export declare class RTValueTypeArray<T = unknown, Metadata extends Record<string, unknown> = {}, CustomOptions extends object = {}, Self extends RTValueTypeArray<T, Metadata, CustomOptions, Self, keyof Self> = RTValueTypeArray<T, Metadata, CustomOptions, any, any>, ForceReturn extends keyof Self = keyof Self> extends RTValueTypeBase<T[], ArrayMeta<T> & Metadata, CustomOptions, Self, ForceReturn> {
    protected _baseType: 'array';
    protected _type: string;
    static valueDefinition: string[];
    static isArray: boolean;
    get typeDefinitionStr(): string;
    private _item;
    constructor(repoTherapy: RepoTherapy, description: string, item: ArrrayItem<T>, options?: CustomOptions & Partial<Options<T[], ArrayMeta<T> & Metadata, CustomOptions, Self>>);
    getItem(): ArrrayItem<T>;
    mock(useDefault?: boolean): T[] | undefined;
    protected _unstrict(value: unknown): T[];
    protected _minLength(minLength: number): void;
    protected _maxLength(maxLength: number): void;
    protected _exactLength(): void;
    protected _init(): z.ZodTransform<T[], T[]>;
}
export type ObjectMeta = {
    soft?: boolean;
    optional?: boolean;
    keyMap?: (value: string[]) => string[];
    keyRevert?: (value: string[]) => string[];
};
export declare class RTValueTypeObject<T extends object = object, Metadata extends Record<string, unknown> = {}, CustomOptions extends object = {}, Self extends RTValueTypeObject<T, Metadata, CustomOptions, Self, keyof Self> = RTValueTypeObject<T, Metadata, CustomOptions, any, any>, ForceReturn extends keyof Self = keyof Self> extends RTValueTypeBase<T, ObjectMeta & Metadata, CustomOptions, Self, ForceReturn> {
    protected _baseType: 'object';
    protected _type: string;
    static valueDefinition: string[];
    get typeDefinitionStr(): string;
    private _items;
    constructor(repoTherapy: RepoTherapy, description: string, items: ObjectDefinition<T>, options?: CustomOptions & Partial<Options<T, ObjectMeta & Metadata, CustomOptions, Self>>);
    getItems(): ObjectDefinition<T>;
    existingKeys(data: object): (keyof T & string)[];
    mock(useDefault: boolean): T;
    protected _unstrict(value: unknown): T;
    private _recursiveLoopToValue;
    private _restructure;
    protected _init(): z.ZodTransform<Awaited<T>, T>;
}
export type PatternMeta = {
    optional?: boolean;
};
export declare class RTValueTypePattern<Metadata extends Record<string, unknown> = {}, CustomOptions extends object = {}, Self extends RTValueTypePattern<Metadata, CustomOptions, Self, keyof Self> = RTValueTypePattern<Metadata, CustomOptions, any, any>, ForceReturn extends keyof Self = keyof Self> extends RTValueTypeBase<string, PatternMeta & Metadata, CustomOptions, Self, ForceReturn> {
    protected readonly _pattern: RegExp;
    protected readonly _patternName: string;
    protected _baseType: 'string';
    protected _unstrict: StringConstructor;
    protected get _type(): string;
    constructor(repoTherapy: RepoTherapy, name: string, description: string, pattern: RegExp, options?: CustomOptions & Partial<Options<string, PatternMeta & Metadata, CustomOptions, Self>>);
    protected _init(): z.ZodString;
    static define(regexp: Record<string, {
        description: string;
        pattern: RegExp;
    } | RegExp>): () => {
        [k: string]: {
            description: string;
            pattern: RegExp;
        };
    };
}
export {};
//# sourceMappingURL=value-type-definitions.d.ts.map