type NoopFunc = typeof noopFunc;
declare function noopFunc(): void;
type AnyFunc = typeof anyFunc;
declare function anyFunc(...args: any[]): any;
type AnyObject = Record<string, any>;
declare const AnyObject: AnyObject;
type ValueOf<T extends Record<string, any>> = T[keyof T];
type AllKeys<T extends Record<string, any>> = T extends Record<string, any> ? T extends any[] ? never : keyof T | {
    [K in keyof T]: AllKeys<T[K]>;
}[keyof T] : never;
type ClientXY = {
    clientX: number;
    clientY: number;
};

declare function firstOne<T extends any = any>(input: T[] | Set<T>): T | undefined;
declare function lastOne<T extends any = any>(input: T[] | Set<T>): T;
declare function deleteFromArray<T>(target: T[], filter: string | ((value: T) => boolean)): void;
declare function flushFuncs<T extends NoopFunc>(input: T[] | Set<T>): void;
declare function clampIndex<T extends any = any>(arr: T[], index?: number): number;
declare function loopFor<T>(arr: T[], callback: (cur: T, next: T, prev: T, index: number) => 'continue' | 'break' | void): void;

declare const ThisAsAny: any;
declare function iife<T extends any = any>(callback: () => T): T;
/**
 * @deprecated
 */
declare function matchCase<T extends string, R extends any>(Case: T, obj: Partial<Record<T, R>> & {
    _default?: R;
}): R | undefined;
declare function Log<T>(someThing: T, label?: string): T;
declare function clone<T extends any>(object: T): T;
declare function jsonFy(obj: any): string;
declare function jsonParse<T = any>(obj: any, fallback?: T): T | undefined;
declare function objKeys<K extends string>(obj: Partial<Record<K, any>>): K[];
declare function objectId(obj: AnyObject): string;
declare function suffixOf(input?: string, lowerCase?: boolean): string;
declare function createFuncAOP<T extends (...args: any[]) => any>({ before, after, }?: {
    before?: (...args: Parameters<T>) => void;
    after?: (result: ReturnType<T>, ...args: Parameters<T>) => void;
}): (func: T) => T;
declare function safeTimeout(func: () => any, delay?: number): void;
declare function miniId(size?: number, alphabet?: string): string;
declare function optionalSet<T extends AnyObject>(obj: T | undefined | null, key: keyof T, value: T[keyof T]): void;

type ObjCacheStore<K extends PropertyKey, V> = Partial<Record<K, V>>;
declare function getSet<K, V>(cache: Map<K, V>, key: K, fn: () => V, compare?: unknown[]): V;
declare function getSet<K extends object, V>(cache: WeakMap<K, V>, key: K, fn: () => V, compare?: unknown[]): V;
declare function getSet<K extends PropertyKey, V>(cache: ObjCacheStore<K, V>, key: K, fn: () => V, compare?: unknown[]): V;

type MatchKey = string | number | symbol;
type MatchHandler = (...args: any[]) => unknown;
type MatchValue = string | number | boolean | bigint | symbol | object | null | undefined;
type MatchCase<Value> = MatchValue | ((value: Value) => unknown);
type CaseResult<Case> = Case extends MatchHandler ? ReturnType<Case> : Case;
type MatchResult<Cases> = CaseResult<Cases[keyof Cases]>;
type ExhaustiveValueCases<Value extends MatchKey> = {
    [Case in Value]: MatchCase<Case>;
};
type PartialValueCases<Value extends MatchKey> = Partial<ExhaustiveValueCases<Value>> & {
    _: MatchCase<Value>;
};
type UnionToIntersection<Value> = (Value extends unknown ? (value: Value) => void : never) extends (value: infer Intersection) => void ? Intersection : never;
type ExhaustiveObjectCases<Value, Key extends MatchKey> = UnionToIntersection<Value extends Record<Key, infer Case extends MatchKey> ? {
    [CurrentCase in Case]: MatchCase<Value>;
} : never>;
type PartialObjectCases<Value, Key extends MatchKey> = Partial<ExhaustiveObjectCases<Value, Key>> & {
    _: MatchCase<Value>;
};
declare function match<const Value extends MatchKey, const Cases extends ExhaustiveValueCases<NoInfer<Value>>>(value: Value, cases: Cases): MatchResult<Cases>;
declare function match<const Value extends MatchKey, const Cases extends PartialValueCases<NoInfer<Value>>>(value: Value, cases: Cases): MatchResult<Cases>;
declare function match<const Value, const Key extends keyof Value, const Cases extends ExhaustiveObjectCases<Value, Extract<Key, MatchKey>>>(value: Value, key: Key & (Value[Key] extends MatchKey ? unknown : never), cases: Cases): MatchResult<Cases>;
declare function match<const Value, const Key extends keyof Value, const Cases extends PartialObjectCases<Value, Extract<Key, MatchKey>>>(value: Value, key: Key & (Value[Key] extends MatchKey ? unknown : never), cases: Cases): MatchResult<Cases>;

export { type AllKeys, type AnyFunc, AnyObject, type ClientXY, Log, type NoopFunc, ThisAsAny, type ValueOf, anyFunc, clampIndex, clone, createFuncAOP, deleteFromArray, firstOne, flushFuncs, getSet, iife, jsonFy, jsonParse, lastOne, loopFor, match, matchCase, miniId, noopFunc, objKeys, objectId, optionalSet, safeTimeout, suffixOf };