import { S as Signal, R as ReadonlySignal, a as REACTIVE_MARKER, E as ElementProps, b as EffuseChild, c as ElementNode, B as BlueprintDef, P as Portals, d as PortalFn, e as BlueprintNode, f as EffuseNode, g as EFFUSE_NODE, M as MATCH_MARKER, C as Component, h as BlueprintContext } from './jsx-runtime-dai6OIG_.cjs';
export { i as CreateBlueprintNode, j as CreateElementNode, k as CreateFragmentNode, l as CreateListNode, m as CreateTextNode, F as FRAGMENT, n as Fragment, o as FragmentNode, H as HYDRATION_SCRIPT_ID, L as ListNode, N as NodeType, T as TextNode, p as isEffuseNode, q as jsx, r as jsxDEV, s as jsxs, t as matchEffuseNode } from './jsx-runtime-dai6OIG_.cjs';
import { Schema, SubscriptionRef, Effect, Cause, Scope, Layer, Context, ManagedRuntime } from 'effect';
import * as effect_Types from 'effect/Types';
import * as effect_Cause from 'effect/Cause';
import 'effect/Unify';

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare const EffectOptionsSchema: Schema.Struct<{
    immediate: Schema.optional<typeof Schema.Boolean>;
    retry: Schema.optional<Schema.Struct<{
        times: Schema.optional<typeof Schema.Number>;
        delay: Schema.optional<typeof Schema.Number>;
        strategy: Schema.optional<Schema.Literal<["constant", "exponential"]>>;
    }>>;
    timeout: Schema.optional<typeof Schema.Number>;
    debounce: Schema.optional<Schema.Struct<{
        wait: typeof Schema.Number;
        leading: Schema.optional<typeof Schema.Boolean>;
        trailing: Schema.optional<typeof Schema.Boolean>;
    }>>;
    flush: Schema.optional<Schema.Literal<["sync", "post"]>>;
}>;
type EffectOptions = Schema.Schema.Type<typeof EffectOptionsSchema>;
declare const WatchOptionsSchema: Schema.extend<Schema.Struct<{
    immediate: Schema.optional<typeof Schema.Boolean>;
    retry: Schema.optional<Schema.Struct<{
        times: Schema.optional<typeof Schema.Number>;
        delay: Schema.optional<typeof Schema.Number>;
        strategy: Schema.optional<Schema.Literal<["constant", "exponential"]>>;
    }>>;
    timeout: Schema.optional<typeof Schema.Number>;
    debounce: Schema.optional<Schema.Struct<{
        wait: typeof Schema.Number;
        leading: Schema.optional<typeof Schema.Boolean>;
        trailing: Schema.optional<typeof Schema.Boolean>;
    }>>;
    flush: Schema.optional<Schema.Literal<["sync", "post"]>>;
}>, Schema.Struct<{
    deep: Schema.optional<typeof Schema.Boolean>;
    once: Schema.optional<typeof Schema.Boolean>;
}>>;
type WatchOptions = Schema.Schema.Type<typeof WatchOptionsSchema>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

type CleanupFn$2 = () => void;
type OnCleanup = (cleanupFn: CleanupFn$2) => void;

interface EffectHandle {
    readonly stop: () => void;
    readonly pause: () => void;
    readonly resume: () => void;
}

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
declare class Dep {
    version: number;
    private subscribers;
    track(): void;
    trigger(): void;
    subscribe(callback: () => void): () => void;
    hasSubscribers(): boolean;
    clear(): void;
}

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare function signal<T>(initialValue: T, name?: string): Signal<T>;
declare function readonlySignal<T>(source: Signal<T>): ReadonlySignal<T>;
declare function isSignal<T>(value: unknown): value is Signal<T>;
declare function unref<T>(maybeSignal: T | Signal<T>): T;
declare function getSignalRef<T>(sig: Signal<T>): SubscriptionRef.SubscriptionRef<T> | null;
declare function getSignalDep<T>(sig: Signal<T>): Dep | null;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

type Reactive<T extends object> = T & {
    readonly [REACTIVE_MARKER]: true;
};
declare const reactive: <T extends object>(target: T) => Reactive<T>;
declare const isReactive: (value: unknown) => value is Reactive<object>;
declare const toRaw: <T extends object>(observed: T) => T;
declare const markRaw: <T extends object>(value: T) => T;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare function computed<T>(getter: () => T): ReadonlySignal<T>;
declare function writableComputed<T>(options: {
    get: () => T;
    set: (value: T) => void;
}): Signal<T>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

type DeepReadonly<T> = T extends object ? {
    readonly [K in keyof T]: DeepReadonly<T[K]>;
} : T;
declare function readonly<T>(target: Signal<T>): ReadonlySignal<T>;
declare function readonly<T extends object>(target: Reactive<T>): DeepReadonly<Reactive<T>>;
declare function readonly<T extends object>(target: T): DeepReadonly<T>;
declare const isReadonly: (value: unknown) => boolean;
declare const shallowReadonly: <T extends object>(target: T) => Readonly<T>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare function watchEffect(fn: (onCleanup: OnCleanup) => void | Promise<void>, options?: EffectOptions): EffectHandle;
declare function effectOnce(fn: () => void): void;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

type WatchSource<T> = Signal<T> | ReadonlySignal<T> | (() => T) | (T extends object ? T : never);
type WatchCallback<T> = (newValue: T, oldValue: T | undefined, onCleanup: OnCleanup) => void | Promise<void>;
declare function watch<T>(source: WatchSource<T>, callback: WatchCallback<T>, options?: WatchOptions): EffectHandle;
declare const watchMultiple: <T extends readonly WatchSource<unknown>[]>(sources: T, callback: (newValues: { [K in keyof T]: T[K] extends WatchSource<infer V> ? V : never; }, oldValues: { [K in keyof T]: T[K] extends WatchSource<infer V> ? V | undefined : never; }, onCleanup: OnCleanup) => void | Promise<void>, options?: WatchOptions) => EffectHandle;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare function el(tag: string, props?: ElementProps | null, ...children: EffuseChild[]): ElementNode;
declare function el<P>(blueprint: BlueprintDef<P>, props?: P | null, portals?: Portals | PortalFn | null): BlueprintNode<P>;
declare const fragment: (...children: EffuseChild[]) => EffuseNode;
declare const toNode: (child: EffuseChild) => EffuseNode | null;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

type CleanupFn$1 = () => void;
declare const render: (child: EffuseChild, container: Element) => CleanupFn$1;
declare const unmount: (container: Element) => void;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface ForProps<T> {
    each: Signal<T[]> | (() => T[]);
    keyExtractor?: (item: T, index: number) => unknown;
    children: (item: Signal<T>, index: Signal<number>) => EffuseNode;
    fallback?: EffuseChild | (() => EffuseChild);
    range?: Signal<{
        start: number;
        end: number;
    }>;
    transitions?: {
        enter?: (node: EffuseNode, index: number) => void;
        exit?: (node: EffuseNode, index: number) => void;
        move?: (node: EffuseNode, fromIndex: number, toIndex: number) => void;
    };
}
declare const For: (<T>(props: ForProps<T>) => EffuseNode) & {
    Dynamic: <T>(sig: Signal<T[]>, render: (item: T, index: Signal<number>) => EffuseNode) => EffuseNode;
};

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface ShowProps<T> {
    when: Signal<T> | (() => T);
    fallback?: EffuseChild | (() => EffuseChild);
    children: EffuseChild | ((item: NonNullable<T>) => EffuseChild);
    keyed?: boolean;
}
declare const Show: <T>(props: ShowProps<T>) => EffuseNode;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

