import { Dispatch, SetStateAction } from 'react';

declare const Random: {
    EntryFrom: <T extends Record<string, unknown>>(obj: T) => T[keyof T];
    KeyFrom: <T_1 extends Record<string, unknown>>(obj: T_1) => keyof T_1;
    RGBObject: () => {
        r: number;
        g: number;
        b: number;
    };
    RGBString: () => `rgb(${number},${number},${number})`;
    NumberBetween: (pMin: number, pMax: number) => number;
};

declare const Log: {
    __proceed: boolean;
    verbose: boolean;
    JSON: (obj: object) => void;
    ObjectEntries: (obj: object) => void;
    ServerReq: (str: string[]) => void;
    EventListenerAdded: (str: string) => void;
    EventListenerRemoved: (str: string) => void;
    Attempt: (str: string) => void;
    Constructor: (str: string) => void;
    Linebreak: (str?: string) => void;
    Message: (str: string) => void;
    Success: (str: string) => void;
    Testing: (data: unknown) => void;
    Warning: (str: string) => void;
    WithCustomStyle: (str: string, css: string) => void;
    Click: (str: string) => void;
    Mounted: (str: string) => void;
    MouseEnter: (str: string) => void;
    MouseLeave: (str: string) => void;
    Render: (str: string) => void;
    StateChange: (data: unknown, whatChanged: string) => void;
    ThemeUpdate: (str: string) => void;
    Unmounted: (str: string) => void;
};

declare const MATH: {
    IsEven: (n: number) => boolean;
    IsOdd: (n: number) => boolean;
    RoundTo2DP: (num: number) => number;
};

type TEntries<T> = {
    [K in keyof T]: [K, T[K]];
}[keyof T][];

declare const OBJ: {
    ArrayContains: <T extends unknown[]>(needle: unknown, haystack: T) => boolean;
    Entries: <T_1 extends Record<string, unknown>>(obj: T_1) => TEntries<T_1>;
    HasKey: <T_2 extends Record<string, unknown>>(obj: T_2, key: PropertyKey) => key is keyof T_2;
    IsObject: <T_3 extends Record<string, unknown>>(obj: T_3) => boolean;
    IsEmpty: <T_4 extends Record<string, unknown>>(obj: T_4) => boolean;
    Keys: <T_5 extends Record<string, unknown>>(obj: T_5) => (keyof T_5)[];
};

type TSetState<TState> = Dispatch<SetStateAction<TState>>;

declare const MakeObservable: <_state, _setState extends TSetState<_state>>(targetData: _state) => {
    Get: () => _state;
    Set: (arg: _state) => void;
    Subscribe: (setState: _setState) => void;
};

declare const STR: {
    CapitaliseFirstLetter: (pStr: string) => string;
    CapitaliseWords: (str: string) => string;
    Rearrange: (pStr: string) => string;
    RemoveIndentation: (pStr: string) => string;
};

declare const ToggleFullScreen: () => void;
declare const SetFullScreen: (bool: boolean) => void;

declare const store: {
    Get: () => "PENDING" | "ACCEPTED" | "REJECTED";
    Set: (arg: "PENDING" | "ACCEPTED" | "REJECTED") => void;
    Subscribe: (setState: TSetState<"PENDING" | "ACCEPTED" | "REJECTED">) => void;
};
type TState$5 = ReturnType<typeof store.Get>;
interface IActions {
    AcceptCookies: () => void;
    RejectCookies: () => void;
}
type TUseCookies = () => {
    cookieStatus: TState$5;
    cookieActions: IActions;
};
declare const useCookies: TUseCookies;

declare const QUERIES: {
    xs: string;
    s: string;
    m: string;
    l: string;
    xl: string;
    xxl: string;
    desktop_S: string;
    desktop_M: string;
    desktop_L: string;
    portrait: string;
    landscape: string;
    mobile: string;
    motionReduced: string;
};
type TKeys = keyof typeof QUERIES;
type TState$4 = Record<TKeys, boolean>;
declare const useMediaQueries: () => {
    mediaQueries: TState$4;
};
declare const Media: (queriesToCombine: Array<keyof typeof QUERIES>) => string;

type TState$3 = boolean;
declare const useMediaQueryCustom: (queryString: string) => TState$3;

declare const initialState$1: {
    noOfUpdates: number;
    x: number;
    y: number;
    clientX: number;
    clientY: number;
    distanceFromCentreX: number;
    distanceFromCentreY: number;
};
type TState$2 = typeof initialState$1;
type TUseMousePosition = () => {
    mousePosition: TState$2;
};
declare const useMousePosition: TUseMousePosition;

declare const initialData: {
    noOfUpdates: number;
    isAbsolute: boolean;
    x: number;
    y: number;
    z: number;
};
type TState$1 = typeof initialData;
type TUseSensors = () => {
    sensors: TState$1;
};
declare const useSensors: TUseSensors;

