export type Objectish = AnyObject | AnyArray | AnyMap | AnySet;
export type AnyObject = {
    [key: string]: unknown;
};
export type AnyArray = readonly unknown[];
export type AnySet = ReadonlySet<unknown>;
export type AnyMap = ReadonlyMap<unknown, unknown>;
export type DefinedArray = readonly defined[];
export type DefinedSet = ReadonlySet<defined>;
export type DefinedMap = ReadonlyMap<defined, defined>;
type PrimitiveType = number | string | boolean;
type AtomicObject = Callback | Promise<unknown>;
/**
 * If the lib "ES2015.Collection" is not included in tsconfig.json,
 * types like ReadonlyArray, WeakMap etc. fall back to `any` (specified nowhere)
 * or `{}` (from the node types), in both cases entering an infinite recursion in
 * pattern matching type mappings
 * This type can be used to cast these types to `void` in these cases.
 */
type IfAvailable<T, Fallback = void> = true | false extends (T extends never ? true : false) ? Fallback : keyof T extends never ? Fallback : T;
/**
 * These should also never be mapped but must be tested after regular Map and
 * Set
 */
type WeakReferences = IfAvailable<WeakMap<AnyObject, unknown>> | IfAvailable<WeakSet<AnyObject>>;
type MutableObject<T> = {
    -readonly [K in keyof T]: Mutable<T[K]>;
};
/**@alias Draft in rbxts/immut */
export type Mutable<T> = T extends PrimitiveType ? T : T extends AtomicObject ? T : T extends ReadonlyMap<infer K, infer V> ? Map<Mutable<K>, Mutable<V>> : T extends ReadonlySet<infer V> ? Set<Mutable<V>> : T extends WeakReferences ? T : T extends object ? MutableObject<T> : T;
type ImmutableObject<T> = {
    -readonly [K in keyof T]: Mutable<T[K]>;
};
export type Immutable<T> = T extends PrimitiveType ? T : T extends AtomicObject ? T : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<Immutable<K>, Immutable<V>> : T extends ReadonlySet<infer V> ? ReadonlySet<Immutable<V>> : T extends WeakReferences ? T : T extends object ? ImmutableObject<T> : T;
type Underfined<T> = {
    [P in keyof T]: P extends undefined ? T[P] : never;
};
type FilterFlags<Base, Condition> = {
    [key in keyof Base]: Base[key] extends Condition ? key : never;
};
type AllowedNames<Base, Condition> = FilterFlags<Base, Condition>[keyof Base];
type SubType<Base, Condition> = Pick<Base, AllowedNames<Base, Condition>>;
export type OptionalKeys<T> = Exclude<keyof T, NonNullable<keyof SubType<Underfined<T>, never>>>;
export type MakeOnlyOptionalKeys<T> = {
    [key in OptionalKeys<T>]: T[key];
};
export declare namespace TableTools {
    /**
     * clones the immutable data and executes the function with draft as argument
     * @param data data to be cloned
     * @param callback draft is a clone of the data with readonly flag removed
     * @returns new changed copy of data (draft)
     */
    export function CopyData<Data extends Objectish>(data: Data, callback: (draft: Mutable<Data>) => void): Data;
    export function DeepCopyData<Data extends object>(data: Data, callback?: (draft: Mutable<Data>) => void): Data;
    export function FillOutDefaults<T extends {}>(data: Partial<T>, default_data: T): T & Partial<T>;
    type GetKeyType<T extends AnyMap> = T extends Map<infer K, defined> ? K : T extends ReadonlyMap<infer K, defined> ? K : never;
    type GetValueType<T extends AnyMap> = T extends Map<defined, infer V> ? V : T extends ReadonlyMap<defined, infer V> ? V : never;
    /**returns the keys of the map */
    export function GetKeys<T extends DefinedMap>(map: T): GetKeyType<T>[];
    /**returns the values of the map */
    export function GetValues<T extends DefinedMap>(map: T): GetValueType<T>[];
    export function IsArray(data: object): boolean;
    export function ExtractElementsFromRecursiveData<Data extends object>(data: Data, check: (element: defined, key: defined, taken_elements: Array<defined>, data: Data) => boolean, ignore_table_if_added?: boolean): defined[];
    export function Filter<K, V>(map: ReadonlyMap<K, V>, check: (value: V, key: K, map: ReadonlyMap<K, V>) => boolean): Map<K, V>;
    /**@returns first element from the map [key, value] */
    export function GetFirst<T extends DefinedMap>(map: T): LuaTuple<[defined, defined]> | undefined;
    export function GetRandomKey<T extends DefinedMap>(map: T): GetKeyType<T>;
    export function GetRandomValue<T extends DefinedMap>(map: T): GetValueType<T>;
    export function GetOrCreate<T extends DefinedMap, K = GetKeyType<T>, V = GetValueType<T>>(map: Map<K, V>, key: K, create_callback: (key: K, map: Map<K, V>) => V): NonNullable<V>;
    export function Find<K, V>(map: ReadonlyMap<K, V>, check: (element: V, key: K, map: ReadonlyMap<K, V>) => boolean): V | undefined;
    export function FindKey<K, V>(map: ReadonlyMap<K, V>, check: (element: V, key: K, map: ReadonlyMap<K, V>) => boolean): K | undefined;
    export function Includes<K, V>(map: ReadonlyMap<K, V>, check: (element: V, key: K, map: ReadonlyMap<K, V>) => boolean): boolean;
    export function KeyOf<K, V>(map: ReadonlyMap<K, V>, seached_value: V): K | undefined;
    export function ToPairs<K, V>(map: ReadonlyMap<K, V>): [K, V][];
    export function MapToArray<K, V, Q extends defined>(map: ReadonlyMap<K, V>, selector: (key: K, value: V, map: ReadonlyMap<K, V>) => Q): Q[];
    export function MapToArrayFiltered<K, V, Q extends defined>(map: ReadonlyMap<K, V>, selector: (key: K, value: V, map: ReadonlyMap<K, V>) => Q | void): Q[];
    /**
     *
     * @param new_map
     * @param old_map
     * @returns keys that dont exist in new_map, but exist in old_map
     */
    export function GetMissingKeys<K extends defined>(new_map: ReadonlyMap<K, unknown>, old_map: ReadonlyMap<K, unknown>): K[];
    /**
     *
     * @param new_map
     * @param old_map
     * @returns keys that exist in new_map, but dont exist in old_map
     */
    export function GetNewKeys<K extends defined>(new_map: ReadonlyMap<K, unknown>, old_map: ReadonlyMap<K, unknown>): K[];
    /**
     *
     * @param new_map
     * @param old_map
     * @param selector
     * @param ignore_missing_or_new_keys
     * @returns keys of different values
     */
    export function GetDifferentValueKeys<K extends defined, V1, V2>(new_map: ReadonlyMap<K, V1>, old_map: ReadonlyMap<K, V2>, selector?: (value_1: V1, value_2: V2, key_1: K, key_2: K, map_1: ReadonlyMap<K, V1>, map_2: ReadonlyMap<K, V2>) => boolean, ignore_missing_or_new_keys?: boolean): K[];
    /**
     * maps the map to the new map
     * @param map map
     * @param selector => [new_key, new_value]
     * @returns mapped map from map
     */
    export function MapToNew<K0, V0, K1, V1>(map: ReadonlyMap<K0, V0>, selector: (key: K0, value: V0, map: ReadonlyMap<K0, V0>) => [K1, V1]): Map<K1, V1>;
    /**
     * maps the map to the new map, if no value was returned will filter the value
     * @param map map
     * @param selector => [new_key, new_value]
     * @returns mapped filtered map from map
     */
    export function MapFiltered<K0, V0, K1, V1>(map: ReadonlyMap<K0, V0>, selector: (key: K0, value: V0, map: ReadonlyMap<K0, V0>) => void | undefined | [K1, V1]): Map<K1, V1>;
    export {};
}
export {};