type MatchNode<T> = {
    [EFFUSE_NODE]: true;
    _tag: 'Fragment';
    _matchMarker: typeof MATCH_MARKER;
    when: Signal<T> | (() => T) | T;
    children: EffuseChild | ((item: NonNullable<T>) => EffuseChild);
};
interface SwitchProps {
    fallback?: EffuseChild | (() => EffuseChild);
    children: MatchNode<unknown>[] | MatchNode<unknown>;
}
declare const Switch: ((props: SwitchProps) => EffuseNode) & {
    Match: <T>(props: {
        when: Signal<T> | (() => T) | T;
        children: EffuseChild | ((item: NonNullable<T>) => EffuseChild);
    }) => MatchNode<T>;
};

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface DynamicProps<P extends Record<string, unknown>> {
    component: Signal<BlueprintNode<P> | null> | (() => BlueprintNode<P> | null);
    props?: P;
    fallback?: EffuseChild | (() => EffuseChild);
    portals?: Portals;
}
declare const Dynamic: <P extends Record<string, unknown>>(dynamicProps: DynamicProps<P>) => EffuseNode;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface ErrorBoundaryProps {
    fallback: EffuseChild | ((error: Error, reset: () => void) => EffuseChild);
    children: EffuseChild;
    onError?: (error: Error) => void;
}
declare const ErrorBoundary: (props: ErrorBoundaryProps) => EffuseNode;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface RepeatProps {
    readonly times: number | Signal<number>;
    readonly children: (index: number) => EffuseChild;
    readonly fallback?: EffuseChild | (() => EffuseChild);
}
declare const Repeat: (props: RepeatProps) => EffuseNode;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface AwaitProps<T> {
    readonly promise: Promise<T> | (() => Promise<T>) | Signal<Promise<T>>;
    readonly pending?: EffuseChild | (() => EffuseChild);
    readonly error?: EffuseChild | ((error: unknown) => EffuseChild);
    readonly children: (data: T) => EffuseChild;
}
declare const Await: <T>(props: AwaitProps<T>) => EffuseNode;

interface SuspenseProps {
    fallback: EffuseChild;
    children: EffuseChild | (() => EffuseChild);
    [key: string]: unknown;
}
declare const Suspense: Component<SuspenseProps>;

declare const PropsValidationError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
    readonly _tag: "PropsValidationError";
} & Readonly<A>;
declare class PropsValidationError extends PropsValidationError_base<{
    readonly propName: string;
    readonly componentName: string | undefined;
    readonly message: string;
    readonly cause?: unknown;
}> {
    toString(): string;
}
interface PropDefinition<T> {
    readonly schema: Schema.Schema<T>;
    readonly required: boolean;
    readonly defaultValue?: T;
    readonly _tag: 'PropDefinition';
}
interface PropSchemaBuilder<T extends Record<string, unknown>> {
    readonly _schema: {
        [K in keyof T]: PropDefinition<T[K]>;
    };
    readonly schema: Schema.Schema<T>;
    readonly validate: (props: unknown, componentName?: string) => Effect.Effect<T, PropsValidationError>;
    readonly validateSync: (props: unknown, componentName?: string) => T;
}
interface AnyPropSchemaBuilder {
    readonly validateSync: (props: unknown, componentName?: string) => unknown;
}
type ExtractPropType<P> = P extends PropDefinition<infer T> ? T : never;
declare function required$1<T>(schema: Schema.Schema<T>): PropDefinition<T>;
declare function required$1<T extends Record<string, unknown>>(builder: PropSchemaBuilder<T>): PropDefinition<T>;
declare function optional<T>(schema: Schema.Schema<T>, defaultValue?: T): PropDefinition<T | undefined>;
declare function optional<T extends Record<string, unknown>>(builder: PropSchemaBuilder<T>, defaultValue?: T): PropDefinition<T | undefined>;
declare const PropSchema: {
    required: typeof required$1;
    optional: typeof optional;
    struct: <const D extends Record<string, PropDefinition<any>>>(definitions: D) => PropSchemaBuilder<{ [K in keyof D]: ExtractPropType<D[K]>; }>;
    String: typeof Schema.String;
    Number: typeof Schema.Number;
    Boolean: typeof Schema.Boolean;
    Literal: typeof Schema.Literal;
    Union: typeof Schema.Union;
    Array: <Value extends Schema.Schema.Any>(value: Value) => Schema.Array$<Value>;
    Struct: typeof Schema.Struct;
    Unknown: typeof Schema.Unknown;
    Optional: <S extends Schema.Schema.All>(self: S) => Schema.optional<S>;
};
type PropSchemaInfer<S> = S extends PropSchemaBuilder<infer T> ? T : never;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

type PropsDef<P> = {
    [K in keyof P]?: P[K] | (() => P[K]);
};
interface BlueprintOptions<P extends Record<string, unknown> = Record<string, unknown>> {
    readonly name?: string;
    readonly props?: PropsDef<P>;
    readonly propsSchema?: PropSchemaBuilder<P>;
    readonly state?: (props: P) => Record<string, Signal<unknown>>;
    readonly view: (context: BlueprintContext<P>) => EffuseChild;
    readonly error?: (error: Error) => EffuseChild;
    readonly loading?: () => EffuseChild;
}
declare const blueprint: <P extends Record<string, unknown> = Record<string, unknown>>(options: BlueprintOptions<P>) => BlueprintDef<P>;
declare const isBlueprint: (value: unknown) => value is BlueprintDef;
declare const instantiateBlueprint: <P extends Record<string, unknown>>(def: BlueprintDef<P>, props: P, portals: Portals) => BlueprintContext<P>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface ComponentLifecycle {
    readonly scope: Scope.CloseableScope;
    readonly onMount: (fn: () => (() => void) | undefined) => void;
    readonly onUnmount: (fn: () => void) => void;
    readonly onBeforeMount: (fn: () => void) => void;
    readonly onBeforeUnmount: (fn: () => void) => void;
    readonly runMount: () => void;
    readonly runCleanup: () => Effect.Effect<void>;
}
declare const createComponentLifecycleSync: () => ComponentLifecycle;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
declare function useCallback<T extends (...args: any[]) => any>(fn: T, deps?: unknown[]): T;
declare function useMemo<T>(fn: () => T, deps?: unknown[]): () => T;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
interface MetaTag {
    readonly name?: string;
    readonly property?: string;
    readonly content: string;
    readonly httpEquiv?: string;
}
interface LinkTag {
    readonly rel: string;
    readonly href: string;
    readonly type?: string;
    readonly crossOrigin?: 'anonymous' | 'use-credentials';
    readonly [key: string]: string | undefined;
}
interface ScriptTag {
    readonly src?: string;
    readonly content?: string;
    readonly type?: string;
    readonly async?: boolean;
    readonly defer?: boolean;
    readonly id?: string;
}
interface OpenGraphProps {
    readonly title?: string;
    readonly description?: string;
    readonly type?: string;
    readonly url?: string;
    readonly image?: string;
    readonly siteName?: string;
    readonly locale?: string;
    readonly [key: string]: string | undefined;
}
interface TwitterCardProps {
    readonly card?: 'summary' | 'summary_large_image' | 'app' | 'player';
    readonly site?: string;
    readonly creator?: string;
    readonly title?: string;
    readonly description?: string;
    readonly image?: string;
    readonly [key: string]: string | undefined;
}
interface HeadProps {
    readonly title?: string;
    readonly titleTemplate?: string | ((title?: string) => string);
    readonly description?: string;
    readonly canonical?: string;
    readonly viewport?: string;
    readonly charset?: string;
    readonly lang?: string;
    readonly themeColor?: string;
    readonly favicon?: string;
    readonly og?: OpenGraphProps;
    readonly twitter?: TwitterCardProps;
    readonly meta?: readonly MetaTag[];
    readonly link?: readonly LinkTag[];
    readonly script?: readonly ScriptTag[];
    readonly base?: string;
    readonly robots?: string;
    readonly htmlAttrs?: Record<string, string | boolean>;
    readonly bodyAttrs?: Record<string, string | boolean>;
    readonly noscript?: readonly {
        innerHTML: string;
        id?: string;
    }[];
    readonly style?: readonly {
        innerHTML: string;
        id?: string;
        type?: string;
    }[];
}
interface SSRContext {
    readonly url: string;
    readonly headStack: HeadProps[];
    readonly state: Record<string, unknown>;
    readonly isServer: true;
}
interface RenderResult {
    readonly html: string;
    readonly head: HeadProps;
    readonly state: Record<string, unknown>;
    readonly timing?: number;
}
interface ServerAppOptions {
    readonly basePath?: string;
    readonly minify?: boolean;
    readonly template?: string;
    readonly hydrate?: boolean;
}

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

