import type { ComponentType } from 'react';
export type Maybe<T> = T | null | undefined;
/**
 * Makes only mutable types (objects, arrays) readonly while leaving primitive
 * types unchanged. This prevents type issues caused by making other types
 * readonly, like Readonly<string> which isn't the same as string.
 */
export type NonMutable<T> = T extends object ? Readonly<T> : T;
export type UnknownRecord = Record<string, unknown>;
export type AnyComponent = ComponentType<any>;
export type Simplify<T> = {
    [K in keyof T]: T[K];
} & {};
export type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = {
    [K in Keys]-?: Required<Pick<T, K>> & Partial<Omit<T, K>>;
}[Keys];
type ConvertValueToArray<T> = Simplify<(T extends any[] ? T[number] : T)[]>;
export type ConvertValuesToArrays<T> = {
    [K in keyof T]-?: ConvertValueToArray<Exclude<T[K], undefined>>;
};
export type ConvertValuesToArraysWithUndefined<T> = {
    [K in keyof T]-?: ConvertValueToArray<T[K]>;
};
type AllKeys<U> = U extends unknown ? keyof U : never;
/**
 * Turns a tuple of object shapes into a union whose members are mutually
 * exclusive: choosing one member forbids every key that belongs only to the
 * others (each such key becomes `?: never`). Use it instead of hand-writing the
 * `?: never` fields.
 *
 * @example
 *   `MutuallyExclusiveUnion<[{ x: number }, { y: number }]>` resolves to
 *   `{ x: number; y?: never } | { y: number; x?: never }`.
 */
export type MutuallyExclusiveUnion<T extends ReadonlyArray<unknown>, Processed extends ReadonlyArray<unknown> = []> = T extends readonly [infer First, ...infer Rest] ? Simplify<(First & {
    [K in Exclude<AllKeys<[...Processed, ...Rest][number]>, keyof First>]?: never;
}) | MutuallyExclusiveUnion<Rest, readonly [...Processed, First]>> : never;
export {};
//# sourceMappingURL=helpers.d.ts.map