declare const initialState: {
    height: number;
    width: number;
    centreX: number;
    centreY: number;
};
type TState = typeof initialState;
type TUseScreen = () => {
    screen: TState;
};
declare const useScreen: TUseScreen;

declare const palettes: {
    /**
     * Palettes Kat came up with
    */
    readonly kat: {
        readonly electricPurple: "rgb(191,0,255)";
        readonly green0: "rgb(89,238,89)";
        readonly orange0: "rgb(255,165,0)";
        readonly petrolBlue: "rgb(16,98,122)";
        readonly offWhite: "rgb(234,224,200)";
        readonly brownA: "#62481F";
        readonly mycorexRed: "rgb(255,0,0)";
        readonly transparent: "rgba(0,0,0,0)";
        readonly corkBrown: "#BB8A55";
        readonly ochre: "#bdb15f";
    };
    /**
     * Generated by Coloors extension that I like
    */
    readonly coloors: {
        readonly redRyb: "#ff3a20ff";
        readonly spaceCadet: "#2e294eff";
        readonly blanchedAlmond: "#ffebc6ff";
        readonly pewterBlue: "#7c9eb2ff";
        readonly glossyGrape: "#a288a6ff";
        readonly burgundy: "#800020";
    };
    /**
     * Original green variations from Matrix 1
    */
    readonly matrix: {
        readonly a: "rgb(13,2,8)";
        readonly b: "rgb(0,59,0)";
        readonly c: "rgb(0,143,17)";
        readonly d: "rgb(0,255,65)";
    };
    /**
     * Variation A of synthwave type outrun palette
     */
    readonly outrunA: {
        readonly a: "rgb(255,108,17)";
        readonly b: "rgb(255,56,100)";
        readonly c: "rgb(45,226,230)";
        readonly d: "rgb(38,20,71)";
        readonly e: "rgb(13,2,33)";
    };
    /**
     * Variation B of synthwave type outrun palette
     */
    readonly outrunB: {
        readonly a: "rgb(2, 55, 136)";
        readonly b: "rgb(101, 13, 137)";
        readonly c: "rgb(146, 0, 117)";
        readonly d: "rgb(246, 1, 157)";
        readonly e: "rgb(212, 0, 120)";
    };
    /**
     * Variation C of synthwave type outrun palette
     */
    readonly outrunC: {
        readonly a: "rgb(36, 23, 52)";
        readonly b: "rgb(46, 33, 87)";
        readonly c: "rgb(253, 55, 119)";
        readonly d: "rgb(247, 6, 207)";
        readonly e: "rgb(253, 29, 83)";
    };
    /**
     * Variation E of synthwave type outrun palette
     */
    readonly outrunD: {
        readonly a: "rgb(249, 200, 14)";
        readonly b: "rgb(255, 67, 101)";
        readonly c: "rgb(84, 13, 110)";
        readonly d: "rgb(121, 30, 148)";
        readonly e: "rgb(84, 19, 136)";
    };
    /**
     * Original tech & tribal colour palette
     */
    readonly techandtribal: {
        readonly a: "rgb(40, 127, 241)";
        readonly b: "rgb(247, 6, 207)";
        readonly c: "rgb(12,20,31)";
        readonly d: "rgb(13,2,33)";
        readonly e: "rgb(0,255,255)";
    };
    /**
     * Tron Legacy palette (original) mostly blues, blacks, whites
     * */
    readonly tron: {
        readonly a: "rgb(24,202,230)";
        readonly b: "rgb(111,195,223)";
        readonly c: "rgb(52,96,141)";
        readonly d: "rgb(40, 127, 241)";
        readonly e: "rgb(5,13,16)";
        readonly f: "rgb(13,12,28)";
        readonly g: "rgb(12,20,31)";
        readonly h: "rgb(223,116,12)";
        readonly i: "rgb(255,230,77)";
        readonly j: "rgb(216,218,231)";
        readonly k: "rgb(221, 230, 243)";
        readonly l: "rgb(230,255,255)";
    };
};
declare const GetRandomPalette: () => never;

type TLettersLowerCase = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
type TRGBColour = `${"rgb" | "RGB"}(${number},${number},${number})`;
type TRGBAColour = `${"rgba" | "RGBA"}(${number},${number},${number},${number})`;
type THexColour = `#${string}`;

export { GetRandomPalette, Log, MATH, MakeObservable, Media, OBJ, Random, STR, SetFullScreen, THexColour, TLettersLowerCase, TRGBAColour, TRGBColour, ToggleFullScreen, palettes, useCookies, useMediaQueries, useMediaQueryCustom, useMousePosition, useScreen, useSensors };