type MaybePromise<T> = T | Promise<T>;
type CleanupFn = () => void;
type SetupResult = CleanupFn | undefined;
type PluginCleanup = () => void;
type PluginFn = () => MaybePromise<PluginCleanup | undefined>;
type Guard = (to: RouteConfig, from: RouteConfig | null) => boolean | Promise<boolean>;
interface RouteConfig {
    readonly path: string;
    readonly component: Component;
    readonly name?: string;
    readonly meta?: Record<string, unknown>;
    readonly head?: HeadProps;
    readonly children?: readonly RouteConfig[];
    readonly redirect?: string;
    readonly beforeEnter?: Guard;
}
interface StoreConfig {
    readonly name: string;
    readonly state: Record<string, unknown>;
    readonly actions?: Record<string, (...args: unknown[]) => void>;
}
type LayerRestriction = 'components' | 'routes' | 'stores' | 'providers' | 'plugins';
type LayerProps = Record<string, Signal<unknown>>;
type LayerProvides = Record<string, () => unknown>;
interface LayerDependency<P extends LayerProps = LayerProps> {
    readonly name: string;
    readonly props: P;
    get: (key: string) => unknown;
    component: (name: string) => Component | undefined;
}
type DepsRecord<D extends readonly string[]> = {
    [K in D[number]]: LayerDependency;
};
interface SetupContext<P extends LayerProps = LayerProps, D extends readonly string[] = readonly string[], S = unknown> {
    readonly props: P;
    readonly store: S;
    readonly deps: DepsRecord<D>;
    get: (name: string) => LayerDependency;
    getService: (key: string) => unknown;
    component: (name: string) => Component | undefined;
    readonly layers: readonly ResolvedLayer[];
}
type LayerSetupFn<P extends LayerProps = LayerProps, D extends readonly string[] = readonly string[], S = unknown> = (ctx: SetupContext<P, D, S>) => SetupResult | Promise<SetupResult> | void;
type LifecycleHook<P extends LayerProps = LayerProps, D extends readonly string[] = readonly string[], S = unknown> = (ctx: SetupContext<P, D, S>) => void | Promise<void>;
type ErrorHook<P extends LayerProps = LayerProps, D extends readonly string[] = readonly string[], S = unknown> = (error: Error, ctx: SetupContext<P, D, S>) => void;
type OnReadyHook<P extends LayerProps = LayerProps, D extends readonly string[] = readonly string[], S = unknown> = (ctx: SetupContext<P, D, S>, allLayers: readonly ResolvedLayer[]) => void | Promise<void>;
interface EffuseLayer<P extends LayerProps = LayerProps, D extends readonly string[] = readonly string[], S = unknown> {
    readonly name: string;
    readonly domain?: string;
    readonly props?: P;
    readonly store?: S;
    readonly deriveProps?: (store: S) => P;
    readonly extends?: readonly EffuseLayer[];
    readonly dependencies?: D;
    readonly restrict?: readonly LayerRestriction[];
    readonly head?: HeadProps;
    readonly components?: Record<string, Component<any>>;
    readonly provides?: LayerProvides;
    readonly setup?: LayerSetupFn<P, D, S>;
    readonly onMount?: LifecycleHook<P, D, S>;
    readonly onUnmount?: LifecycleHook<P, D, S>;
    readonly onError?: ErrorHook<P, D, S>;
    readonly onReady?: OnReadyHook<P, D, S>;
    readonly routes?: readonly RouteConfig[];
    readonly routeOptions?: {
        readonly lazy?: boolean;
        readonly guards?: readonly Guard[];
    };
    readonly stores?: readonly StoreConfig[];
    readonly providers?: readonly Component[];
    readonly plugins?: readonly PluginFn[];
}
interface ResolvedLayer<P extends LayerProps = LayerProps, D extends readonly string[] = readonly string[], S = unknown> extends EffuseLayer<P, D, S> {
    readonly _resolved: true;
    readonly _order: number;
}
interface MergedConfig {
    readonly routes: readonly RouteConfig[];
    readonly guards: readonly Guard[];
    readonly stores: readonly StoreConfig[];
    readonly providers: readonly Component[];
    readonly plugins: readonly PluginFn[];
    readonly setups: readonly LayerSetupFn[];
    readonly lazy: boolean;
}
type AnyLayer = EffuseLayer<any, any, any>;
type AnyResolvedLayer = ResolvedLayer<any, any, any>;
interface EffuseLayerRegistry {
}
interface EffuseServiceRegistry {
}
interface EffuseComponentRegistry {
}
type LayerPropsOf<K extends keyof EffuseLayerRegistry> = EffuseLayerRegistry[K] extends {
    props: infer P extends LayerProps;
} ? P : LayerProps;
type LayerProvidesOf<K extends keyof EffuseLayerRegistry> = EffuseLayerRegistry[K] extends {
    provides: infer S;
} ? S : unknown;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface PropsRegistry {
    readonly props: Map<string, LayerProps>;
    get: (layerName: string) => LayerProps | undefined;
    set: (layerName: string, props: LayerProps) => void;
    has: (layerName: string) => boolean;
}
declare const PropsService_base: Effect.Service.Class<PropsService, "effuse/layer/Props", {
    readonly effect: Effect.Effect<PropsRegistry, never, never>;
}>;
declare class PropsService extends PropsService_base {
}

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface LayerRegistry {
    readonly layers: Map<string, AnyResolvedLayer>;
    readonly components: Map<string, Component>;
    readonly services: Map<string, unknown>;
    getLayer: (name: string) => AnyResolvedLayer | undefined;
    getComponent: (name: string) => Component | undefined;
    getService: (key: string) => unknown;
    registerLayer: (layer: AnyResolvedLayer) => void;
    registerComponent: (name: string, component: Component) => void;
    registerService: (key: string, value: unknown) => void;
    hasLayer: (name: string) => boolean;
    hasComponent: (name: string) => boolean;
    hasService: (key: string) => boolean;
}
declare const RegistryService_base: Effect.Service.Class<RegistryService, "effuse/layer/Registry", {
    readonly effect: Effect.Effect<LayerRegistry, never, never>;
}>;
declare class RegistryService extends RegistryService_base {
}

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface LayerContext<P extends LayerProps = LayerProps> {
    readonly name: string;
    readonly props: P;
    readonly provides?: Record<string, () => unknown>;
    readonly deps: Record<string, LayerContext>;
    getService: (key: string) => unknown;
    getComponent: (name: string) => unknown;
}
type TypedLayerContext<K extends keyof EffuseLayerRegistry> = LayerContext<LayerPropsOf<K>>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

type ExposedValues = object;
interface EffuseRegistry {
}
type RouterType = EffuseRegistry extends {
    router: infer R;
} ? R : unknown;
interface ScriptContext<P> {
    readonly props: Readonly<P>;
    expose: (values: ExposedValues) => void;
    signal: typeof signal;
    computed: <T>(getter: () => T) => ReadonlySignal<T>;
    store: (name: string) => unknown;
    router: RouterType;
    onMount: (callback: () => (() => void) | undefined) => void;
    onUnmount: (callback: () => void) => void;
    onBeforeMount: (callback: () => void) => void;
    onBeforeUnmount: (callback: () => void) => void;
    watch: <T>(source: Signal<T> | (() => T), callback: (newValue: T, oldValue: T | undefined, onCleanup: OnCleanup) => void, options?: WatchOptions) => void;
    watchMultiple: <T extends readonly (Signal<unknown> | (() => unknown))[]>(sources: T, callback: (newValues: {
        [K in keyof T]: T[K] extends Signal<infer V> ? V : T[K] extends () => infer V ? V : never;
    }, oldValues: {
        [K in keyof T]: T[K] extends Signal<infer V> ? V | undefined : T[K] extends () => infer V ? V | undefined : never;
    }, onCleanup: OnCleanup) => void, options?: WatchOptions) => void;
    watchEffect: (fn: (onCleanup: OnCleanup) => void | Promise<void>, options?: EffectOptions) => EffectHandle;
    useCallback: typeof useCallback;
    useMemo: typeof useMemo;
    useLayer: <K extends keyof EffuseLayerRegistry>(name: K) => TypedLayerContext<K>;
    useStore: {
        <K extends keyof EffuseServiceRegistry>(key: K): EffuseServiceRegistry[K];
        (key: string): unknown;
    };
    useService: {
        <K extends keyof EffuseServiceRegistry>(key: K): EffuseServiceRegistry[K];
        (key: string): unknown;
    };
    useLayerProps: <K extends keyof EffuseLayerRegistry>(name: K) => LayerPropsOf<K> | undefined;
    /**
     * @deprecated Use `useLayer(name).provides` for all layer providers,
     * or `useService(key)` for individual services. Will be removed in a future release.
     */
    useLayerProvider: <K extends keyof EffuseLayerRegistry>(name: K) => LayerProvidesOf<K> | undefined;
    useComponent: {
        <K extends keyof EffuseComponentRegistry>(name: K): EffuseComponentRegistry[K];
        (name: string): Component | undefined;
    };
}
declare const setGlobalStoreGetter: (getter: (name: string) => unknown) => void;
declare const setGlobalRouter: (router: unknown) => void;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

