declare module 'reactorjs' {
    /**
    * Type definitions for reactorjs
    * Project: https://github.com/fynyky/reactor.js
    * Definitions by: ChzxxuanzhengFile
    */

    /**
    * A Reactor is an object wrapper that automatically tracks Observer functions
    * that read its properties and notifies the observers when those properties are updated.
    */
    export class Reactor<T extends object = any> {
        /**
        * Creates a new Reactor.
        * @param target - Optional object to wrap with reactive behavior. Changes to the reactor are passed through to the underlying object.
        */
        constructor(target?: T)
    }

    export interface Observer<TArgs extends any[] = [], TReturn = any> {
        /**
        * Executes the observer function and starts tracking dependencies.
        * @param args - Arguments to pass to the observer function.
        * @returns The return value of the observer function.
        */
        (...args: TArgs): TReturn
    }

    /**
    * An Observer is a function wrapper that automatically tracks dependencies on Reactor properties
    * and re-executes when those properties are updated.
    */
    export class Observer<TArgs extends any[] = [], TReturn = any> {
        /**
        * Creates a new Observer.
        * @param fn - The function to wrap with reactive behavior.
        */
        constructor(fn: (...args: TArgs) => TReturn)

        /**
        * The last return value of the observer function.
        * This property is itself observable by other observers.
        */
        readonly value: TReturn

        /**
        * Starts the observer. Re-executes the function and begins tracking dependencies.
        * If already started, subsequent calls have no effect.
        */
        start(): void

        /**
        * Stops the observer. Clears any existing dependencies and prevents triggering.
        */
        stop(): void
    }

    /**
    * Shields a block of code from creating observer dependencies.
    * Any reactor properties read inside the function will not be set as dependencies.
    *
    * @param fn - The function to execute without creating dependencies.
    * @returns The return value of the function.
    *
    * @example
    * ```typescript
    * const taskList = new Reactor(["a", "b", "c", "d"])
    * new Observer(() => {
    *   console.log(hide(() => taskList.pop()))
    * })()
    * ```
    */
    export function hide<T>(fn: () => T): T

    /**
    * Batches multiple reactor updates together and triggers observers only once at the end.
    * This prevents multiple repeated triggering when updating multiple properties.
    *
    * @param fn - The function containing multiple updates to batch.
    * @returns The return value of the function.
    *
    * @example
    * ```typescript
    * const person = new Reactor({ firstName: "John", lastName: "Doe" })
    * batch(() => {
    *   person.firstName = "Jane"
    *   person.lastName = "Smith"
    * }) // Triggers observers only once
    * ```
    */
    export function batch<T>(fn: () => T): T

    /**
    * Removes the Reactor wrapper and returns the underlying base object.
    * This is necessary for native objects or objects with private properties that don't work with proxies.
    *
    * @param reactor - The reactor to unwrap, or the observer to extract the function from.
    * @returns The underlying object or function.
    *
    * @example
    * ```typescript
    * const mapReactor = new Reactor(new Map())
    * Map.prototype.keys.call(shuck(mapReactor)) // works fine
    *
    * const myFunction = () => {}
    * const observer = new Observer(myFunction)
    * myFunction === shuck(observer) // true
    * ```
    */
    export function shuck<T extends object>(reactor: Reactor<T>): T
    export function shuck<TArgs extends any[], TReturn>(
        observer: Observer<TArgs, TReturn>,
    ): (...args: TArgs) => TReturn
    export function shuck(target: any): any

    /**
    * Type helper for creating a reactive version of an object type.
    * Properties of the object become reactive and can trigger observers.
    */
    export type Reactive<T> = T extends object ? Reactor<T> & T : T
}