export declare var nil: any;
declare global {
    interface Window {
        nil: any;
    }
}
export type RecursiveRequired<T> = Required<{
    [P in keyof T]: T[P] extends object | undefined ? RecursiveRequired<Required<T[P]>> : T[P];
}>;
export declare function wrapInNil<T>(object?: T): Required<T>;
export declare const YES = true;
export declare const NO = false;
export declare function IS<T>(object: T | undefined | null | false): object is T;
export declare function IS_NOT(object: any): object is undefined | null | false;
export declare function IS_DEFINED<T>(object: T | undefined): object is T;
export declare function IS_UNDEFINED(object: any): object is undefined;
export declare function IS_NIL(object: any): object is typeof nil;
export declare function IS_NOT_NIL<T>(object: T | undefined | null): object is T | undefined | null;
export declare function IS_LIKE_NULL(object: any): object is undefined | null;
export declare function IS_NOT_LIKE_NULL<T>(object: T | null | undefined): object is T;
export declare function IS_AN_EMAIL_ADDRESS(email: string): boolean;
export declare function FIRST_OR_NIL<T>(...objects: (T | undefined | null)[]): T;
export declare function FIRST<T>(...objects: (T | undefined | null)[]): T;
export declare function MAKE_ID(randomPartLength?: number): string;
export declare function RETURNER<T>(value?: T): (..._objects: any[]) => T | undefined;
export type UIIFBlockReceiver<T> = (functionToCall: () => any) => UIIFEvaluator<T>;
export type UIIFEvaluatorBase<T> = () => T;
export interface UIIFEvaluator<T> extends UIIFEvaluatorBase<T> {
    ELSE_IF: (otherValue: any) => UIIFBlockReceiver<T>;
    ELSE: (functionToCall: () => any) => T;
}
export declare function IF<T = any>(value: any): UIIFBlockReceiver<T>;
export declare class UIFunctionCall<T extends (...args: any) => any> {
    isAUIFunctionCallObject: boolean;
    parameters: Parameters<T>[];
    constructor(...parameters: Parameters<T>);
    callFunction(functionToCall: T): void;
}
export declare function CALL<T extends (...args: any) => any>(...objects: Parameters<T>): UIFunctionCall<T>;
export declare class UIFunctionExtender<T extends (...args: any) => any> {
    isAUIFunctionExtenderObject: boolean;
    extendingFunction: T;
    static functionByExtendingFunction<T extends (...args: any) => any>(functionToExtend: T, extendingFunction: T): T & {
        extendedFunction: T;
    };
    constructor(extendingFunction: T);
    extendedFunction(functionToExtend: T): T & {
        extendedFunction: T;
    };
}
export declare function EXTEND<T extends (...args: any) => any>(extendingFunction: T): UIFunctionExtender<T>;
export declare class UILazyPropertyValue<T> {
    isAUILazyPropertyValueObject: boolean;
    initFunction: () => T;
    constructor(initFunction: () => T);
    setLazyPropertyValue(key: string, target: object): void;
}
export declare function LAZY_VALUE<T>(initFunction: () => T): UILazyPropertyValue<T>;
type NativeGlobal = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Error;
export type UIInitializerValue<T> = T extends (Function | ((...args: any) => any)) ? UIFunctionCall<T> | UIFunctionCall<T>[] | UIFunctionExtender<T> | T : T extends any[] ? T : T extends NativeGlobal ? T : T extends object ? UIInitializerObject<T> | T : T;
export type UIInitializerObject<T> = {
    [P in keyof T]?: UIInitializerValue<T[P]>;
};
export interface Configurable {
    configureWithObject<K extends keyof this>(object: {
        [P in K]?: UIInitializerValue<this[P]>;
    }): void;
    configuredWithObject<K extends keyof this>(object: {
        [P in K]?: UIInitializerValue<this[P]>;
    }): this;
}
export declare class UIObject implements Configurable {
    constructor();
    get class(): any;
    get superclass(): any;
    isKindOfClass(classObject: any): boolean;
    isMemberOfClass(classObject: any): boolean;
    static annotationsMap: WeakMap<any, Function[]>;
    static recordAnnotation(annotation: Function, target: Function): void;
    static classHasAnnotation(classObject: Function, annotation: Function): boolean | undefined;
    static annotationsOnClass(classObject: Function): Function[];
    static wrapObject<T>(object: T): UIObject & T;
    valueForKey(key: string): any;
    valueForKeyPath<T = any>(keyPath: string, defaultValue?: T): T | undefined;
    static valueForKeyPath<T = any>(keyPath: string, object: any, defaultValue?: T): T | undefined;
    setValueForKeyPath(keyPath: string, value: any, createPath?: boolean): boolean;
    static setValueForKeyPath(keyPath: string, value: any, currentObject: any, createPath: boolean): boolean;
    configureWithObject<K extends keyof this>(object: {
        [P in K]?: UIInitializerValue<this[P]>;
    }): { [P in K]?: UIInitializerValue<this[P]> | undefined; };
    configuredWithObject<K extends keyof this>(object: {
        [P in K]?: UIInitializerValue<this[P]>;
    }): this;
    static configureWithObject<TargetType extends object, ConfigKeys extends keyof TargetType>(configurationTarget: TargetType, object: {
        [P in ConfigKeys]?: UIInitializerValue<TargetType[P]>;
    }): {
        [P in ConfigKeys]?: UIInitializerValue<TargetType[P]>;
    };
    static configuredWithObject<T extends object>(configurationTarget: T, object: UIInitializerObject<T>): T;
    get methods(): Record<string, Function>;
    get superProxy(): this & {
        superProxy: SuperProxy<this>;
    };
    performFunctionWithSelf<T>(functionToPerform: (self: this) => T): T;
    performingFunctionWithSelf(functionToPerform: (self: this) => void): this;
    performFunctionWithDelay(delay: number, functionToCall: Function): void;
}
type SuperProxy<T> = T & {
    superProxy: SuperProxy<T>;
};
export type MethodsOnly<T> = Pick<T, {
    [K in keyof T]: T[K] extends Function ? K : never;
}[keyof T]>;
export type ValueOf<T> = T[keyof T];
export {};