type TemplateArgs<E extends ExposedValues> = E & {
    readonly children?: EffuseChild;
};
interface LayerScriptContext<P, K extends keyof EffuseLayerRegistry> extends ScriptContext<P> {
    readonly layerProps: LayerPropsOf<K>;
    readonly layer: LayerContext<LayerPropsOf<K>>;
}
interface DefineOptionsWithInferredProps<P, E extends ExposedValues> {
    name?: string;
    props: P;
    layer?: undefined;
    script: (ctx: ScriptContext<P>) => E | undefined;
    template: (exposed: TemplateArgs<E>, props: Readonly<P>) => EffuseChild;
}
interface DefineOptionsWithInferredPropsAndLayer<P, E extends ExposedValues, K extends keyof EffuseLayerRegistry> {
    name?: string;
    props: P;
    layer: K;
    script: (ctx: LayerScriptContext<P, K>) => E | undefined;
    template: (exposed: TemplateArgs<E>, props: Readonly<P>) => EffuseChild;
}
interface DefineOptions<P, E extends ExposedValues> {
    name?: string;
    props?: undefined;
    layer?: undefined;
    script: (ctx: ScriptContext<P>) => E | undefined;
    template: (exposed: TemplateArgs<E>, props: Readonly<P>) => EffuseChild;
}
interface DefineOptionsWithLayer<P, E extends ExposedValues, K extends keyof EffuseLayerRegistry> {
    name?: string;
    props?: undefined;
    layer: K;
    script: (ctx: LayerScriptContext<P, K>) => E | undefined;
    template: (exposed: TemplateArgs<E>, props: Readonly<P>) => EffuseChild;
}
declare function define<P = Record<string, unknown>, E extends ExposedValues = ExposedValues>(options: DefineOptions<P, E> | DefineOptionsWithInferredProps<P, E>): Component<P>;
declare function define<K extends keyof EffuseLayerRegistry, P = Record<string, unknown>, E extends ExposedValues = ExposedValues>(options: DefineOptionsWithLayer<P, E, K> | DefineOptionsWithInferredPropsAndLayer<P, E, K>): Component<P>;
type LayerPropsFor<K extends keyof EffuseLayerRegistry> = LayerPropsOf<K>;

interface PortalContainer {
    readonly id: string;
    readonly element: Element;
    readonly cleanup: () => void;
}
declare const createPortal: (content: EffuseChild, target: string | Element) => {
    cleanup: () => void;
};
declare const registerPortalOutlet: (name: string, element: Element) => void;
declare const unregisterPortalOutlet: (name: string) => void;
declare const getPortalOutlet: (name: string) => Element | undefined;
declare const renderToNamedPortal: (name: string, content: EffuseChild) => {
    cleanup: () => void;
};
type PortalInsertMode = 'append' | 'prepend' | 'replace';
type PortalPriority = 'low' | 'normal' | 'high' | 'overlay' | number;
declare const PORTAL_PRIORITY: {
    readonly LOW: 100;
    readonly NORMAL: 1000;
    readonly HIGH: 10000;
    readonly OVERLAY: 100000;
    readonly DEFAULT: 1000;
};
interface PortalProps {
    target: string | Element | (() => string | Element | null);
    children: EffuseChild;
    disabled?: boolean | (() => boolean);
    insertMode?: PortalInsertMode;
    priority?: PortalPriority;
    onMount?: (element: Element) => void;
    onUnmount?: () => void;
    useShadow?: boolean;
    key?: string;
}
declare const Portal: Component<PortalProps>;
declare const PortalOutlet: Component<{
    name: string;
    class?: string;
}>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
declare const RenderError_base$1: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
    readonly _tag: "RenderError";
} & Readonly<A>;
declare class RenderError$1 extends RenderError_base$1<{
    readonly message: string;
    readonly node?: unknown;
    readonly element?: unknown;
}> {
}
declare const MountError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
    readonly _tag: "MountError";
} & Readonly<A>;
declare class MountError extends MountError_base<{
    readonly message: string;
    readonly target?: string | Element;
}> {
}

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface Canvas {
    paint: <P extends Record<string, unknown>>(blueprint: BlueprintDef<P>, props?: P) => void;
    render: (node: EffuseChild) => void;
    dispose: () => void;
    paintEffect: <P extends Record<string, unknown>>(blueprint: BlueprintDef<P>, props?: P) => Effect.Effect<void, RenderError$1 | MountError>;
    renderEffect: (node: EffuseChild) => Effect.Effect<void, RenderError$1>;
}
declare const canvas: (target: Element | string) => Canvas;
declare const canvasEffect: (target: Element | string) => Effect.Effect<Canvas, MountError>;
declare const mount: <P = Record<string, unknown>>(blueprint: BlueprintDef<P>, target: Element | string, props?: P) => Canvas;
declare const mountEffect: <P extends Record<string, unknown>>(blueprint: BlueprintDef<P>, target: Element | string, props?: P) => Effect.Effect<Canvas, MountError | RenderError$1>;

type HookCleanup = () => void;
type HookFinalizer = () => void | Promise<void>;
type EffectCallback = () => HookCleanup | undefined;
interface HookScope {
    addFinalizer: (fn: HookFinalizer) => void;
    dispose: () => Promise<void>;
}
interface HookContext<C = unknown> {
    readonly config: C;
    readonly signal: <T>(initial: T) => Signal<T>;
    readonly computed: <T>(fn: () => T) => ReadonlySignal<T>;
    readonly watchEffect: (fn: EffectCallback) => void;
    readonly onMount: (fn: EffectCallback) => void;
    readonly scope: HookScope;
    readonly layer: <K extends keyof EffuseLayerRegistry>(name: K) => LayerPropsOf<K>;
    readonly layerProvider: <K extends keyof EffuseLayerRegistry>(name: K) => LayerProvidesOf<K>;
    readonly use: <R>(hook: () => R) => R;
    readonly runAsync: <T>(fn: () => Promise<T>) => Promise<T>;
}
type HookSetupFn<C, R> = (ctx: HookContext<C>) => R;
interface HookDefinition<C = unknown, R = unknown> {
    readonly deps?: readonly string[];
    readonly setup: HookSetupFn<C, R>;
}
type InferHookReturn<H> = H extends HookDefinition<unknown, infer R> ? R : never;
type InferHookConfig<H> = H extends HookDefinition<infer C, infer _R> ? C : never;

declare function defineHook<C = undefined, R = unknown>(definition: {
    readonly name?: string;
    readonly deps?: readonly string[];
    readonly setup: HookSetupFn<C, R>;
}): C extends undefined ? () => R : (config: C) => R;

declare const createHookContext: <C>(config: C, hookName?: string) => {
    ctx: HookContext<C>;
    dispose: () => Promise<void>;
    mountCallbacks: EffectCallback[];
};

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface MountedNode {
    nodes: Node[];
    cleanup: () => void;
}

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare const resolveLayerOrder: (layers: readonly AnyLayer[], visited?: Set<AnyLayer>, path?: string[]) => AnyResolvedLayer[];
declare const mergeLayerConfigs: (layers: readonly AnyResolvedLayer[]) => MergedConfig;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

