@glimmer/util

let assign: {
    <T, U>(target: T, source: U): T & U;
    <T_1, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
    <T_2, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 &
        U_2 &
        V_1 &
        W;
    (target: object, ...sources: any[]): any;
};

let beginTestSteps: () => void;

let debugToString: (value: unknown) => string;

const EMPTY_ARRAY: readonly unknown[];

const EMPTY_NUMBER_ARRAY: number[];

const EMPTY_STRING_ARRAY: string[];

let endTestSteps: () => void;

const HAS_NATIVE_PROXY: boolean;

const HAS_NATIVE_SYMBOL: boolean;

const LOCAL_LOGGER: Console;

const LOGGER: Console;

let logStep: (type: string, steps: unknown) => void;

const SERIALIZATION_FIRST_NODE_STRING: string;

const symbol: (key: string) => any;

let verifySteps: (
    type: string,
    steps: unknown[] | ((steps: unknown[]) => void),
    message?: string
) => void;

assert: (test: any, msg: string) => asserts test;

assertNever: (value: never, desc?: string) => never;

assertPresent: <T>(
    list: T[],
    message?: string
) => asserts list is PresentArray<T>;

buildUntouchableThis: (source: string) => null | object;

castToBrowser: {
    (doc: Document | SimpleDocument): Document;
    <S extends SugaryNodeCheck<keyof BrowserElementTags>>(
        node: any,
        check: S
    ): NodeForSugaryCheck<S>;
    <S extends SugaryNodeCheck<'NODE'>>(
        element: any,
        check: S
    ): NodeForSugaryCheck<S>;
    <K extends keyof HTMLElementTagNameMap>(
        element: any,
        check: K
    ): HTMLElementTagNameMap[K];
};

castToSimple: {
    (doc: Document | SimpleDocument): SimpleDocument;
    (elem: any): SimpleElement;
    (node: any): SimpleNode;
};

checkNode: <S extends SugaryNodeCheck<keyof BrowserTags>>(
    node: Node | null,
    check: S
) => NodeForSugaryCheck<S>;

clearElement: (parent: SimpleElement) => void;

constants: (...values: unknown[]) => unknown[];

decodeHandle: (num: number) => number;

decodeImmediate: (num: number) => number;

decodeNegative: (num: number) => number;

decodePositive: (num: number) => number;

deprecate: (desc: string) => void;

dict: <T = unknown>() => Dict<T>;

emptyArray: <T extends unknown>() => T[];

encodeHandle: (num: number) => number;

encodeImmediate: (num: number) => number;

encodeNegative: (num: number) => number;

encodePositive: (num: number) => number;

enumerableSymbol: (key: string) => any;

exhausted: (value: never) => never;

expect: <T>(val: Maybe<T>, message: string) => T;

extractHandle: (handle: HandleResult) => number;

fillNulls: <T>(count: number) => T[];

ifPresent: <T, U, V>(
    list: T[],
    ifPresent: (input: PresentArray<T>) => U,
    otherwise: () => V
) => U | V;

intern: (str: string) => string;

isDict: <T>(u: T) => u is any;

isEmptyArray: (input: unknown[] | readonly unknown[]) => boolean;

isErrHandle: (handle: HandleResult) => handle is ErrHandle;

isHandle: (value: number) => boolean;

isNonPrimitiveHandle: (value: number) => boolean;

isObject: <T>(u: T) => u is object & T;

isOkHandle: (handle: HandleResult) => handle is OkHandle;

isPresent: <T>(list: readonly T[]) => list is PresentArray<T>;

isSerializationFirstNode: (node: SimpleNode) => boolean;

isSmallInt: (value: number) => boolean;

keys: <T>(obj: T) => Array<keyof T>;

mapPresent: {
    <T, U>(list: PresentArray<T>, callback: (input: T) => U): PresentArray<U>;
    <T, U>(list: any, callback: (input: T) => U): any;
};

strip: (strings: TemplateStringsArray, ...args: unknown[]) => string;

toPresentOption: <T>(list: T[]) => Option<PresentArray<T>>;

tuple: <T extends Lit[]>(...args: T) => T;

unreachable: (message?: string) => Error;

unwrap: <T>(val: Maybe<T>) => T;

unwrapHandle: (handle: HandleResult) => number;

unwrapTemplate: (template: Template) => TemplateOk;

values: <T>(obj: { [s: string]: T }) => T[];

type Factory<T> = new (...args: unknown[]) => T;

type FIXME<T, S extends string> = (T & S) | T;

type Lit = string | number | boolean | undefined | null | void | {};