import Joi from 'joi';
declare module 'joi' {
    type VE = import('joi').ValidationError;
    type VO = import('joi').ValidationOptions;
    type AVO = import('joi').AsyncValidationOptions;
    type SM<T> = import('joi').SchemaMap<T>;
    type OS<T> = import('joi').ObjectSchema<T>;
    type GenericValidationResult<T> = {
        error: VE;
        errors?: VE;
        warning?: VE;
        value: unknown;
    } | {
        error: undefined;
        errors?: VE;
        warning?: VE;
        value: T;
    };
    interface ObjectSchema<TSchema = any> {
        /**
         * Appends the allowed object keys. If schema is null, undefined, or {}, no changes will be applied.
         */
        append<TAppend = TSchema>(schema?: SM<TAppend>): OS<TSchema & TAppend>;
        /**
         * Sets or extends the allowed object keys.
         */
        keys<TAppend = TSchema>(schema?: SM<TAppend>): OS<TSchema & TAppend>;
        /**
         * Validates a value using the schema and options.
         */
        validate(value: unknown, options?: VO): GenericValidationResult<TSchema>;
        /**
         * Validates a value using the schema and options.
         */
        validateAsync(value: unknown, options?: AVO): Promise<TSchema>;
    }
}
export declare type DeepPartial<T> = {
    [P in keyof T]?: DeepPartial<T[P]>;
};
export declare type ExtractValues<T> = T extends ReadonlyArray<infer U> ? U : never;
export declare type AllExcept<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
export declare type SchemaOf<T> = Record<keyof T, Joi.AnySchema | Joi.AnySchema[]>;
export declare function objectSchemaOf<T>(map: SchemaOf<T>): Joi.ObjectSchema<T>;
export declare type StrictSchemaMap<T = {}> = {
    [K in keyof T]: Joi.AnySchema | Joi.AnySchema[];
};
export declare const isObjectSchema: <T = {}>(schema: Joi.AnySchema) => schema is Joi.ObjectSchema<T>;
export declare const isNumberSchema: (schema: Joi.AnySchema) => schema is Joi.NumberSchema;
export declare const makeAllNumbersUnsafe: <T>(input: StrictSchemaMap<T>) => StrictSchemaMap<T>;
export declare const makeAllOptional: <T>(input: StrictSchemaMap<T>) => StrictSchemaMap<T>;
export declare type OptionalKeysOf<T> = Exclude<{
    [K in keyof T]: T extends Record<K, T[K]> ? never : K;
}[keyof T], undefined>;
export declare const makeAllRequired: <T>(input: StrictSchemaMap<T>, excluding?: Exclude<{ [K in keyof T]: T extends Record<K, T[K]> ? never : K; }[keyof T], undefined>[] | undefined) => StrictSchemaMap<T>;
export declare function literalAs<T>(value: T): T;
export { Joi };