type ResultOf<T> = T extends () => infer R ? R : never;
type EffuseServices<T extends EffuseLayer> = T['provides'] extends infer P extends LayerProvides ? {
    [K in keyof P]: ResultOf<P[K]>;
} : {};
interface CompiledLayer<T extends EffuseLayer> extends EffuseLayer {
    readonly effectLayer: Layer.Layer<EffuseServices<T>, never, Scope.Scope>;
    readonly tags: {
        readonly [K in keyof EffuseServices<T>]: Context.Tag<string, EffuseServices<T>[K]>;
    };
    readonly _resolved: true;
}
declare function defineLayer<T extends EffuseLayer>(definition: T): CompiledLayer<T>;
type MergeServices<Layers extends readonly CompiledLayer<any>[]> = Layers extends readonly [infer L, ...infer R] ? L extends CompiledLayer<infer T> ? EffuseServices<T> & (R extends readonly CompiledLayer<any>[] ? MergeServices<R> : {}) : never : {};
declare function combineLayers<Layers extends readonly CompiledLayer<any>[]>(...layers: Layers): Layer.Layer<MergeServices<Layers>, never, Scope.Scope>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
type TracingCategory = 'layers' | 'router' | 'components' | 'effects' | 'signals' | 'suspense' | 'emit' | 'store' | 'fibers' | 'hooks';
interface UseHooksCategories {
    readonly useWindowSize: boolean;
    readonly useLocalStorage: boolean;
    readonly useEventListener: boolean;
    readonly useMediaQuery: boolean;
    readonly useOnline: boolean;
    readonly useInterval: boolean;
    readonly useDebounce: boolean;
    readonly useThrottle: boolean;
}
declare const defaultUseHooksCategories: UseHooksCategories;
interface TracingCategories {
    readonly layers: boolean;
    readonly router: boolean;
    readonly components: boolean;
    readonly effects: boolean;
    readonly signals: boolean;
    readonly suspense: boolean;
    readonly emit: boolean;
    readonly store: boolean;
    readonly fibers: boolean;
    readonly hooks: boolean;
    readonly useHooks?: Partial<UseHooksCategories>;
}

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface TracingConfig {
    readonly enabled: boolean;
    readonly serviceName: string;
    readonly console: boolean;
    readonly verbose: boolean;
    readonly categories?: Partial<TracingCategories>;
}
interface TracingServiceApi {
    readonly config: TracingConfig;
    readonly isEnabled: () => boolean;
    readonly isCategoryEnabled: (category: TracingCategory) => boolean;
    readonly startSpan: (name: string, attributes?: Record<string, unknown>) => void;
    readonly endSpan: (name: string) => void;
    readonly logSpan: (name: string, duration: number, attributes?: Record<string, unknown>, depth?: number) => void;
    readonly log: (category: TracingCategory, type: string, name: string, data?: Record<string, unknown>) => void;
    readonly logWithDuration: (category: TracingCategory, type: string, name: string, duration: number, data?: Record<string, unknown>) => void;
}
declare const TracingService_base: Context.TagClass<TracingService, "TracingService", TracingServiceApi>;
declare class TracingService extends TracingService_base {
}
declare const createTracingService: (config?: Partial<TracingConfig>) => TracingServiceApi;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare const setGlobalTracing: (service: TracingServiceApi) => void;
declare const getGlobalTracing: () => TracingServiceApi | null;
declare const clearGlobalTracing: () => void;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

type LayerRuntimeServices = PropsService | RegistryService | TracingService;
interface LayerRuntimeOptions {
    tracing?: Partial<TracingConfig>;
}
interface LayerRuntime {
    readonly runtime: ManagedRuntime.ManagedRuntime<LayerRuntimeServices, never>;
    readonly cleanups: readonly CleanupFn[];
    dispose: () => Promise<void>;
}
declare const createLayerRuntime: (layers: readonly AnyResolvedLayer[], options?: LayerRuntimeOptions) => Promise<LayerRuntime>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface AppInstance {
    unmount: () => Promise<void>;
}
type MountOptions = LayerRuntimeOptions;
declare class EffuseApp {
    private layers;
    private rootComponent;
    private layerRuntime;
    constructor(root: Component);
    useLayers(layers: (AnyLayer | CompiledLayer<any> | (() => Promise<AnyLayer | CompiledLayer<any>>))[]): Promise<this>;
    mount(selector: string, options?: MountOptions): Promise<AppInstance>;
    private cleanup;
}

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare const createApp: (root: Component) => EffuseApp;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface ServerApp {
    useLayers(layers: readonly EffuseLayer[]): ServerApp;
    configure(options: ServerAppOptions): ServerApp;
    renderToString(url: string): Promise<RenderResult>;
    renderToHtml(url: string): Promise<string>;
}
declare const createServerApp: (root: Component) => ServerApp;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare const isServer: () => boolean;
declare const useHead: (head: HeadProps) => void;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
interface SeoMetaInput {
    title?: string;
    description?: string;
    keywords?: string;
    author?: string;
    robots?: string;
    generator?: string;
    applicationName?: string;
    referrer?: 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
    themeColor?: string;
    colorScheme?: 'normal' | 'light' | 'dark' | 'light dark' | 'dark light';
    ogTitle?: string;
    ogDescription?: string;
    ogType?: string;
    ogUrl?: string;
    ogImage?: string;
    ogImageAlt?: string;
    ogImageWidth?: string | number;
    ogImageHeight?: string | number;
    ogImageType?: string;
    ogLocale?: string;
    ogLocaleAlternate?: string[];
    ogSiteName?: string;
    ogDeterminer?: 'a' | 'an' | 'the' | '' | 'auto';
    articlePublishedTime?: string;
    articleModifiedTime?: string;
    articleExpirationTime?: string;
    articleAuthor?: string | string[];
    articleSection?: string;
    articleTag?: string | string[];
    twitterCard?: 'summary' | 'summary_large_image' | 'app' | 'player';
    twitterSite?: string;
    twitterSiteId?: string;
    twitterCreator?: string;
    twitterCreatorId?: string;
    twitterTitle?: string;
    twitterDescription?: string;
    twitterImage?: string;
    twitterImageAlt?: string;
    fbAppId?: string;
    googleSiteVerification?: string;
    yandexVerification?: string;
    msValidate?: string;
    appleItunesApp?: string;
    appleMobileWebAppCapable?: 'yes' | 'no';
    appleMobileWebAppStatusBarStyle?: 'default' | 'black' | 'black-translucent';
    appleMobileWebAppTitle?: string;
    formatDetection?: string;
}
declare const useSeoMeta: (input: SeoMetaInput) => void;
declare const useServerSeoMeta: (input: SeoMetaInput) => void;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface HandlerConfig {
    root: Component;
    layers?: readonly EffuseLayer[];
    options?: ServerAppOptions;
    transform?: (req: Request) => Request;
    notFound?: () => Response;
}
declare const createHandler: (config: HandlerConfig) => (request: Request) => Promise<Response>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare const mergeHeadProps: (base: HeadProps, override: HeadProps) => HeadProps;
declare const mergeLayerHeads: (heads: readonly HeadProps[]) => HeadProps;
declare const headToHtml: (head: HeadProps) => string;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface HydrationData {
    head: HeadProps;
    state: Record<string, unknown>;
    url: string;
    timestamp: number;
}
declare const getHydrationData: () => HydrationData | null;
declare const checkHydrationMatch: (clientState: Record<string, unknown>, serverState: Record<string, unknown>) => boolean;
declare const initHydration: () => HydrationData | null;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
declare const CycleError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
    readonly _tag: "CycleError";
} & Readonly<A>;
declare class CycleError extends CycleError_base<{
    readonly message: string;
    readonly layers: readonly string[];
}> {
}
declare const RenderError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
    readonly _tag: "RenderError";
} & Readonly<A>;
declare class RenderError extends RenderError_base<{
    readonly message: string;
    readonly url: string;
    readonly cause?: unknown;
}> {
}
declare const ValidationError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
    readonly _tag: "ValidationError";
} & Readonly<A>;
declare class ValidationError extends ValidationError_base<{
    readonly message: string;
    readonly path?: readonly string[];
    readonly expected?: string;
    readonly received?: string;
}> {
}
declare const HydrationError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
    readonly _tag: "HydrationError";
} & Readonly<A>;
declare class HydrationError extends HydrationError_base<{
    readonly message: string;
    readonly serverState: unknown;
    readonly clientState: unknown;
}> {
}
declare const HeadMergeError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
    readonly _tag: "HeadMergeError";
} & Readonly<A>;
declare class HeadMergeError extends HeadMergeError_base<{
    readonly message: string;
    readonly conflictingKeys: readonly string[];
}> {
}
declare const PluginError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
    readonly _tag: "PluginError";
} & Readonly<A>;
declare class PluginError extends PluginError_base<{
    readonly message: string;
    readonly pluginName?: string;
    readonly cause?: unknown;
}> {
}
type SSRError = CycleError | RenderError | ValidationError | HydrationError | HeadMergeError | PluginError;

