babel-plugin-react-compiler 0.0.0 → 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1705 @@
+import * as BabelCore from '@babel/core';
+import { NodePath as NodePath$1 } from '@babel/core';
+import * as t from '@babel/types';
+import { z } from 'zod';
+import { NodePath, Scope } from '@babel/traverse';
+
+interface Result<T, E> {
+    map<U>(fn: (val: T) => U): Result<U, E>;
+    mapErr<F>(fn: (val: E) => F): Result<T, F>;
+    mapOr<U>(fallback: U, fn: (val: T) => U): U;
+    mapOrElse<U>(fallback: () => U, fn: (val: T) => U): U;
+    andThen<U>(fn: (val: T) => Result<U, E>): Result<U, E>;
+    and<U>(res: Result<U, E>): Result<U, E>;
+    or(res: Result<T, E>): Result<T, E>;
+    orElse<F>(fn: (val: E) => Result<T, F>): Result<T, F>;
+    isOk(): this is OkImpl<T>;
+    isErr(): this is ErrImpl<E>;
+    expect(msg: string): T;
+    expectErr(msg: string): E;
+    unwrap(): T;
+    unwrapOr(fallback: T): T;
+    unwrapOrElse(fallback: (val: E) => T): T;
+    unwrapErr(): E;
+}
+declare class OkImpl<T> implements Result<T, never> {
+    #private;
+    constructor(val: T);
+    map<U>(fn: (val: T) => U): Result<U, never>;
+    mapErr<F>(_fn: (val: never) => F): Result<T, F>;
+    mapOr<U>(_fallback: U, fn: (val: T) => U): U;
+    mapOrElse<U>(_fallback: () => U, fn: (val: T) => U): U;
+    andThen<U>(fn: (val: T) => Result<U, never>): Result<U, never>;
+    and<U>(res: Result<U, never>): Result<U, never>;
+    or(_res: Result<T, never>): Result<T, never>;
+    orElse<F>(_fn: (val: never) => Result<T, F>): Result<T, F>;
+    isOk(): this is OkImpl<T>;
+    isErr(): this is ErrImpl<never>;
+    expect(_msg: string): T;
+    expectErr(msg: string): never;
+    unwrap(): T;
+    unwrapOr(_fallback: T): T;
+    unwrapOrElse(_fallback: (val: never) => T): T;
+    unwrapErr(): never;
+}
+declare class ErrImpl<E> implements Result<never, E> {
+    #private;
+    constructor(val: E);
+    map<U>(_fn: (val: never) => U): Result<U, E>;
+    mapErr<F>(fn: (val: E) => F): Result<never, F>;
+    mapOr<U>(fallback: U, _fn: (val: never) => U): U;
+    mapOrElse<U>(fallback: () => U, _fn: (val: never) => U): U;
+    andThen<U>(_fn: (val: never) => Result<U, E>): Result<U, E>;
+    and<U>(_res: Result<U, E>): Result<U, E>;
+    or(res: Result<never, E>): Result<never, E>;
+    orElse<F>(fn: (val: E) => ErrImpl<F>): Result<never, F>;
+    isOk(): this is OkImpl<never>;
+    isErr(): this is ErrImpl<E>;
+    expect(msg: string): never;
+    expectErr(_msg: string): E;
+    unwrap(): never;
+    unwrapOr<T>(fallback: T): T;
+    unwrapOrElse<T>(fallback: (val: E) => T): T;
+    unwrapErr(): E;
+}
+
+type AliasingEffect = {
+    kind: 'Freeze';
+    value: Place;
+    reason: ValueReason;
+} | {
+    kind: 'Mutate';
+    value: Place;
+    reason?: MutationReason | null;
+} | {
+    kind: 'MutateConditionally';
+    value: Place;
+} | {
+    kind: 'MutateTransitive';
+    value: Place;
+} | {
+    kind: 'MutateTransitiveConditionally';
+    value: Place;
+} | {
+    kind: 'Capture';
+    from: Place;
+    into: Place;
+} | {
+    kind: 'Alias';
+    from: Place;
+    into: Place;
+} | {
+    kind: 'MaybeAlias';
+    from: Place;
+    into: Place;
+} | {
+    kind: 'Assign';
+    from: Place;
+    into: Place;
+} | {
+    kind: 'Create';
+    into: Place;
+    value: ValueKind;
+    reason: ValueReason;
+} | {
+    kind: 'CreateFrom';
+    from: Place;
+    into: Place;
+} | {
+    kind: 'ImmutableCapture';
+    from: Place;
+    into: Place;
+} | {
+    kind: 'Apply';
+    receiver: Place;
+    function: Place;
+    mutatesFunction: boolean;
+    args: Array<Place | SpreadPattern | Hole>;
+    into: Place;
+    signature: FunctionSignature | null;
+    loc: SourceLocation;
+} | {
+    kind: 'CreateFunction';
+    captures: Array<Place>;
+    function: FunctionExpression | ObjectMethod;
+    into: Place;
+} | {
+    kind: 'MutateFrozen';
+    place: Place;
+    error: CompilerDiagnostic;
+} | {
+    kind: 'MutateGlobal';
+    place: Place;
+    error: CompilerDiagnostic;
+} | {
+    kind: 'Impure';
+    place: Place;
+    error: CompilerDiagnostic;
+} | {
+    kind: 'Render';
+    place: Place;
+};
+type MutationReason = {
+    kind: 'AssignCurrentProperty';
+};
+type AliasingSignature = {
+    receiver: IdentifierId;
+    params: Array<IdentifierId>;
+    rest: IdentifierId | null;
+    returns: IdentifierId;
+    effects: Array<AliasingEffect>;
+    temporaries: Array<Place>;
+};
+
+type BuiltInType = PrimitiveType | FunctionType | ObjectType;
+type Type = BuiltInType | PhiType | TypeVar | PolyType | PropType | ObjectMethod$1;
+type PrimitiveType = {
+    kind: 'Primitive';
+};
+type FunctionType = {
+    kind: 'Function';
+    shapeId: string | null;
+    return: Type;
+    isConstructor: boolean;
+};
+type ObjectType = {
+    kind: 'Object';
+    shapeId: string | null;
+};
+type TypeVar = {
+    kind: 'Type';
+    id: TypeId;
+};
+type PolyType = {
+    kind: 'Poly';
+};
+type PhiType = {
+    kind: 'Phi';
+    operands: Array<Type>;
+};
+type PropType = {
+    kind: 'Property';
+    objectType: Type;
+    objectName: string;
+    propertyName: {
+        kind: 'literal';
+        value: PropertyLiteral;
+    } | {
+        kind: 'computed';
+        value: Type;
+    };
+};
+type ObjectMethod$1 = {
+    kind: 'ObjectMethod';
+};
+declare const opaqueTypeId: unique symbol;
+type TypeId = number & {
+    [opaqueTypeId]: 'IdentifierId';
+};
+
+type HookKind = 'useContext' | 'useState' | 'useActionState' | 'useReducer' | 'useRef' | 'useEffect' | 'useLayoutEffect' | 'useInsertionEffect' | 'useMemo' | 'useCallback' | 'useTransition' | 'useImperativeHandle' | 'useEffectEvent' | 'Custom';
+type FunctionSignature = {
+    positionalParams: Array<Effect>;
+    restParam: Effect | null;
+    returnType: BuiltInType | PolyType;
+    returnValueKind: ValueKind;
+    returnValueReason?: ValueReason;
+    calleeEffect: Effect;
+    hookKind: HookKind | null;
+    noAlias?: boolean;
+    mutableOnlyIfOperandsAreMutable?: boolean;
+    impure?: boolean;
+    knownIncompatible?: string | null | undefined;
+    canonicalName?: string;
+    aliasing?: AliasingSignature | null | undefined;
+};
+
+type Global = BuiltInType | PolyType;
+
+type ResolvedType = {
+    kind: 'Concrete';
+    type: ConcreteType<ResolvedType>;
+    platform: Platform;
+};
+type ComponentType<T> = {
+    kind: 'Component';
+    props: Map<string, T>;
+    children: null | T;
+};
+type ConcreteType<T> = {
+    kind: 'Enum';
+} | {
+    kind: 'Mixed';
+} | {
+    kind: 'Number';
+} | {
+    kind: 'String';
+} | {
+    kind: 'Boolean';
+} | {
+    kind: 'Void';
+} | {
+    kind: 'Nullable';
+    type: T;
+} | {
+    kind: 'Array';
+    element: T;
+} | {
+    kind: 'Set';
+    element: T;
+} | {
+    kind: 'Map';
+    key: T;
+    value: T;
+} | {
+    kind: 'Function';
+    typeParameters: null | Array<TypeParameter<T>>;
+    params: Array<T>;
+    returnType: T;
+} | ComponentType<T> | {
+    kind: 'Generic';
+    id: TypeParameterId;
+    bound: T;
+} | {
+    kind: 'Object';
+    id: NominalId;
+    members: Map<string, ResolvedType>;
+} | {
+    kind: 'Tuple';
+    id: NominalId;
+    members: Array<T>;
+} | {
+    kind: 'Structural';
+    id: LinearId;
+} | {
+    kind: 'Union';
+    members: Array<T>;
+} | {
+    kind: 'Instance';
+    name: string;
+    members: Map<string, ResolvedType>;
+};
+type TypeParameter<T> = {
+    name: string;
+    id: TypeParameterId;
+    bound: T;
+};
+declare const opaqueLinearId: unique symbol;
+type LinearId = number & {
+    [opaqueLinearId]: 'LinearId';
+};
+declare const opaqueTypeParameterId: unique symbol;
+type TypeParameterId = number & {
+    [opaqueTypeParameterId]: 'TypeParameterId';
+};
+declare const opaqueNominalId: unique symbol;
+type NominalId = number & {
+    [opaqueNominalId]: 'NominalId';
+};
+type Platform = 'client' | 'server' | 'shared';
+interface ITypeEnv {
+    popGeneric(name: string): void;
+    getGeneric(name: string): null | TypeParameter<ResolvedType>;
+    pushGeneric(name: string, binding: {
+        name: string;
+        id: TypeParameterId;
+        bound: ResolvedType;
+    }): void;
+    getType(id: Identifier): ResolvedType;
+    getTypeOrNull(id: Identifier): ResolvedType | null;
+    setType(id: Identifier, type: ResolvedType): void;
+    nextNominalId(): NominalId;
+    nextTypeParameterId(): TypeParameterId;
+    moduleEnv: Map<string, ResolvedType>;
+    addBinding(bindingIdentifier: t.Identifier, type: ResolvedType): void;
+    resolveBinding(bindingIdentifier: t.Identifier): ResolvedType | null;
+}
+declare class FlowTypeEnv implements ITypeEnv {
+    #private;
+    moduleEnv: Map<string, ResolvedType>;
+    init(env: Environment, source: string): void;
+    setType(identifier: Identifier, type: ResolvedType): void;
+    getType(identifier: Identifier): ResolvedType;
+    getTypeOrNull(identifier: Identifier): ResolvedType | null;
+    getTypeByLoc(loc: SourceLocation): ResolvedType | null;
+    nextNominalId(): NominalId;
+    nextTypeParameterId(): TypeParameterId;
+    addBinding(bindingIdentifier: t.Identifier, type: ResolvedType): void;
+    resolveBinding(bindingIdentifier: t.Identifier): ResolvedType | null;
+    pushGeneric(name: string, generic: TypeParameter<ResolvedType>): void;
+    popGeneric(name: string): void;
+    getGeneric(name: string): null | TypeParameter<ResolvedType>;
+}
+
+declare const ExternalFunctionSchema: z.ZodObject<{
+    source: z.ZodString;
+    importSpecifierName: z.ZodString;
+}, z.core.$strip>;
+type ExternalFunction = z.infer<typeof ExternalFunctionSchema>;
+type CompilerMode = 'all_features' | 'no_inferred_memo';
+declare const HookSchema: z.ZodObject<{
+    effectKind: z.ZodEnum<typeof Effect>;
+    valueKind: z.ZodEnum<typeof ValueKind>;
+    noAlias: z.ZodDefault<z.ZodBoolean>;
+    transitiveMixedData: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type Hook = z.infer<typeof HookSchema>;
+declare const EnvironmentConfigSchema: z.ZodObject<{
+    customHooks: z.ZodDefault<z.ZodMap<z.ZodString, z.ZodObject<{
+        effectKind: z.ZodEnum<typeof Effect>;
+        valueKind: z.ZodEnum<typeof ValueKind>;
+        noAlias: z.ZodDefault<z.ZodBoolean>;
+        transitiveMixedData: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    moduleTypeProvider: z.ZodDefault<z.ZodNullable<z.ZodAny>>;
+    customMacros: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodTuple<[z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"wildcard">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"name">;
+        name: z.ZodString;
+    }, z.core.$strip>]>>], null>]>>>>;
+    enableResetCacheOnSourceFileChanges: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+    enablePreserveExistingMemoizationGuarantees: z.ZodDefault<z.ZodBoolean>;
+    validatePreserveExistingMemoizationGuarantees: z.ZodDefault<z.ZodBoolean>;
+    enablePreserveExistingManualUseMemo: z.ZodDefault<z.ZodBoolean>;
+    enableForest: z.ZodDefault<z.ZodBoolean>;
+    enableUseTypeAnnotations: z.ZodDefault<z.ZodBoolean>;
+    flowTypeProvider: z.ZodDefault<z.ZodNullable<z.ZodAny>>;
+    enableOptionalDependencies: z.ZodDefault<z.ZodBoolean>;
+    enableFire: z.ZodDefault<z.ZodBoolean>;
+    enableNameAnonymousFunctions: z.ZodDefault<z.ZodBoolean>;
+    inferEffectDependencies: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        function: z.ZodObject<{
+            source: z.ZodString;
+            importSpecifierName: z.ZodString;
+        }, z.core.$strip>;
+        autodepsIndex: z.ZodNumber;
+    }, z.core.$strip>>>>;
+    inlineJsxTransform: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        elementSymbol: z.ZodUnion<readonly [z.ZodLiteral<"react.element">, z.ZodLiteral<"react.transitional.element">]>;
+        globalDevVar: z.ZodString;
+    }, z.core.$strip>>>;
+    validateHooksUsage: z.ZodDefault<z.ZodBoolean>;
+    validateRefAccessDuringRender: z.ZodDefault<z.ZodBoolean>;
+    validateNoSetStateInRender: z.ZodDefault<z.ZodBoolean>;
+    validateNoSetStateInEffects: z.ZodDefault<z.ZodBoolean>;
+    validateNoDerivedComputationsInEffects: z.ZodDefault<z.ZodBoolean>;
+    validateNoJSXInTryStatements: z.ZodDefault<z.ZodBoolean>;
+    validateStaticComponents: z.ZodDefault<z.ZodBoolean>;
+    validateMemoizedEffectDependencies: z.ZodDefault<z.ZodBoolean>;
+    validateNoCapitalizedCalls: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    validateBlocklistedImports: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    validateNoImpureFunctionsInRender: z.ZodDefault<z.ZodBoolean>;
+    validateNoFreezingKnownMutableFunctions: z.ZodDefault<z.ZodBoolean>;
+    enableAssumeHooksFollowRulesOfReact: z.ZodDefault<z.ZodBoolean>;
+    enableTransitivelyFreezeFunctionExpressions: z.ZodDefault<z.ZodBoolean>;
+    enableEmitFreeze: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        source: z.ZodString;
+        importSpecifierName: z.ZodString;
+    }, z.core.$strip>>>;
+    enableEmitHookGuards: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        source: z.ZodString;
+        importSpecifierName: z.ZodString;
+    }, z.core.$strip>>>;
+    enableInstructionReordering: z.ZodDefault<z.ZodBoolean>;
+    enableFunctionOutlining: z.ZodDefault<z.ZodBoolean>;
+    enableJsxOutlining: z.ZodDefault<z.ZodBoolean>;
+    enableEmitInstrumentForget: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        fn: z.ZodObject<{
+            source: z.ZodString;
+            importSpecifierName: z.ZodString;
+        }, z.core.$strip>;
+        gating: z.ZodNullable<z.ZodObject<{
+            source: z.ZodString;
+            importSpecifierName: z.ZodString;
+        }, z.core.$strip>>;
+        globalGating: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+    assertValidMutableRanges: z.ZodDefault<z.ZodBoolean>;
+    enableChangeVariableCodegen: z.ZodDefault<z.ZodBoolean>;
+    enableMemoizationComments: z.ZodDefault<z.ZodBoolean>;
+    throwUnknownException__testonly: z.ZodDefault<z.ZodBoolean>;
+    enableTreatFunctionDepsAsConditional: z.ZodDefault<z.ZodBoolean>;
+    disableMemoizationForDebugging: z.ZodDefault<z.ZodBoolean>;
+    enableChangeDetectionForDebugging: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        source: z.ZodString;
+        importSpecifierName: z.ZodString;
+    }, z.core.$strip>>>;
+    enableCustomTypeDefinitionForReanimated: z.ZodDefault<z.ZodBoolean>;
+    hookPattern: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    enableTreatRefLikeIdentifiersAsRefs: z.ZodDefault<z.ZodBoolean>;
+    enableTreatSetIdentifiersAsStateSetters: z.ZodDefault<z.ZodBoolean>;
+    lowerContextAccess: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        source: z.ZodString;
+        importSpecifierName: z.ZodString;
+    }, z.core.$strip>>>;
+    validateNoVoidUseMemo: z.ZodDefault<z.ZodBoolean>;
+    validateNoDynamicallyCreatedComponentsOrHooks: z.ZodDefault<z.ZodBoolean>;
+    enableAllowSetStateFromRefsInEffects: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type EnvironmentConfig = z.infer<typeof EnvironmentConfigSchema>;
+type PartialEnvironmentConfig = Partial<EnvironmentConfig>;
+type ReactFunctionType = 'Component' | 'Hook' | 'Other';
+declare class Environment {
+    #private;
+    logger: Logger | null;
+    filename: string | null;
+    code: string | null;
+    config: EnvironmentConfig;
+    fnType: ReactFunctionType;
+    compilerMode: CompilerMode;
+    programContext: ProgramContext;
+    hasFireRewrite: boolean;
+    hasInferredEffect: boolean;
+    inferredEffectLocations: Set<SourceLocation>;
+    parentFunction: NodePath<t.Function>;
+    constructor(scope: Scope, fnType: ReactFunctionType, compilerMode: CompilerMode, config: EnvironmentConfig, contextIdentifiers: Set<t.Identifier>, parentFunction: NodePath<t.Function>, logger: Logger | null, filename: string | null, code: string | null, programContext: ProgramContext);
+    get typeContext(): FlowTypeEnv;
+    get isInferredMemoEnabled(): boolean;
+    get nextIdentifierId(): IdentifierId;
+    get nextBlockId(): BlockId;
+    get nextScopeId(): ScopeId;
+    get scope(): Scope;
+    logErrors(errors: Result<void, CompilerError>): void;
+    isContextIdentifier(node: t.Identifier): boolean;
+    isHoistedIdentifier(node: t.Identifier): boolean;
+    generateGloballyUniqueIdentifierName(name: string | null): ValidatedIdentifier;
+    outlineFunction(fn: HIRFunction, type: ReactFunctionType | null): void;
+    getOutlinedFunctions(): Array<{
+        fn: HIRFunction;
+        type: ReactFunctionType | null;
+    }>;
+    getGlobalDeclaration(binding: NonLocalBinding, loc: SourceLocation): Global | null;
+    static knownReactModules: ReadonlyArray<string>;
+    getFallthroughPropertyType(receiver: Type, _property: Type): BuiltInType | PolyType | null;
+    getPropertyType(receiver: Type, property: string | number): BuiltInType | PolyType | null;
+    getFunctionSignature(type: FunctionType): FunctionSignature | null;
+    addHoistedIdentifier(node: t.Identifier): void;
+}
+declare function validateEnvironmentConfig(partialConfig: PartialEnvironmentConfig): EnvironmentConfig;
+
+declare const GeneratedSource: unique symbol;
+type SourceLocation = t.SourceLocation | typeof GeneratedSource;
+type ReactiveFunction = {
+    loc: SourceLocation;
+    id: ValidIdentifierName | null;
+    nameHint: string | null;
+    params: Array<Place | SpreadPattern>;
+    generator: boolean;
+    async: boolean;
+    body: ReactiveBlock;
+    env: Environment;
+    directives: Array<string>;
+};
+type ReactiveScopeBlock = {
+    kind: 'scope';
+    scope: ReactiveScope;
+    instructions: ReactiveBlock;
+};
+type PrunedReactiveScopeBlock = {
+    kind: 'pruned-scope';
+    scope: ReactiveScope;
+    instructions: ReactiveBlock;
+};
+type ReactiveBlock = Array<ReactiveStatement>;
+type ReactiveStatement = ReactiveInstructionStatement | ReactiveTerminalStatement | ReactiveScopeBlock | PrunedReactiveScopeBlock;
+type ReactiveInstructionStatement = {
+    kind: 'instruction';
+    instruction: ReactiveInstruction;
+};
+type ReactiveTerminalStatement<Tterminal extends ReactiveTerminal = ReactiveTerminal> = {
+    kind: 'terminal';
+    terminal: Tterminal;
+    label: {
+        id: BlockId;
+        implicit: boolean;
+    } | null;
+};
+type ReactiveInstruction = {
+    id: InstructionId;
+    lvalue: Place | null;
+    value: ReactiveValue;
+    effects?: Array<AliasingEffect> | null;
+    loc: SourceLocation;
+};
+type ReactiveValue = InstructionValue | ReactiveLogicalValue | ReactiveSequenceValue | ReactiveTernaryValue | ReactiveOptionalCallValue;
+type ReactiveLogicalValue = {
+    kind: 'LogicalExpression';
+    operator: t.LogicalExpression['operator'];
+    left: ReactiveValue;
+    right: ReactiveValue;
+    loc: SourceLocation;
+};
+type ReactiveTernaryValue = {
+    kind: 'ConditionalExpression';
+    test: ReactiveValue;
+    consequent: ReactiveValue;
+    alternate: ReactiveValue;
+    loc: SourceLocation;
+};
+type ReactiveSequenceValue = {
+    kind: 'SequenceExpression';
+    instructions: Array<ReactiveInstruction>;
+    id: InstructionId;
+    value: ReactiveValue;
+    loc: SourceLocation;
+};
+type ReactiveOptionalCallValue = {
+    kind: 'OptionalExpression';
+    id: InstructionId;
+    value: ReactiveValue;
+    optional: boolean;
+    loc: SourceLocation;
+};
+type ReactiveTerminal = ReactiveBreakTerminal | ReactiveContinueTerminal | ReactiveReturnTerminal | ReactiveThrowTerminal | ReactiveSwitchTerminal | ReactiveDoWhileTerminal | ReactiveWhileTerminal | ReactiveForTerminal | ReactiveForOfTerminal | ReactiveForInTerminal | ReactiveIfTerminal | ReactiveLabelTerminal | ReactiveTryTerminal;
+type ReactiveTerminalTargetKind = 'implicit' | 'labeled' | 'unlabeled';
+type ReactiveBreakTerminal = {
+    kind: 'break';
+    target: BlockId;
+    id: InstructionId;
+    targetKind: ReactiveTerminalTargetKind;
+    loc: SourceLocation;
+};
+type ReactiveContinueTerminal = {
+    kind: 'continue';
+    target: BlockId;
+    id: InstructionId;
+    targetKind: ReactiveTerminalTargetKind;
+    loc: SourceLocation;
+};
+type ReactiveReturnTerminal = {
+    kind: 'return';
+    value: Place;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type ReactiveThrowTerminal = {
+    kind: 'throw';
+    value: Place;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type ReactiveSwitchTerminal = {
+    kind: 'switch';
+    test: Place;
+    cases: Array<{
+        test: Place | null;
+        block: ReactiveBlock | void;
+    }>;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type ReactiveDoWhileTerminal = {
+    kind: 'do-while';
+    loop: ReactiveBlock;
+    test: ReactiveValue;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type ReactiveWhileTerminal = {
+    kind: 'while';
+    test: ReactiveValue;
+    loop: ReactiveBlock;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type ReactiveForTerminal = {
+    kind: 'for';
+    init: ReactiveValue;
+    test: ReactiveValue;
+    update: ReactiveValue | null;
+    loop: ReactiveBlock;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type ReactiveForOfTerminal = {
+    kind: 'for-of';
+    init: ReactiveValue;
+    test: ReactiveValue;
+    loop: ReactiveBlock;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type ReactiveForInTerminal = {
+    kind: 'for-in';
+    init: ReactiveValue;
+    loop: ReactiveBlock;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type ReactiveIfTerminal = {
+    kind: 'if';
+    test: Place;
+    consequent: ReactiveBlock;
+    alternate: ReactiveBlock | null;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type ReactiveLabelTerminal = {
+    kind: 'label';
+    block: ReactiveBlock;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type ReactiveTryTerminal = {
+    kind: 'try';
+    block: ReactiveBlock;
+    handlerBinding: Place | null;
+    handler: ReactiveBlock;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type HIRFunction = {
+    loc: SourceLocation;
+    id: ValidIdentifierName | null;
+    nameHint: string | null;
+    fnType: ReactFunctionType;
+    env: Environment;
+    params: Array<Place | SpreadPattern>;
+    returnTypeAnnotation: t.FlowType | t.TSType | null;
+    returns: Place;
+    context: Array<Place>;
+    body: HIR;
+    generator: boolean;
+    async: boolean;
+    directives: Array<string>;
+    aliasingEffects: Array<AliasingEffect> | null;
+};
+type HIR = {
+    entry: BlockId;
+    blocks: Map<BlockId, BasicBlock>;
+};
+type BlockKind = 'block' | 'value' | 'loop' | 'sequence' | 'catch';
+type BasicBlock = {
+    kind: BlockKind;
+    id: BlockId;
+    instructions: Array<Instruction>;
+    terminal: Terminal;
+    preds: Set<BlockId>;
+    phis: Set<Phi>;
+};
+type Terminal = UnsupportedTerminal | UnreachableTerminal | ThrowTerminal | ReturnTerminal | GotoTerminal | IfTerminal | BranchTerminal | SwitchTerminal | ForTerminal | ForOfTerminal | ForInTerminal | DoWhileTerminal | WhileTerminal | LogicalTerminal | TernaryTerminal | OptionalTerminal | LabelTerminal | SequenceTerminal | MaybeThrowTerminal | TryTerminal | ReactiveScopeTerminal | PrunedScopeTerminal;
+type UnsupportedTerminal = {
+    kind: 'unsupported';
+    id: InstructionId;
+    loc: SourceLocation;
+    fallthrough?: never;
+};
+type UnreachableTerminal = {
+    kind: 'unreachable';
+    id: InstructionId;
+    loc: SourceLocation;
+    fallthrough?: never;
+};
+type ThrowTerminal = {
+    kind: 'throw';
+    value: Place;
+    id: InstructionId;
+    loc: SourceLocation;
+    fallthrough?: never;
+};
+type Case = {
+    test: Place | null;
+    block: BlockId;
+};
+type ReturnVariant = 'Void' | 'Implicit' | 'Explicit';
+type ReturnTerminal = {
+    kind: 'return';
+    returnVariant: ReturnVariant;
+    loc: SourceLocation;
+    value: Place;
+    id: InstructionId;
+    fallthrough?: never;
+    effects: Array<AliasingEffect> | null;
+};
+type GotoTerminal = {
+    kind: 'goto';
+    block: BlockId;
+    variant: GotoVariant;
+    id: InstructionId;
+    loc: SourceLocation;
+    fallthrough?: never;
+};
+declare enum GotoVariant {
+    Break = "Break",
+    Continue = "Continue",
+    Try = "Try"
+}
+type IfTerminal = {
+    kind: 'if';
+    test: Place;
+    consequent: BlockId;
+    alternate: BlockId;
+    fallthrough: BlockId;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type BranchTerminal = {
+    kind: 'branch';
+    test: Place;
+    consequent: BlockId;
+    alternate: BlockId;
+    id: InstructionId;
+    loc: SourceLocation;
+    fallthrough: BlockId;
+};
+type SwitchTerminal = {
+    kind: 'switch';
+    test: Place;
+    cases: Array<Case>;
+    fallthrough: BlockId;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type DoWhileTerminal = {
+    kind: 'do-while';
+    loop: BlockId;
+    test: BlockId;
+    fallthrough: BlockId;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type WhileTerminal = {
+    kind: 'while';
+    loc: SourceLocation;
+    test: BlockId;
+    loop: BlockId;
+    fallthrough: BlockId;
+    id: InstructionId;
+};
+type ForTerminal = {
+    kind: 'for';
+    loc: SourceLocation;
+    init: BlockId;
+    test: BlockId;
+    update: BlockId | null;
+    loop: BlockId;
+    fallthrough: BlockId;
+    id: InstructionId;
+};
+type ForOfTerminal = {
+    kind: 'for-of';
+    loc: SourceLocation;
+    init: BlockId;
+    test: BlockId;
+    loop: BlockId;
+    fallthrough: BlockId;
+    id: InstructionId;
+};
+type ForInTerminal = {
+    kind: 'for-in';
+    loc: SourceLocation;
+    init: BlockId;
+    loop: BlockId;
+    fallthrough: BlockId;
+    id: InstructionId;
+};
+type LogicalTerminal = {
+    kind: 'logical';
+    operator: t.LogicalExpression['operator'];
+    test: BlockId;
+    fallthrough: BlockId;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type TernaryTerminal = {
+    kind: 'ternary';
+    test: BlockId;
+    fallthrough: BlockId;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type LabelTerminal = {
+    kind: 'label';
+    block: BlockId;
+    fallthrough: BlockId;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type OptionalTerminal = {
+    kind: 'optional';
+    optional: boolean;
+    test: BlockId;
+    fallthrough: BlockId;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type SequenceTerminal = {
+    kind: 'sequence';
+    block: BlockId;
+    fallthrough: BlockId;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type TryTerminal = {
+    kind: 'try';
+    block: BlockId;
+    handlerBinding: Place | null;
+    handler: BlockId;
+    fallthrough: BlockId;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type MaybeThrowTerminal = {
+    kind: 'maybe-throw';
+    continuation: BlockId;
+    handler: BlockId;
+    id: InstructionId;
+    loc: SourceLocation;
+    fallthrough?: never;
+    effects: Array<AliasingEffect> | null;
+};
+type ReactiveScopeTerminal = {
+    kind: 'scope';
+    fallthrough: BlockId;
+    block: BlockId;
+    scope: ReactiveScope;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type PrunedScopeTerminal = {
+    kind: 'pruned-scope';
+    fallthrough: BlockId;
+    block: BlockId;
+    scope: ReactiveScope;
+    id: InstructionId;
+    loc: SourceLocation;
+};
+type Instruction = {
+    id: InstructionId;
+    lvalue: Place;
+    value: InstructionValue;
+    loc: SourceLocation;
+    effects: Array<AliasingEffect> | null;
+};
+type LValue = {
+    place: Place;
+    kind: InstructionKind;
+};
+type LValuePattern = {
+    pattern: Pattern;
+    kind: InstructionKind;
+};
+type ArrayExpression = {
+    kind: 'ArrayExpression';
+    elements: Array<Place | SpreadPattern | Hole>;
+    loc: SourceLocation;
+};
+type Pattern = ArrayPattern | ObjectPattern;
+type Hole = {
+    kind: 'Hole';
+};
+type SpreadPattern = {
+    kind: 'Spread';
+    place: Place;
+};
+type ArrayPattern = {
+    kind: 'ArrayPattern';
+    items: Array<Place | SpreadPattern | Hole>;
+};
+type ObjectPattern = {
+    kind: 'ObjectPattern';
+    properties: Array<ObjectProperty | SpreadPattern>;
+};
+type ObjectPropertyKey = {
+    kind: 'string';
+    name: string;
+} | {
+    kind: 'identifier';
+    name: string;
+} | {
+    kind: 'computed';
+    name: Place;
+} | {
+    kind: 'number';
+    name: number;
+};
+type ObjectProperty = {
+    kind: 'ObjectProperty';
+    key: ObjectPropertyKey;
+    type: 'property' | 'method';
+    place: Place;
+};
+type LoweredFunction = {
+    func: HIRFunction;
+};
+type ObjectMethod = {
+    kind: 'ObjectMethod';
+    loc: SourceLocation;
+    loweredFunc: LoweredFunction;
+};
+declare enum InstructionKind {
+    Const = "Const",
+    Let = "Let",
+    Reassign = "Reassign",
+    Catch = "Catch",
+    HoistedConst = "HoistedConst",
+    HoistedLet = "HoistedLet",
+    HoistedFunction = "HoistedFunction",
+    Function = "Function"
+}
+type Phi = {
+    kind: 'Phi';
+    place: Place;
+    operands: Map<BlockId, Place>;
+};
+type ManualMemoDependency = {
+    root: {
+        kind: 'NamedLocal';
+        value: Place;
+    } | {
+        kind: 'Global';
+        identifierName: string;
+    };
+    path: DependencyPath;
+};
+type StartMemoize = {
+    kind: 'StartMemoize';
+    manualMemoId: number;
+    deps: Array<ManualMemoDependency> | null;
+    loc: SourceLocation;
+};
+type FinishMemoize = {
+    kind: 'FinishMemoize';
+    manualMemoId: number;
+    decl: Place;
+    pruned?: true;
+    loc: SourceLocation;
+};
+type MethodCall = {
+    kind: 'MethodCall';
+    receiver: Place;
+    property: Place;
+    args: Array<Place | SpreadPattern>;
+    loc: SourceLocation;
+};
+type CallExpression = {
+    kind: 'CallExpression';
+    callee: Place;
+    args: Array<Place | SpreadPattern>;
+    loc: SourceLocation;
+    typeArguments?: Array<t.FlowType>;
+};
+type NewExpression = {
+    kind: 'NewExpression';
+    callee: Place;
+    args: Array<Place | SpreadPattern>;
+    loc: SourceLocation;
+};
+type LoadLocal = {
+    kind: 'LoadLocal';
+    place: Place;
+    loc: SourceLocation;
+};
+type LoadContext = {
+    kind: 'LoadContext';
+    place: Place;
+    loc: SourceLocation;
+};
+type InstructionValue = LoadLocal | LoadContext | {
+    kind: 'DeclareLocal';
+    lvalue: LValue;
+    type: t.FlowType | t.TSType | null;
+    loc: SourceLocation;
+} | {
+    kind: 'DeclareContext';
+    lvalue: {
+        kind: InstructionKind.Let | InstructionKind.HoistedConst | InstructionKind.HoistedLet | InstructionKind.HoistedFunction;
+        place: Place;
+    };
+    loc: SourceLocation;
+} | StoreLocal | {
+    kind: 'StoreContext';
+    lvalue: {
+        kind: InstructionKind.Reassign | InstructionKind.Const | InstructionKind.Let | InstructionKind.Function;
+        place: Place;
+    };
+    value: Place;
+    loc: SourceLocation;
+} | Destructure | {
+    kind: 'Primitive';
+    value: number | boolean | string | null | undefined;
+    loc: SourceLocation;
+} | JSXText | {
+    kind: 'BinaryExpression';
+    operator: Exclude<t.BinaryExpression['operator'], '|>'>;
+    left: Place;
+    right: Place;
+    loc: SourceLocation;
+} | NewExpression | CallExpression | MethodCall | {
+    kind: 'UnaryExpression';
+    operator: Exclude<t.UnaryExpression['operator'], 'throw' | 'delete'>;
+    value: Place;
+    loc: SourceLocation;
+} | ({
+    kind: 'TypeCastExpression';
+    value: Place;
+    type: Type;
+    loc: SourceLocation;
+} & ({
+    typeAnnotation: t.FlowType;
+    typeAnnotationKind: 'cast';
+} | {
+    typeAnnotation: t.TSType;
+    typeAnnotationKind: 'as' | 'satisfies';
+})) | JsxExpression | {
+    kind: 'ObjectExpression';
+    properties: Array<ObjectProperty | SpreadPattern>;
+    loc: SourceLocation;
+} | ObjectMethod | ArrayExpression | {
+    kind: 'JsxFragment';
+    children: Array<Place>;
+    loc: SourceLocation;
+} | {
+    kind: 'RegExpLiteral';
+    pattern: string;
+    flags: string;
+    loc: SourceLocation;
+} | {
+    kind: 'MetaProperty';
+    meta: string;
+    property: string;
+    loc: SourceLocation;
+} | {
+    kind: 'PropertyStore';
+    object: Place;
+    property: PropertyLiteral;
+    value: Place;
+    loc: SourceLocation;
+} | PropertyLoad | {
+    kind: 'PropertyDelete';
+    object: Place;
+    property: PropertyLiteral;
+    loc: SourceLocation;
+} | {
+    kind: 'ComputedStore';
+    object: Place;
+    property: Place;
+    value: Place;
+    loc: SourceLocation;
+} | {
+    kind: 'ComputedLoad';
+    object: Place;
+    property: Place;
+    loc: SourceLocation;
+} | {
+    kind: 'ComputedDelete';
+    object: Place;
+    property: Place;
+    loc: SourceLocation;
+} | LoadGlobal | StoreGlobal | FunctionExpression | {
+    kind: 'TaggedTemplateExpression';
+    tag: Place;
+    value: {
+        raw: string;
+        cooked?: string;
+    };
+    loc: SourceLocation;
+} | {
+    kind: 'TemplateLiteral';
+    subexprs: Array<Place>;
+    quasis: Array<{
+        raw: string;
+        cooked?: string;
+    }>;
+    loc: SourceLocation;
+} | {
+    kind: 'Await';
+    value: Place;
+    loc: SourceLocation;
+} | {
+    kind: 'GetIterator';
+    collection: Place;
+    loc: SourceLocation;
+} | {
+    kind: 'IteratorNext';
+    iterator: Place;
+    collection: Place;
+    loc: SourceLocation;
+} | {
+    kind: 'NextPropertyOf';
+    value: Place;
+    loc: SourceLocation;
+} | {
+    kind: 'PrefixUpdate';
+    lvalue: Place;
+    operation: t.UpdateExpression['operator'];
+    value: Place;
+    loc: SourceLocation;
+} | {
+    kind: 'PostfixUpdate';
+    lvalue: Place;
+    operation: t.UpdateExpression['operator'];
+    value: Place;
+    loc: SourceLocation;
+} | {
+    kind: 'Debugger';
+    loc: SourceLocation;
+} | StartMemoize | FinishMemoize | {
+    kind: 'UnsupportedNode';
+    node: t.Node;
+    loc: SourceLocation;
+};
+type JsxExpression = {
+    kind: 'JsxExpression';
+    tag: Place | BuiltinTag;
+    props: Array<JsxAttribute>;
+    children: Array<Place> | null;
+    loc: SourceLocation;
+    openingLoc: SourceLocation;
+    closingLoc: SourceLocation;
+};
+type JsxAttribute = {
+    kind: 'JsxSpreadAttribute';
+    argument: Place;
+} | {
+    kind: 'JsxAttribute';
+    name: string;
+    place: Place;
+};
+type FunctionExpression = {
+    kind: 'FunctionExpression';
+    name: ValidIdentifierName | null;
+    nameHint: string | null;
+    loweredFunc: LoweredFunction;
+    type: 'ArrowFunctionExpression' | 'FunctionExpression' | 'FunctionDeclaration';
+    loc: SourceLocation;
+};
+type Destructure = {
+    kind: 'Destructure';
+    lvalue: LValuePattern;
+    value: Place;
+    loc: SourceLocation;
+};
+type Place = {
+    kind: 'Identifier';
+    identifier: Identifier;
+    effect: Effect;
+    reactive: boolean;
+    loc: SourceLocation;
+};
+type JSXText = {
+    kind: 'JSXText';
+    value: string;
+    loc: SourceLocation;
+};
+type StoreLocal = {
+    kind: 'StoreLocal';
+    lvalue: LValue;
+    value: Place;
+    type: t.FlowType | t.TSType | null;
+    loc: SourceLocation;
+};
+type PropertyLoad = {
+    kind: 'PropertyLoad';
+    object: Place;
+    property: PropertyLiteral;
+    loc: SourceLocation;
+};
+type LoadGlobal = {
+    kind: 'LoadGlobal';
+    binding: NonLocalBinding;
+    loc: SourceLocation;
+};
+type StoreGlobal = {
+    kind: 'StoreGlobal';
+    name: string;
+    value: Place;
+    loc: SourceLocation;
+};
+type BuiltinTag = {
+    kind: 'BuiltinTag';
+    name: string;
+    loc: SourceLocation;
+};
+type MutableRange = {
+    start: InstructionId;
+    end: InstructionId;
+};
+type NonLocalImportSpecifier = {
+    kind: 'ImportSpecifier';
+    name: string;
+    module: string;
+    imported: string;
+};
+type NonLocalBinding = {
+    kind: 'ImportDefault';
+    name: string;
+    module: string;
+} | {
+    kind: 'ImportNamespace';
+    name: string;
+    module: string;
+} | NonLocalImportSpecifier | {
+    kind: 'ModuleLocal';
+    name: string;
+} | {
+    kind: 'Global';
+    name: string;
+};
+type Identifier = {
+    id: IdentifierId;
+    declarationId: DeclarationId;
+    name: IdentifierName | null;
+    mutableRange: MutableRange;
+    scope: ReactiveScope | null;
+    type: Type;
+    loc: SourceLocation;
+};
+type IdentifierName = ValidatedIdentifier | PromotedIdentifier;
+type ValidatedIdentifier = {
+    kind: 'named';
+    value: ValidIdentifierName;
+};
+type PromotedIdentifier = {
+    kind: 'promoted';
+    value: string;
+};
+declare const opaqueValidIdentifierName: unique symbol;
+type ValidIdentifierName = string & {
+    [opaqueValidIdentifierName]: 'ValidIdentifierName';
+};
+declare enum ValueReason {
+    Global = "global",
+    JsxCaptured = "jsx-captured",
+    HookCaptured = "hook-captured",
+    HookReturn = "hook-return",
+    Effect = "effect",
+    KnownReturnSignature = "known-return-signature",
+    Context = "context",
+    State = "state",
+    ReducerState = "reducer-state",
+    ReactiveFunctionArgument = "reactive-function-argument",
+    Other = "other"
+}
+declare enum ValueKind {
+    MaybeFrozen = "maybefrozen",
+    Frozen = "frozen",
+    Primitive = "primitive",
+    Global = "global",
+    Mutable = "mutable",
+    Context = "context"
+}
+declare enum Effect {
+    Unknown = "<unknown>",
+    Freeze = "freeze",
+    Read = "read",
+    Capture = "capture",
+    ConditionallyMutateIterator = "mutate-iterator?",
+    ConditionallyMutate = "mutate?",
+    Mutate = "mutate",
+    Store = "store"
+}
+type ReactiveScope = {
+    id: ScopeId;
+    range: MutableRange;
+    dependencies: ReactiveScopeDependencies;
+    declarations: Map<IdentifierId, ReactiveScopeDeclaration>;
+    reassignments: Set<Identifier>;
+    earlyReturnValue: {
+        value: Identifier;
+        loc: SourceLocation;
+        label: BlockId;
+    } | null;
+    merged: Set<ScopeId>;
+    loc: SourceLocation;
+};
+type ReactiveScopeDependencies = Set<ReactiveScopeDependency>;
+type ReactiveScopeDeclaration = {
+    identifier: Identifier;
+    scope: ReactiveScope;
+};
+declare const opaquePropertyLiteral: unique symbol;
+type PropertyLiteral = (string | number) & {
+    [opaquePropertyLiteral]: 'PropertyLiteral';
+};
+type DependencyPathEntry = {
+    property: PropertyLiteral;
+    optional: boolean;
+};
+type DependencyPath = Array<DependencyPathEntry>;
+type ReactiveScopeDependency = {
+    identifier: Identifier;
+    reactive: boolean;
+    path: DependencyPath;
+};
+declare const opaqueBlockId: unique symbol;
+type BlockId = number & {
+    [opaqueBlockId]: 'BlockId';
+};
+declare const opaqueScopeId: unique symbol;
+type ScopeId = number & {
+    [opaqueScopeId]: 'ScopeId';
+};
+declare const opaqueIdentifierId: unique symbol;
+type IdentifierId = number & {
+    [opaqueIdentifierId]: 'IdentifierId';
+};
+declare const opageDeclarationId: unique symbol;
+type DeclarationId = number & {
+    [opageDeclarationId]: 'DeclarationId';
+};
+declare const opaqueInstructionId: unique symbol;
+type InstructionId = number & {
+    [opaqueInstructionId]: 'IdentifierId';
+};
+
+type Options = {
+    indent: number;
+};
+declare function printFunctionWithOutlined(fn: HIRFunction): string;
+declare function printHIR(ir: HIR, options?: Options | null): string;
+
+declare enum ErrorSeverity {
+    Error = "Error",
+    Warning = "Warning",
+    Hint = "Hint",
+    Off = "Off"
+}
+type CompilerDiagnosticOptions = {
+    category: ErrorCategory;
+    reason: string;
+    description: string | null;
+    details: Array<CompilerDiagnosticDetail>;
+    suggestions?: Array<CompilerSuggestion> | null | undefined;
+};
+type CompilerDiagnosticDetail = {
+    kind: 'error';
+    loc: SourceLocation | null;
+    message: string | null;
+} | {
+    kind: 'hint';
+    message: string;
+};
+declare enum CompilerSuggestionOperation {
+    InsertBefore = 0,
+    InsertAfter = 1,
+    Remove = 2,
+    Replace = 3
+}
+type CompilerSuggestion = {
+    op: CompilerSuggestionOperation.InsertAfter | CompilerSuggestionOperation.InsertBefore | CompilerSuggestionOperation.Replace;
+    range: [number, number];
+    description: string;
+    text: string;
+} | {
+    op: CompilerSuggestionOperation.Remove;
+    range: [number, number];
+    description: string;
+};
+type CompilerErrorDetailOptions = {
+    category: ErrorCategory;
+    reason: string;
+    description?: string | null | undefined;
+    loc: SourceLocation | null;
+    suggestions?: Array<CompilerSuggestion> | null | undefined;
+};
+type PrintErrorMessageOptions = {
+    eslint: boolean;
+};
+declare class CompilerDiagnostic {
+    options: CompilerDiagnosticOptions;
+    constructor(options: CompilerDiagnosticOptions);
+    static create(options: Omit<CompilerDiagnosticOptions, 'details'>): CompilerDiagnostic;
+    get reason(): CompilerDiagnosticOptions['reason'];
+    get description(): CompilerDiagnosticOptions['description'];
+    get severity(): ErrorSeverity;
+    get suggestions(): CompilerDiagnosticOptions['suggestions'];
+    get category(): ErrorCategory;
+    withDetails(...details: Array<CompilerDiagnosticDetail>): CompilerDiagnostic;
+    primaryLocation(): SourceLocation | null;
+    printErrorMessage(source: string, options: PrintErrorMessageOptions): string;
+    toString(): string;
+}
+declare class CompilerErrorDetail {
+    options: CompilerErrorDetailOptions;
+    constructor(options: CompilerErrorDetailOptions);
+    get reason(): CompilerErrorDetailOptions['reason'];
+    get description(): CompilerErrorDetailOptions['description'];
+    get severity(): ErrorSeverity;
+    get loc(): CompilerErrorDetailOptions['loc'];
+    get suggestions(): CompilerErrorDetailOptions['suggestions'];
+    get category(): ErrorCategory;
+    primaryLocation(): SourceLocation | null;
+    printErrorMessage(source: string, options: PrintErrorMessageOptions): string;
+    toString(): string;
+}
+declare class CompilerError extends Error {
+    details: Array<CompilerErrorDetail | CompilerDiagnostic>;
+    disabledDetails: Array<CompilerErrorDetail | CompilerDiagnostic>;
+    printedMessage: string | null;
+    static invariant(condition: unknown, options: Omit<CompilerDiagnosticOptions, 'category'>): asserts condition;
+    static throwDiagnostic(options: CompilerDiagnosticOptions): never;
+    static throwTodo(options: Omit<CompilerErrorDetailOptions, 'category'>): never;
+    static throwInvalidJS(options: Omit<CompilerErrorDetailOptions, 'category'>): never;
+    static throwInvalidReact(options: CompilerErrorDetailOptions): never;
+    static throwInvalidConfig(options: Omit<CompilerErrorDetailOptions, 'category'>): never;
+    static throw(options: CompilerErrorDetailOptions): never;
+    constructor(...args: Array<any>);
+    get message(): string;
+    set message(_message: string);
+    toString(): string;
+    withPrintedMessage(source: string, options: PrintErrorMessageOptions): CompilerError;
+    printErrorMessage(source: string, options: PrintErrorMessageOptions): string;
+    merge(other: CompilerError): void;
+    pushDiagnostic(diagnostic: CompilerDiagnostic): void;
+    push(options: CompilerErrorDetailOptions): CompilerErrorDetail;
+    pushErrorDetail(detail: CompilerErrorDetail): CompilerErrorDetail;
+    hasAnyErrors(): boolean;
+    asResult(): Result<void, CompilerError>;
+    hasErrors(): boolean;
+    hasWarning(): boolean;
+    hasHints(): boolean;
+}
+declare enum ErrorCategory {
+    Hooks = "Hooks",
+    CapitalizedCalls = "CapitalizedCalls",
+    StaticComponents = "StaticComponents",
+    UseMemo = "UseMemo",
+    Factories = "Factories",
+    PreserveManualMemo = "PreserveManualMemo",
+    IncompatibleLibrary = "IncompatibleLibrary",
+    Immutability = "Immutability",
+    Globals = "Globals",
+    Refs = "Refs",
+    EffectDependencies = "EffectDependencies",
+    EffectSetState = "EffectSetState",
+    EffectDerivationsOfState = "EffectDerivationsOfState",
+    ErrorBoundaries = "ErrorBoundaries",
+    Purity = "Purity",
+    RenderSetState = "RenderSetState",
+    Invariant = "Invariant",
+    Todo = "Todo",
+    Syntax = "Syntax",
+    UnsupportedSyntax = "UnsupportedSyntax",
+    Config = "Config",
+    Gating = "Gating",
+    Suppression = "Suppression",
+    AutomaticEffectDependencies = "AutomaticEffectDependencies",
+    Fire = "Fire",
+    FBT = "FBT"
+}
+type LintRule = {
+    category: ErrorCategory;
+    severity: ErrorSeverity;
+    name: string;
+    description: string;
+    recommended: boolean;
+};
+declare const LintRules: Array<LintRule>;
+
+type CodegenFunction = {
+    type: 'CodegenFunction';
+    id: t.Identifier | null;
+    nameHint: string | null;
+    params: t.FunctionDeclaration['params'];
+    body: t.BlockStatement;
+    generator: boolean;
+    async: boolean;
+    loc: SourceLocation;
+    memoSlotsUsed: number;
+    memoBlocks: number;
+    memoValues: number;
+    prunedMemoBlocks: number;
+    prunedMemoValues: number;
+    outlined: Array<{
+        fn: CodegenFunction;
+        type: ReactFunctionType | null;
+    }>;
+    hasInferredEffect: boolean;
+    inferredEffectLocations: Set<SourceLocation>;
+    hasFireRewrite: boolean;
+};
+
+declare function printReactiveFunctionWithOutlined(fn: ReactiveFunction): string;
+declare function printReactiveFunction(fn: ReactiveFunction): string;
+
+type CompilerPipelineValue = {
+    kind: 'ast';
+    name: string;
+    value: CodegenFunction;
+} | {
+    kind: 'hir';
+    name: string;
+    value: HIRFunction;
+} | {
+    kind: 'reactive';
+    name: string;
+    value: ReactiveFunction;
+} | {
+    kind: 'debug';
+    name: string;
+    value: string;
+};
+declare function compileFn(func: NodePath<t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression>, config: EnvironmentConfig, fnType: ReactFunctionType, mode: CompilerMode, programContext: ProgramContext, logger: Logger | null, filename: string | null, code: string | null): CodegenFunction;
+
+declare const PanicThresholdOptionsSchema: z.ZodEnum<{
+    none: "none";
+    all_errors: "all_errors";
+    critical_errors: "critical_errors";
+}>;
+type PanicThresholdOptions = z.infer<typeof PanicThresholdOptionsSchema>;
+declare const DynamicGatingOptionsSchema: z.ZodObject<{
+    source: z.ZodString;
+}, z.core.$strip>;
+type DynamicGatingOptions = z.infer<typeof DynamicGatingOptionsSchema>;
+declare const CustomOptOutDirectiveSchema: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+type CustomOptOutDirective = z.infer<typeof CustomOptOutDirectiveSchema>;
+type PluginOptions = Partial<{
+    environment: Partial<EnvironmentConfig>;
+    logger: Logger | null;
+    gating: ExternalFunction | null;
+    dynamicGating: DynamicGatingOptions | null;
+    panicThreshold: PanicThresholdOptions;
+    noEmit: boolean;
+    compilationMode: CompilationMode;
+    eslintSuppressionRules: Array<string> | null | undefined;
+    flowSuppressions: boolean;
+    ignoreUseNoForget: boolean;
+    customOptOutDirectives: CustomOptOutDirective;
+    sources: Array<string> | ((filename: string) => boolean) | null;
+    enableReanimatedCheck: boolean;
+    target: CompilerReactTarget;
+}>;
+type ParsedPluginOptions = Required<Omit<PluginOptions, 'environment'>> & {
+    environment: EnvironmentConfig;
+};
+declare const CompilerReactTargetSchema: z.ZodUnion<readonly [z.ZodLiteral<"17">, z.ZodLiteral<"18">, z.ZodLiteral<"19">, z.ZodObject<{
+    kind: z.ZodLiteral<"donotuse_meta_internal">;
+    runtimeModule: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>]>;
+type CompilerReactTarget = z.infer<typeof CompilerReactTargetSchema>;
+declare const CompilationModeSchema: z.ZodEnum<{
+    syntax: "syntax";
+    infer: "infer";
+    annotation: "annotation";
+    all: "all";
+}>;
+type CompilationMode = z.infer<typeof CompilationModeSchema>;
+type LoggerEvent = CompileSuccessEvent | CompileErrorEvent | CompileDiagnosticEvent | CompileSkipEvent | PipelineErrorEvent | TimingEvent | AutoDepsDecorationsEvent | AutoDepsEligibleEvent;
+type CompileErrorEvent = {
+    kind: 'CompileError';
+    fnLoc: t.SourceLocation | null;
+    detail: CompilerErrorDetail | CompilerDiagnostic;
+};
+type CompileDiagnosticEvent = {
+    kind: 'CompileDiagnostic';
+    fnLoc: t.SourceLocation | null;
+    detail: Omit<Omit<CompilerErrorDetailOptions, 'severity'>, 'suggestions'>;
+};
+type CompileSuccessEvent = {
+    kind: 'CompileSuccess';
+    fnLoc: t.SourceLocation | null;
+    fnName: string | null;
+    memoSlots: number;
+    memoBlocks: number;
+    memoValues: number;
+    prunedMemoBlocks: number;
+    prunedMemoValues: number;
+};
+type CompileSkipEvent = {
+    kind: 'CompileSkip';
+    fnLoc: t.SourceLocation | null;
+    reason: string;
+    loc: t.SourceLocation | null;
+};
+type PipelineErrorEvent = {
+    kind: 'PipelineError';
+    fnLoc: t.SourceLocation | null;
+    data: string;
+};
+type TimingEvent = {
+    kind: 'Timing';
+    measurement: PerformanceMeasure;
+};
+type AutoDepsDecorationsEvent = {
+    kind: 'AutoDepsDecorations';
+    fnLoc: t.SourceLocation;
+    decorations: Array<t.SourceLocation>;
+};
+type AutoDepsEligibleEvent = {
+    kind: 'AutoDepsEligible';
+    fnLoc: t.SourceLocation;
+    depArrayLoc: t.SourceLocation;
+};
+type Logger = {
+    logEvent: (filename: string | null, event: LoggerEvent) => void;
+    debugLogIRs?: (value: CompilerPipelineValue) => void;
+};
+declare function parsePluginOptions(obj: unknown): ParsedPluginOptions;
+
+type CompilerPass = {
+    opts: ParsedPluginOptions;
+    filename: string | null;
+    comments: Array<t.CommentBlock | t.CommentLine>;
+    code: string | null;
+};
+declare const OPT_IN_DIRECTIVES: Set<string>;
+declare const OPT_OUT_DIRECTIVES: Set<string>;
+declare function tryFindDirectiveEnablingMemoization(directives: Array<t.Directive>, opts: ParsedPluginOptions): Result<t.Directive | null, CompilerError>;
+declare function findDirectiveDisablingMemoization(directives: Array<t.Directive>, { customOptOutDirectives }: PluginOptions): t.Directive | null;
+type BabelFn = NodePath$1<t.FunctionDeclaration> | NodePath$1<t.FunctionExpression> | NodePath$1<t.ArrowFunctionExpression>;
+type CompileProgramMetadata = {
+    retryErrors: Array<{
+        fn: BabelFn;
+        error: CompilerError;
+    }>;
+    inferredEffectLocations: Set<t.SourceLocation>;
+};
+declare function compileProgram(program: NodePath$1<t.Program>, pass: CompilerPass): CompileProgramMetadata | null;
+
+type SuppressionRange = {
+    disableComment: t.Comment;
+    enableComment: t.Comment | null;
+    source: SuppressionSource;
+};
+type SuppressionSource = 'Eslint' | 'Flow';
+
+type ProgramContextOptions = {
+    program: NodePath$1<t.Program>;
+    suppressions: Array<SuppressionRange>;
+    opts: ParsedPluginOptions;
+    filename: string | null;
+    code: string | null;
+    hasModuleScopeOptOut: boolean;
+};
+declare class ProgramContext {
+    scope: Scope;
+    opts: ParsedPluginOptions;
+    filename: string | null;
+    code: string | null;
+    reactRuntimeModule: string;
+    suppressions: Array<SuppressionRange>;
+    hasModuleScopeOptOut: boolean;
+    alreadyCompiled: WeakSet<object> | Set<object>;
+    knownReferencedNames: Set<string>;
+    imports: Map<string, Map<string, NonLocalImportSpecifier>>;
+    retryErrors: Array<{
+        fn: BabelFn;
+        error: CompilerError;
+    }>;
+    inferredEffectLocations: Set<t.SourceLocation>;
+    constructor({ program, suppressions, opts, filename, code, hasModuleScopeOptOut, }: ProgramContextOptions);
+    isHookName(name: string): boolean;
+    hasReference(name: string): boolean;
+    newUid(name: string): string;
+    addMemoCacheImport(): NonLocalImportSpecifier;
+    addImportSpecifier({ source: module, importSpecifierName: specifier }: ExternalFunction, nameHint?: string): NonLocalImportSpecifier;
+    addNewReference(name: string): void;
+    assertGlobalBinding(name: string, localScope?: Scope): Result<void, CompilerError>;
+    logEvent(event: LoggerEvent): void;
+}
+
+declare function runBabelPluginReactCompiler(text: string, file: string, language: 'flow' | 'typescript', options: PluginOptions | null, includeAst?: boolean): BabelCore.BabelFileResult;
+
+declare function parseConfigPragmaForTests(pragma: string, defaults: {
+    compilationMode: CompilationMode;
+    environment?: PartialEnvironmentConfig;
+}): PluginOptions;
+
+declare function BabelPluginReactCompiler(_babel: typeof BabelCore): BabelCore.PluginObj;
+
+declare global {
+}
+
+export { CompilerDiagnostic, type CompilerDiagnosticDetail, type CompilerDiagnosticOptions, CompilerError, CompilerErrorDetail, type CompilerErrorDetailOptions, type CompilerPipelineValue, CompilerSuggestionOperation, Effect, type EnvironmentConfig, ErrorCategory, ErrorSeverity, type ExternalFunction, type Hook, type LintRule, LintRules, type Logger, type LoggerEvent, OPT_IN_DIRECTIVES, OPT_OUT_DIRECTIVES, type PluginOptions, ProgramContext, type SourceLocation, ValueKind, ValueReason, compileFn as compile, compileProgram, BabelPluginReactCompiler as default, findDirectiveDisablingMemoization, tryFindDirectiveEnablingMemoization as findDirectiveEnablingMemoization, parseConfigPragmaForTests, parsePluginOptions, printFunctionWithOutlined, printHIR, printReactiveFunction, printReactiveFunctionWithOutlined, runBabelPluginReactCompiler, validateEnvironmentConfig };