import { type ZodType } from 'zod';
import { RepoTherapyUtilBase } from './base.js';
import type RepoTherapy from './repo-therapy.js';
import type { ValueTypeDefinition } from '../generated/types/value-types.js';
export type BaseMeta = {
    nullable: boolean;
    strict: boolean;
};
type ChainableProps<Metadata extends Record<string, unknown> = {}, Self extends RTValueTypeBase<unknown, any, any, any> = RTValueTypeBase<unknown, any, any, any>, ForceReturn extends keyof Self = keyof Self> = {
    [K in keyof Required<Metadata & BaseMeta>]: K extends 'default' ? (x: (Metadata & BaseMeta)[K]) => Chainable<Metadata, Self> : Required<(Metadata & BaseMeta)>[K] extends boolean ? () => Chainable<Metadata, Self> : (x: (Metadata & BaseMeta)[K]) => Chainable<Metadata, Self>;
} & {
    [K in Exclude<{
        [K in keyof Self]: K extends `_${string}` ? never : K;
    }[keyof Self], 'parse' | 'chainable' | 'init' | 'typeDefinitionStr' | 'mock' | 'extend'>]: Self[K] extends infer A extends (...args: any[]) => unknown | unknown[] ? (...args: Parameters<A>) => K extends ForceReturn ? ReturnType<A> : Chainable<Metadata, Self> : never;
};
type Chainable<Metadata extends Record<string, unknown> = {}, Self extends RTValueTypeBase<unknown, any, any, any> = RTValueTypeBase<unknown, any, any, any>, ForceReturn extends keyof Self = keyof Self> = ((v: unknown) => ReturnType<Self['parse']>) & ChainableProps<Metadata, Self, ForceReturn> & {
    typeDefinition: () => string;
    metadata: () => Metadata & {
        baseType: string;
        description: string;
    };
    mock: (useDefault?: boolean) => ReturnType<Self['mock']>;
    extend: <NewMeta extends Record<string, unknown>>(metadata: NewMeta) => Chainable<Metadata & NewMeta, Self, ForceReturn>;
};
export type Options<T extends unknown, Metadata extends Record<string, unknown> = {}, CustomOptions extends object = {}, Self extends RTValueTypeBase<T, Metadata, CustomOptions, Self, keyof Self> = RTValueTypeBase<T, Metadata, CustomOptions, any, any>> = {
    metadata: Metadata;
    forceReturn?: (keyof Self & string)[];
};
type BaseType = 'string' | 'number' | 'boolean' | 'object' | 'array';
type PrimitiveType<T extends string> = T extends BaseType ? T : T extends `${infer Inner}[]` ? PrimitiveType<Inner> extends never ? never : T : never;
export default abstract class RTValueTypeBase<T extends unknown, Metadata extends Record<string, unknown> = {}, CustomOptions extends object = {}, Self extends RTValueTypeBase<T, Metadata, CustomOptions, Self, keyof Self> = RTValueTypeBase<T, Metadata, CustomOptions, any, any>, ForceReturn extends keyof Self = keyof Self> extends RepoTherapyUtilBase<Options<T, Metadata, CustomOptions, Self> & CustomOptions, Self> {
    protected abstract _baseType: PrimitiveType<BaseType>;
    protected abstract _type: string;
    get typeDefinitionStr(): string;
    static valueDefinition: string[];
    protected readonly _description: string;
    protected _schema: ZodType<T | undefined>;
    protected abstract _init(): ZodType<T>;
    protected abstract _unstrict(value: unknown): T;
    constructor(repoTherapy: RepoTherapy, description: string, options?: Partial<CustomOptions & Options<T, Metadata, CustomOptions, Self>>);
    protected _preParse(value: unknown): unknown;
    protected _postParse(value: T): T;
    private _bindMetaSetter;
    _lock(): void;
    extend<NewMeta extends Record<string, unknown>>(metadata: NewMeta): this;
    protected _getDefault(): T;
    mock(useDefault?: boolean): T | undefined;
    parse(value: unknown): T;
    chainable(): Chainable<Metadata, Self, ForceReturn>;
}
export declare class RTValueType {
    static loader(repoTherapy: RepoTherapy): Promise<ValueTypeDefinition>;
    static generateTypeDefinition(repoTherapy: RepoTherapy): Promise<void>;
}
export {};
//# sourceMappingURL=value-type.d.ts.map