interface EffuseConfigType {
    debug: boolean;
    strictMode: boolean;
    ssrMode: boolean;
}
declare const getEffuseConfig: () => EffuseConfigType;
declare const isDebugEnabled: () => boolean;
declare const isStrictMode: () => boolean;
declare const isSSRMode: () => boolean;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/** Validation result from a validator function. */
type ValidationResult = string | undefined;
/** Validator function for a single field. */
type FieldValidator<T> = (value: T) => ValidationResult;
/** Validation rules per form field. */
type FormValidators<T extends Record<string, unknown>> = {
    [K in keyof T]?: FieldValidator<T[K]>;
};
/** Validation behavior options. */
interface FormValidationOptions {
    /** Debounce delay in milliseconds. */
    readonly debounce?: number;
    /** Validation trigger mode. */
    readonly validateOn?: 'change' | 'blur' | 'submit';
}
/** Configuration options for useForm. */
interface FormOptions<T extends Record<string, unknown>> {
    /** Initial field values as signals. */
    readonly initial: {
        [K in keyof T]: Signal<T[K]>;
    };
    /** Validator functions per field. */
    readonly validators?: FormValidators<T>;
    /** Submit callback. */
    readonly onSubmit?: (data: T) => void | Promise<void>;
    /** Validation options. */
    readonly validationOptions?: FormValidationOptions;
}
/** Input binding result from bind(). */
interface BindResult<T> {
    /** Current field value. */
    readonly value: T;
    /** Input event handler. */
    readonly onInput: (e: Event) => void;
    /** Blur event handler. */
    readonly onBlur: () => void;
    /** Field name. */
    readonly name: string;
}
/** Error map keyed by field name. */
type FormErrors<T extends Record<string, unknown>> = {
    [K in keyof T]?: string;
};
/** Touch state per field. */
type FormTouched<T extends Record<string, unknown>> = {
    [K in keyof T]: Signal<boolean>;
};
/** Field signals per field name. */
type FormFields<T extends Record<string, unknown>> = {
    [K in keyof T]: Signal<T[K]>;
};
/** Return type of useForm hook. */
interface UseFormReturn<T extends Record<string, unknown>> {
    /** Reactive field signals. */
    readonly fields: FormFields<T>;
    /** Reactive error messages. */
    readonly errors: ReadonlySignal<FormErrors<T>>;
    /** Touch state per field. */
    readonly touched: FormTouched<T>;
    /** Form validity state. */
    readonly isValid: ReadonlySignal<boolean>;
    /** Dirty state (any field changed). */
    readonly isDirty: ReadonlySignal<boolean>;
    /** Submission state. */
    readonly isSubmitting: ReadonlySignal<boolean>;
    /** Form submit handler. */
    readonly submit: (e?: Event) => Promise<void>;
    /** Reset to initial values. */
    readonly reset: () => void;
    /** Input binding helper. */
    readonly bind: <K extends keyof T>(name: K) => BindResult<T[K]>;
    /** Set field value. */
    readonly setFieldValue: (name: keyof T, value: T[keyof T]) => void;
    /** Set field error. */
    readonly setFieldError: (name: keyof T, error: string | undefined) => void;
    /** Clear all errors. */
    readonly clearErrors: () => void;
    /** Manual validation trigger. */
    readonly validate: () => boolean;
}

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/**
 * Reactive form state with validation.
 */
