import { Schema, ObjectSchema } from "joi";
import * as joi from "joi";
export declare const WORKING_SCHEMA_KEY = "tsdv:working-schema";
export declare const SCHEMA_KEY = "tsdv:schema";
export declare let Joi: typeof joi;
export declare function registerJoi(customJoi: typeof joi): void;
export declare class ConstraintDefinitionError extends Error {
    message: string;
    name: string;
    constructor(message: string);
}
export declare class ValidationSchemaNotFound extends ConstraintDefinitionError {
    name: string;
    constructor(propertyKey: string | Symbol);
}
export declare type WorkingSchema = {
    [index: string]: Schema;
};
export interface AnyClass {
    new (...args: any[]): any;
}
export declare type StringKey<T> = Extract<keyof T, string>;
export declare type StringOrSymbolKey<T> = Extract<keyof T, string | symbol>;
export declare type Nullable<T> = {
    [K in keyof T]: T[K] | null;
};
/**
 * If a given type extends the desired type, return the given type. Otherwise, return the desired type.
 * So, you can do stuff like this:
 *
 * ```typescript
 * interface Foo {
 *     bar: null;
 *     baz: number;
 *     boz: string;
 *     biz: string | null;
 * }
 *
 * const bars1: AllowUnions<Foo['baz'], number, Foo['baz']>[] = [
 *     'sdf', // Type 'string' is not assignable to type 'number'.
 *     null, // Type 'null' is not assignable to type 'number'.
 *     123
 * ];
 *
 * const bars2: AllowUnions<Foo['boz'], string, Foo['boz']>[] = [
 *     'sdf',
 *     null, // Type 'null' is not assignable to type 'string'.
 *     123 // Type 'number' is not assignable to type 'string'.
 * ];
 *
 * const bars3: AllowUnions<Foo['biz'], string, Foo['biz']>[] = [
 *     'sdf',
 *     null,
 *     123 // Type 'number' is not assignable to type 'string | null'.
 * ];
 * ```
 *
 * Notice that you pass the TOriginal type parameter, which is identical to the TType type parameter. This is because
 * the "extends" condition will narrow the type of TType to just TDesired. So, "string | null" will be narrowed to
 * "string", but we actually want to return the original "string | null".
 *
 * By returning the TDesired when there's no match, we get nice error messages that state what the desired type was.
 */
export declare type AllowUnions<TType, TDesired, TOriginal> = TType extends TDesired ? TOriginal : TDesired;
export declare type MapAllowUnions<TObject, TKey extends keyof TObject, TDesired> = {
    [K in TKey]: AllowUnions<TObject[K], TDesired, TObject[K]>;
};
export declare type TypedPropertyDecorator<TPropertyType> = <TClass extends MapAllowUnions<TClass, TKey, TPropertyType>, TKey extends StringOrSymbolKey<TClass>>(target: TClass, propertyKey: TKey) => void;
export declare function getWorkingSchema<TClass>(target: TClass): WorkingSchema;
export declare function getMergedWorkingSchemas(target: object): WorkingSchema;
export declare function getJoiSchema(clz: AnyClass): ObjectSchema;
export declare function getPropertySchema<TClass, TKey extends StringOrSymbolKey<TClass>>(target: TClass, propertyKey: TKey): Schema;
export declare function updateSchema<TClass, TKey extends StringOrSymbolKey<TClass>>(target: TClass, propertyKey: TKey, schema: Schema): void;
export declare function getAndUpdateSchema<TClass, TKey extends StringOrSymbolKey<TClass>>(target: TClass, propertyKey: TKey, updateFunction: (schema: Schema) => Schema): void;
export declare function constraintDecorator<TPropertyType>(updateFunction: (schema: Schema) => Schema): TypedPropertyDecorator<TPropertyType>;
export declare function constraintDecoratorWithPeers<TPropertyType, TClassForPeers>(peers: StringOrSymbolKey<TClassForPeers>[], updateFunction: (schema: Schema) => Schema): TypedPropertyDecorator<TPropertyType>;
export declare function typeConstraintDecorator<TPropertyType>(typeSchema: (Joi: typeof joi) => Schema): <TClass extends MapAllowUnions<TClass, TKey, TPropertyType>, TKey extends Extract<keyof TClass, string | symbol>>(target: TClass, propertyKey: TKey) => void;
export declare function verifyPeers<TClass>(target: TClass, peers: StringOrSymbolKey<TClass>[]): void;