/**
Represents an array with `unknown` value.

Use case: You want a type that all arrays can be assigned to, but you don't care about the value.

@example
```
import type {UnknownArray} from 'type-fest';

type IsArray<T> = T extends UnknownArray ? true : false;

type A = IsArray<['foo']>;
//=> true

type B = IsArray<readonly number[]>;
//=> true

type C = IsArray<string>;
//=> false
```

@category Type
@category Array
*/
type UnknownArray = readonly unknown[];

/**
Extracts the element type of an array or tuple.

Use-cases:
- When you need type-safe element extraction that returns `never` for non-arrays.
- When extracting element types from generic array parameters in function signatures.
- For better readability and explicit intent over using `T[number]` directly.

Note: Returns `never` if the type is not an array.

@example
```
import type {ArrayElement} from 'type-fest';

// Arrays
type StringArray = ArrayElement<string[]>;
//=> string

// Tuples
type Tuple = ArrayElement<[1, 2, 3]>;
//=> 1 | 2 | 3

// Type-safe
type NotArray = ArrayElement<{a: string}>;
//=> never

// Practical example
declare function getRandomElement<T extends readonly unknown[]>(array: T): ArrayElement<T>;

getRandomElement(['foo', 'bar', 'baz'] as const);
//=> 'foo' | 'bar' | 'baz'
```

@see {@link ArrayValues} - For directly extracting values from a constant array type.
@see {@link IterableElement} - For iterables like `Set`, `Map`, and generators (not suitable for all use cases due to different inference behavior).

@category Array
*/
type ArrayElement<T> =
	T extends UnknownArray
		? T[number]
		: never;

type BaseContext = {
    readonly [key: string]: unknown;
};
type BreakpointObject<TName extends string, TContext extends object> = Readonly<Record<TName, (__DEBUG_CONTEXT__: TContext, ...args: any[]) => void>>;
interface DebugAPIType<TBreakpointName extends string, TContext extends object> {
    /**
     * 🚨 This is strictly for debugging only.
     *
     * List of execution points for debugger to break into.
     *
     * Type `debug($0.webChat.breakpoint.functionName)` in DevTools to break into specific execution.
     */
    get breakpoint(): BreakpointObject<TBreakpointName, TContext>;
    /**
     * 🚨 This is strictly for debugging only.
     *
     * Break into debugger immediately.
     *
     * Note: if Content Security Policy is enabled, it may not break into debugger.
     */
    get debugger(): void;
}
/**
 * This is the triggering side of the debugging API.
 *
 * This object should be kept inside the code that need to be debugged.
 *
 * For public consumption, call `toPublic()` to create an object for receiving side.
 */
interface RestrictedDebugAPIType<TBreakpointName extends string, TContext extends BaseContext> {
    /**
     * Creates a public version of Debug API for external consumption.
     */
    toPublic(): DebugAPIType<TBreakpointName, TContext>;
    /**
     * Triggers a breakpoint function.
     */
    get UNSAFE_callBreakpoint(): Readonly<Record<TBreakpointName, (...args: any[]) => void>>;
    readonly '~types': {
        readonly public: DebugAPIType<TBreakpointName, TContext>;
    };
}
type InferPublic<T extends RestrictedDebugAPIType<any, any>> = T['~types']['public'];

declare class DebugAPI<TBreakpointName extends string, TContext extends object> implements DebugAPIType<TBreakpointName, TContext> {
    #private;
    constructor(breakpoint: BreakpointObject<TBreakpointName, TContext>, context: TContext);
    get breakpoint(): Readonly<Record<TBreakpointName, (__DEBUG_CONTEXT__: TContext, ...args: any[]) => void>>;
    get debugger(): undefined;
}

type AsGetters<T> = {
    readonly [K in keyof T]: () => T[K];
};
declare abstract class RestrictedDebugAPI<TBreakpointName extends string, TContext extends BaseContext> implements RestrictedDebugAPIType<TBreakpointName, TContext> {
    #private;
    constructor(breakpointNames: readonly TBreakpointName[], contextGetters: AsGetters<TContext>);
    toPublic(): DebugAPI<TBreakpointName, TContext>;
    UNSAFE_callBreakpoint: Readonly<Record<TBreakpointName, (...args: any[]) => void>>;
    get '~types'(): Readonly<{
        public: any;
    }>;
}

export { RestrictedDebugAPI as R };
export type { ArrayElement as A, InferPublic as I };