declare function useForm<T extends Record<string, unknown>>(options: FormOptions<T>): UseFormReturn<T>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/** Compose multiple validators into one. */
declare function compose<T>(...validators: FieldValidator<T>[]): FieldValidator<T>;
/** Required field (not null, undefined, or empty string). */
declare function required(message?: string): FieldValidator<unknown>;
/** Custom validation with predicate function. */
declare function custom<T>(predicate: (value: T) => boolean, message?: string): FieldValidator<T>;
/** Validate if value equals expected. */
declare function equals<T>(expected: T, message?: string): FieldValidator<T>;
/** Validate if value is one of allowed values. */
declare function oneOf<T>(allowed: readonly T[], message?: string): FieldValidator<T>;
/** Validate if value is not one of forbidden values. */
declare function notOneOf<T>(forbidden: readonly T[], message?: string): FieldValidator<T>;
/** Conditional validation. */
declare function when<T>(condition: (value: T) => boolean, validator: FieldValidator<T>): FieldValidator<T>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/** Minimum string length. */
declare function minLength(min: number, message?: string): FieldValidator<string>;
/** Maximum string length. */
declare function maxLength(max: number, message?: string): FieldValidator<string>;
/** Exact string length. */
declare function length(len: number, message?: string): FieldValidator<string>;
/** String length range. */
declare function lengthBetween(min: number, max: number, message?: string): FieldValidator<string>;
/** Non empty string. */
declare function nonEmpty(message?: string): FieldValidator<string>;
/** Regex pattern match. */
declare function pattern(regex: RegExp, message?: string): FieldValidator<string>;
/** String starts with prefix. */
declare function startsWith(prefix: string, message?: string): FieldValidator<string>;
/** String ends with suffix. */
declare function endsWith(suffix: string, message?: string): FieldValidator<string>;
/** String includes substring. */
declare function includes(substring: string, message?: string): FieldValidator<string>;
/** Trimmed string (no leading/trailing whitespace). */
declare function trimmed(message?: string): FieldValidator<string>;
/** Lowercase string. */
declare function lowercased(message?: string): FieldValidator<string>;
/** Uppercase string. */
declare function uppercased(message?: string): FieldValidator<string>;
/** Capitalized string. */
declare function capitalized(message?: string): FieldValidator<string>;
/** Uncapitalized string. */
declare function uncapitalized(message?: string): FieldValidator<string>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/** Greater than value. */
declare function greaterThan(min: number, message?: string): FieldValidator<number>;
/** Greater than or equal to value. */
declare function greaterThanOrEqualTo(min: number, message?: string): FieldValidator<number>;
/** Less than value. */
declare function lessThan(max: number, message?: string): FieldValidator<number>;
/** Less than or equal to value. */
declare function lessThanOrEqualTo(max: number, message?: string): FieldValidator<number>;
/** Value between min and max inclusive. */
declare function between(min: number, max: number, message?: string): FieldValidator<number>;
/** Integer value. */
declare function integer(message?: string): FieldValidator<number>;
/** Finite number (excludes NaN, Infinity). */
declare function finite(message?: string): FieldValidator<number>;
/** Positive number (> 0). */
declare function positive(message?: string): FieldValidator<number>;
/** Non negative number (>= 0). */
declare function nonNegative(message?: string): FieldValidator<number>;
/** Negative number (< 0). */
declare function negative(message?: string): FieldValidator<number>;
/** Non positive number (<= 0). */
declare function nonPositive(message?: string): FieldValidator<number>;
/** Multiple of divisor. */
declare function multipleOf(divisor: number, message?: string): FieldValidator<number>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/** Email format validation. */
declare function email(message?: string): FieldValidator<string>;
/** URL format validation. */
declare function url(message?: string): FieldValidator<string>;
/** UUID format validation. */
declare function uuid(message?: string): FieldValidator<string>;
/** ULID format validation. */
declare function ulid(message?: string): FieldValidator<string>;
/** JSON parseable string validation. */
declare function json(message?: string): FieldValidator<string>;
/** Base64 encoded string validation. */
declare function base64(message?: string): FieldValidator<string>;
/** Hex string validation. */
declare function hex(message?: string): FieldValidator<string>;
/** Numeric string validation (string containing only digits). */
declare function numeric(message?: string): FieldValidator<string>;
/** Alphanumeric string validation. */
declare function alphanumeric(message?: string): FieldValidator<string>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/** Minimum array length. */
declare function minItems<T>(min: number, message?: string): FieldValidator<readonly T[]>;
/** Maximum array length. */
declare function maxItems<T>(max: number, message?: string): FieldValidator<readonly T[]>;
/** Exact array length. */
declare function itemCount<T>(count: number, message?: string): FieldValidator<readonly T[]>;
/** Non empty array. */
declare function nonEmptyArray<T>(message?: string): FieldValidator<readonly T[]>;
/** Unique items (no duplicates). */
declare function uniqueItems<T>(message?: string): FieldValidator<readonly T[]>;
/** Validate each item in array. */
declare function everyItem<T>(itemValidator: FieldValidator<T>, message?: string): FieldValidator<readonly T[]>;
/** Validate at least one item in array passes. */
declare function someItem<T>(itemValidator: FieldValidator<T>, message?: string): FieldValidator<readonly T[]>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/** Date is before target date. */
declare function before(target: Date, message?: string): FieldValidator<Date>;
/** Date is after target date. */
declare function after(target: Date, message?: string): FieldValidator<Date>;
/** Date is between two dates. */
declare function dateBetween(start: Date, end: Date, message?: string): FieldValidator<Date>;
/** Date is in the past. */
declare function past(message?: string): FieldValidator<Date>;
/** Date is in the future. */
declare function future(message?: string): FieldValidator<Date>;
/** Valid Date object (not Invalid Date). */
declare function validDate(message?: string): FieldValidator<Date>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/** Greater than value. */
declare function greaterThanBigInt(min: bigint, message?: string): FieldValidator<bigint>;
/** Greater than or equal to value. */
declare function greaterThanOrEqualToBigInt(min: bigint, message?: string): FieldValidator<bigint>;
/** Less than value. */
declare function lessThanBigInt(max: bigint, message?: string): FieldValidator<bigint>;
/** Less than or equal to value. */
declare function lessThanOrEqualToBigInt(max: bigint, message?: string): FieldValidator<bigint>;
/** Value between min and max inclusive. */
declare function betweenBigInt(min: bigint, max: bigint, message?: string): FieldValidator<bigint>;
/** Positive bigint (> 0n). */
declare function positiveBigInt(message?: string): FieldValidator<bigint>;
/** Non negative bigint (>= 0n). */
declare function nonNegativeBigInt(message?: string): FieldValidator<bigint>;
/** Negative bigint (< 0n). */
declare function negativeBigInt(message?: string): FieldValidator<bigint>;
/** Non positive bigint (<= 0n). */
declare function nonPositiveBigInt(message?: string): FieldValidator<bigint>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/** Extract error message from Effect Schema validation result. */
declare function extractSchemaError<T>(schema: Schema.Schema<T>, value: unknown): ValidationResult;
/** Validates values. */
declare function fromSchema<T>(schema: Schema.Schema<T>, message?: string): FieldValidator<T>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare const index_after: typeof after;
declare const index_alphanumeric: typeof alphanumeric;
declare const index_base64: typeof base64;
declare const index_before: typeof before;
declare const index_between: typeof between;
declare const index_betweenBigInt: typeof betweenBigInt;
declare const index_capitalized: typeof capitalized;
declare const index_compose: typeof compose;
declare const index_custom: typeof custom;
declare const index_dateBetween: typeof dateBetween;
declare const index_email: typeof email;
declare const index_endsWith: typeof endsWith;
declare const index_equals: typeof equals;
declare const index_everyItem: typeof everyItem;
declare const index_extractSchemaError: typeof extractSchemaError;
declare const index_finite: typeof finite;
declare const index_fromSchema: typeof fromSchema;
declare const index_future: typeof future;
declare const index_greaterThan: typeof greaterThan;
declare const index_greaterThanBigInt: typeof greaterThanBigInt;
declare const index_greaterThanOrEqualTo: typeof greaterThanOrEqualTo;
declare const index_greaterThanOrEqualToBigInt: typeof greaterThanOrEqualToBigInt;
declare const index_hex: typeof hex;
declare const index_includes: typeof includes;
declare const index_integer: typeof integer;
declare const index_itemCount: typeof itemCount;
declare const index_json: typeof json;
declare const index_length: typeof length;
declare const index_lengthBetween: typeof lengthBetween;
declare const index_lessThan: typeof lessThan;
declare const index_lessThanBigInt: typeof lessThanBigInt;
declare const index_lessThanOrEqualTo: typeof lessThanOrEqualTo;
declare const index_lessThanOrEqualToBigInt: typeof lessThanOrEqualToBigInt;
declare const index_lowercased: typeof lowercased;
declare const index_maxItems: typeof maxItems;
declare const index_maxLength: typeof maxLength;
declare const index_minItems: typeof minItems;
declare const index_minLength: typeof minLength;
declare const index_multipleOf: typeof multipleOf;
declare const index_negative: typeof negative;
declare const index_negativeBigInt: typeof negativeBigInt;
declare const index_nonEmpty: typeof nonEmpty;
declare const index_nonEmptyArray: typeof nonEmptyArray;
declare const index_nonNegative: typeof nonNegative;
declare const index_nonNegativeBigInt: typeof nonNegativeBigInt;
declare const index_nonPositive: typeof nonPositive;
declare const index_nonPositiveBigInt: typeof nonPositiveBigInt;
declare const index_notOneOf: typeof notOneOf;
declare const index_numeric: typeof numeric;
declare const index_oneOf: typeof oneOf;
declare const index_past: typeof past;
declare const index_pattern: typeof pattern;
declare const index_positive: typeof positive;
declare const index_positiveBigInt: typeof positiveBigInt;
declare const index_required: typeof required;
declare const index_someItem: typeof someItem;
declare const index_startsWith: typeof startsWith;
declare const index_trimmed: typeof trimmed;
declare const index_ulid: typeof ulid;
declare const index_uncapitalized: typeof uncapitalized;
declare const index_uniqueItems: typeof uniqueItems;
declare const index_uppercased: typeof uppercased;
declare const index_url: typeof url;
declare const index_uuid: typeof uuid;
declare const index_validDate: typeof validDate;
declare const index_when: typeof when;
declare namespace index {
  export { index_after as after, index_alphanumeric as alphanumeric, index_base64 as base64, index_before as before, index_between as between, index_betweenBigInt as betweenBigInt, index_capitalized as capitalized, index_compose as compose, index_custom as custom, index_dateBetween as dateBetween, index_email as email, index_endsWith as endsWith, index_equals as equals, index_everyItem as everyItem, index_extractSchemaError as extractSchemaError, index_finite as finite, index_fromSchema as fromSchema, index_future as future, index_greaterThan as greaterThan, index_greaterThanBigInt as greaterThanBigInt, index_greaterThanOrEqualTo as greaterThanOrEqualTo, index_greaterThanOrEqualToBigInt as greaterThanOrEqualToBigInt, index_hex as hex, index_includes as includes, index_integer as integer, index_itemCount as itemCount, index_json as json, index_length as length, index_lengthBetween as lengthBetween, index_lessThan as lessThan, index_lessThanBigInt as lessThanBigInt, index_lessThanOrEqualTo as lessThanOrEqualTo, index_lessThanOrEqualToBigInt as lessThanOrEqualToBigInt, index_lowercased as lowercased, index_maxItems as maxItems, index_maxLength as maxLength, index_minItems as minItems, index_minLength as minLength, index_multipleOf as multipleOf, index_negative as negative, index_negativeBigInt as negativeBigInt, index_nonEmpty as nonEmpty, index_nonEmptyArray as nonEmptyArray, index_nonNegative as nonNegative, index_nonNegativeBigInt as nonNegativeBigInt, index_nonPositive as nonPositive, index_nonPositiveBigInt as nonPositiveBigInt, index_notOneOf as notOneOf, index_numeric as numeric, index_oneOf as oneOf, index_past as past, index_pattern as pattern, index_positive as positive, index_positiveBigInt as positiveBigInt, index_required as required, index_someItem as someItem, index_startsWith as startsWith, index_trimmed as trimmed, index_ulid as ulid, index_uncapitalized as uncapitalized, index_uniqueItems as uniqueItems, index_uppercased as uppercased, index_url as url, index_uuid as uuid, index_validDate as validDate, index_when as when };
}

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/** Single field validation. Returns error message or undefined. */
declare function validateField<T>(validator: ((value: T) => string | undefined) | undefined, value: T): string | undefined;
/** Full form validation. Returns error map. */
declare function validateForm<T extends Record<string, unknown>>(validators: FormValidators<T>, values: T): FormErrors<T>;
/** Check if error map contains any errors. */
declare function hasErrors<T extends Record<string, unknown>>(errors: FormErrors<T>): boolean;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
declare const DEFAULT_DEBOUNCE_MS = 300;
declare const DEFAULT_THROTTLE_MS = 100;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

type EmitHandler<P> = (payload: P) => void;
type EventMap = Record<string, any>;
type EmitEvents<T extends EventMap> = T;
type InferPayload<T> = T;
interface EmitOptions {
    readonly debounce?: number;
    readonly throttle?: number;
    readonly once?: boolean;
    readonly filter?: (payload: unknown) => boolean;
}
interface EmitContextData<T extends EventMap> {
    readonly handlers: Map<string, Set<EmitHandler<unknown>>>;
    readonly signals: Map<string, Signal<unknown>>;
    readonly _phantom?: T;
}
type EmitFn<T extends EventMap> = <K extends keyof T & string>(event: K, payload: T[K]) => void;
type EmitFnAsync<T extends EventMap> = <K extends keyof T & string>(event: K, payload: T[K]) => Promise<void>;
type SubscribeFn<T extends EventMap> = <K extends keyof T & string>(event: K, handler: EmitHandler<T[K]>) => () => void;
type EventSignal<P> = ReadonlySignal<P | undefined>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface EmitServiceApi {
    createContext: <T extends EventMap>() => EmitContextData<T>;
    registerHandler: <T extends EventMap>(ctx: EmitContextData<T>, event: string, handler: EmitHandler<unknown>) => () => void;
    emit: <T extends EventMap>(ctx: EmitContextData<T>, event: string, payload: unknown) => void;
    getSignal: <T extends EventMap>(ctx: EmitContextData<T>, event: string) => Signal<unknown>;
}
declare const getEmitService: () => EmitServiceApi;
declare const useEmitService: (fn: (service: EmitServiceApi) => void) => void;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare function useEmits<T extends EventMap>(initialHandlers?: Partial<{
    [K in keyof T]: EmitHandler<T[K]>;
}>): {
    emit: EmitFn<T>;
    emitAsync: EmitFnAsync<T>;
    on: SubscribeFn<T>;
    off: <K extends keyof T & string>(event: K, handler: EmitHandler<T[K]>) => void;
    context: EmitContextData<T>;
};

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare function useEventSignal<T extends EventMap, P>(ctx: EmitContextData<T>, event: string, options?: EmitOptions): EventSignal<P>;
declare function createEventSignal<P>(initialValue?: P): Signal<P | undefined>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
declare function createDebounce<T>(ms?: number): {
    apply: (value: T, callback: (v: T) => void) => void;
    cancel: () => void;
};

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
declare function createThrottle<T>(ms?: number): {
    apply: (value: T, callback: (v: T) => void) => boolean;
    reset: () => void;
};

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
declare function createOnce<T>(): {
    apply: (value: T, callback: (v: T) => void) => boolean;
    reset: () => void;
    hasFired: () => boolean;
};

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
type FilterPredicate<T> = (value: T) => boolean;
declare function createFilter<T>(predicate: FilterPredicate<T>): {
    apply: (value: T, callback: (v: T) => void) => boolean;
};

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

interface ContextOptions<T> {
    readonly id: string;
    readonly defaultValue?: T | (() => T);
    readonly displayName?: string;
}
interface ProviderProps<T> {
    readonly value: T;
    readonly children: EffuseChild;
}
interface EffuseContext<T> {
    readonly id: string;
    readonly displayName: string;
    readonly Provider: ReturnType<typeof define>;
    readonly defaultValue: T | undefined;
    readonly hasDefault: boolean;
    readonly _effectTag: Context.Tag<string, T>;
    readonly _tag: 'EffuseContext';
}
declare function createContext<T>(options: ContextOptions<T>): EffuseContext<T>;
declare function useContext<T>(context: EffuseContext<T>, componentName?: string): T;
declare function hasContextValue<T>(context: EffuseContext<T>): boolean;
declare const isEffuseContext: (value: unknown) => value is EffuseContext<unknown>;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
declare const ContextNotFoundError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
    readonly _tag: "ContextNotFoundError";
} & Readonly<A>;
declare class ContextNotFoundError extends ContextNotFoundError_base<{
    readonly contextId: string;
    readonly componentName?: string;
}> {
    get message(): string;
}

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
type RefCallback<T extends Element = Element> = (el: T | null) => void;
interface RefObject<T extends Element = Element> {
    readonly current: T | null;
    readonly subscribe: (callback: RefCallback<T>) => () => void;
}
type Ref<T extends Element = Element> = RefCallback<T> | RefObject<T>;
type Directive<T extends Element = Element, P = unknown> = (element: T, accessor: () => P) => undefined | (() => void);
interface RefOptions {
    readonly name?: string;
}

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare function createRef<T extends Element = Element>(_options?: RefOptions): RefObject<T>;
declare function isRefObject<T extends Element = Element>(value: unknown): value is RefObject<T>;
declare function isRefCallback<T extends Element = Element>(value: unknown): value is RefCallback<T>;
declare function applyRef<T extends Element>(ref: RefCallback<T> | RefObject<T> | undefined | null, element: T | null): void;

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

declare function registerDirective<T extends Element, P>(name: string, fn: Directive<T, P>): void;
declare function getDirective(name: string): Directive | undefined;
declare function hasDirective(name: string): boolean;
declare function unregisterDirective(name: string): boolean;
declare function applyDirective(name: string, element: Element, accessor: () => unknown): (() => void) | undefined;
declare function getDirectiveNames(): string[];

/**
 * MIT License
 *
 * Copyright (c) 2025 Chris M. Perez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
declare const RefNotAttachedError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
    readonly _tag: "RefNotAttachedError";
} & Readonly<A>;
declare class RefNotAttachedError extends RefNotAttachedError_base<{
    readonly message: string;
    readonly refName?: string;
}> {
}
declare const DirectiveError_base: new <A extends Record<string, any> = {}>(args: effect_Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => effect_Cause.YieldableError & {
    readonly _tag: "DirectiveError";
} & Readonly<A>;
declare class DirectiveError extends DirectiveError_base<{
    readonly message: string;
    readonly directiveName?: string;
    readonly cause?: unknown;
}> {
}

export { type AnyLayer, type AnyPropSchemaBuilder, type AnyResolvedLayer, type AppInstance, Await, type AwaitProps, type BindResult, BlueprintContext, BlueprintDef, BlueprintNode, type BlueprintOptions, type Canvas, type CleanupFn$2 as CleanupFn, type CompiledLayer, Component, type ComponentLifecycle, ContextNotFoundError, type ContextOptions, DEFAULT_DEBOUNCE_MS, DEFAULT_THROTTLE_MS, type DeepReadonly, type DefineOptions, type DefineOptionsWithLayer, type Directive, DirectiveError, Dynamic, type DynamicProps, EFFUSE_NODE, type EffectHandle, type EffectOptions, EffuseApp, EffuseChild, type EffuseConfigType, type EffuseContext, type EffuseLayer, type EffuseLayerRegistry, EffuseNode, type EffuseRegistry, type EffuseServices, ElementNode, type EmitContextData, type EmitEvents, type EmitFn, type EmitFnAsync, type EmitHandler, type EmitOptions, type EmitServiceApi, ErrorBoundary, type ErrorBoundaryProps, type EventMap, type EventSignal, type FieldValidator, type FilterPredicate, For, type ForProps, type FormErrors, type FormFields, type FormOptions, type FormTouched, type FormValidationOptions, type FormValidators, type Guard, type HandlerConfig, type HeadProps, type HookCleanup, type HookContext, type HookDefinition, type HookFinalizer, type HookScope, type HookSetupFn, type HydrationData, type InferHookConfig, type InferHookReturn, type InferPayload, type LayerProps, type LayerPropsFor, type LayerProvides, type LayerRestriction, type LayerRuntime, type LayerRuntimeOptions, type LayerScriptContext, type LayerSetupFn, type LinkTag, type MaybePromise, type MergeServices, type MergedConfig, type MetaTag, type MountOptions, type MountedNode, type OnCleanup, type OpenGraphProps, PORTAL_PRIORITY, type PluginCleanup, type PluginFn, Portal, type PortalContainer, PortalFn, type PortalInsertMode, PortalOutlet, type PortalPriority, type PortalProps, Portals, type PropDefinition, PropSchema, type PropSchemaBuilder, type PropSchemaInfer, PropsValidationError, type ProviderProps, type Reactive, ReadonlySignal, type Ref, type RefCallback, RefNotAttachedError, type RefObject, type RefOptions, type RenderResult, Repeat, type RepeatProps, type ResolvedLayer, type RouteConfig, type SSRContext, type SSRError, type ScriptContext, type ScriptTag, type SeoMetaInput, type ServerApp, type ServerAppOptions, type SetupContext, Show, type ShowProps, Signal, type StoreConfig, type SubscribeFn, Suspense, type SuspenseProps, Switch, type SwitchProps, type TwitterCardProps, type UseFormReturn, type UseHooksCategories, type ValidationResult, type WatchCallback, type WatchOptions, type WatchSource, applyDirective, applyRef, blueprint, canvas, canvasEffect, checkHydrationMatch, clearGlobalTracing, combineLayers, computed, createApp, createComponentLifecycleSync, createContext, createDebounce, createEventSignal, createFilter, createHandler, createHookContext, createLayerRuntime, createOnce, createPortal, createRef, createServerApp, createThrottle, createTracingService, defaultUseHooksCategories, define, defineHook, defineLayer, effectOnce, el, fragment, getDirective, getDirectiveNames, getEffuseConfig, getEmitService, getGlobalTracing, getHydrationData, getPortalOutlet, getSignalDep, getSignalRef, hasContextValue, hasDirective, hasErrors, headToHtml, initHydration, instantiateBlueprint, isBlueprint, isDebugEnabled, isEffuseContext, isReactive, isReadonly, isRefCallback, isRefObject, isSSRMode, isServer, isSignal, isStrictMode, markRaw, mergeHeadProps, mergeLayerConfigs, mergeLayerHeads, mount, mountEffect, reactive, readonly, readonlySignal, registerDirective, registerPortalOutlet, render, renderToNamedPortal, resolveLayerOrder, setGlobalRouter, setGlobalStoreGetter, setGlobalTracing, shallowReadonly, signal, toNode, toRaw, unmount, unref, unregisterDirective, unregisterPortalOutlet, useContext, useEmitService, useEmits, useEventSignal, useForm, useHead, useSeoMeta, useServerSeoMeta, index as v, validateField, validateForm, watch, watchEffect, watchMultiple, writableComputed };