@motifx/core 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,1470 @@
+export { AnyFunctionalComponent, JSX, MotifBaseProps, MotifBindable, MotifClass, MotifComponentConstructor, MotifComponentType, MotifFunctionalComponent, MotifFunctionalComponentBasic, MotifStyle, MotifValue, __attr } from './jsx-runtime.js';
+
+interface IDisposable {
+    dispose(): void;
+}
+
+declare class DisposableStore implements IDisposable {
+    private readonly _items;
+    private _closed;
+    constructor();
+    get isDisposed(): boolean;
+    add<T extends IDisposable>(item: T): T;
+    delete<T extends IDisposable>(item: T): void;
+    detach<T extends IDisposable>(item: T): void;
+    clear(): void;
+    dispose(): void;
+}
+
+declare abstract class Disposable implements IDisposable {
+    constructor();
+    dispose(): void;
+}
+
+interface IDisposableTracker {
+    trackDisposable(disposable: IDisposable): void;
+    setParent(child: IDisposable, parent: IDisposable | null): void;
+    markAsDisposed(disposable: IDisposable): void;
+    markAsSingleton(disposable: IDisposable): void;
+}
+declare class DisposableCore {
+    disposableTracker: IDisposableTracker | null;
+    notifyCreated<T extends IDisposable>(target: T): T;
+    notifyDisposed(target: IDisposable): void;
+    notifyOwner(target: IDisposable, owner: IDisposable | null): void;
+    toDisposable(fn: () => void): IDisposable;
+}
+declare const disposableCore: DisposableCore;
+
+interface BindingFormatInfo {
+    locale?: string | string[];
+    currency?: string;
+}
+interface IBaseBinding {
+    propertyName: string;
+    dataSource: any;
+    dataMember?: string;
+    formatString?: string;
+    converter?: (value: any) => any;
+    converterBack?: (value: any) => any;
+    setter?: (value: any) => void;
+    formatInfo?: BindingFormatInfo;
+    updateMode?: 'onPropertyChanged' | 'onValidation' | 'never';
+    activate(): void;
+    deactivate(): void;
+    reActivate(): void;
+}
+
+interface IBindingCollection {
+    add(propertyName: string, dataSource: any): IBaseBinding;
+    add(propertyName: string, dataSource: any, dataMember: string): IBaseBinding;
+    add(propertyName: string, dataSource: any, dataMember: string, formatString: string): IBaseBinding;
+    add(propertyName: string, dataSource: any, dataMember: string, formatString: string, formatInfo: BindingFormatInfo): IBaseBinding;
+    add(binding: IBaseBinding): IBaseBinding;
+    wait(predicate: () => any): IBaseBinding;
+    when(conditionFn: () => any, effectFn: (isTrue: boolean) => any): IBaseBinding;
+    ternary(conditionFn: () => any, trueFn: (frame: any) => any, falseFn: (frame: any) => any): IBaseBinding;
+    list(itemsFn: () => any[] | Iterable<any>, renderFn: (item: any, index: number) => ComponentBase): IBaseBinding;
+    list(itemsFn: () => any[] | Iterable<any>, renderFn: (item: any, index: number) => ComponentBase, options: ListBindingOptions): IBaseBinding;
+    remove(binding: IBaseBinding): void;
+    clear(): void;
+    items: IBaseBinding[];
+    switchCase(discriminatorFn: () => any, cases: Record<string | number, (frame: any) => any>, defaultFn?: (frame: any) => any): any;
+}
+
+interface ListBindingOptions {
+    reuse?: boolean;
+}
+
+declare class BindingCollection implements IBindingCollection {
+    private _items;
+    private _component;
+    private _branchScope;
+    constructor(component: ComponentBase);
+    private _own;
+    when(computeFn: () => any, renderFn: (isTrue: boolean) => any): any;
+    get items(): IBaseBinding[];
+    text(cb: any): void;
+    value(fn: () => any): void;
+    add(propertyName: string, dataSource: any): IBaseBinding;
+    add(propertyName: string, dataSource: any, dataMember: string): IBaseBinding;
+    add(propertyName: string, dataSource: any, dataMember: string, formatString: string): IBaseBinding;
+    add(propertyName: string, dataSource: any, dataMember: string, formatString: string, formatInfo: BindingFormatInfo): IBaseBinding;
+    add(binding: IBaseBinding): IBaseBinding;
+    wait(predicate: () => any): IBaseBinding;
+    display(predicate: () => any): IBaseBinding;
+    html(predicate: () => any): IBaseBinding;
+    list(itemsFn: () => any[] | Iterable<any>, renderFn: (item: any, index: number) => ComponentBase): IBaseBinding;
+    list(itemsFn: () => any[] | Iterable<any>, renderFn: (item: any, index: number) => ComponentBase, options: ListBindingOptions): IBaseBinding;
+    loop(itemsFn: () => any[] | Iterable<any>, renderFn: (item: any, index: number) => ComponentBase): IBaseBinding;
+    loop(itemsFn: () => any[] | Iterable<any>, renderFn: (item: any, index: number) => ComponentBase, options: ListBindingOptions): IBaseBinding;
+    method(cb: () => any): void;
+    ternary(conditionFn: () => any, trueFn: (frame: Frame) => any, falseFn: (frame: Frame) => any): any;
+    private _ternarySchedule;
+    private ternaryCall;
+    private _ternaryCallTop;
+    watch(cb: () => any): void;
+    remove(binding: IBaseBinding): void;
+    clear(): void;
+    activateAll(): void;
+    model(dataSource: any): IBaseBinding;
+    model(dataSource: any, dataMember: string): IBaseBinding;
+    model(dataSource: any, dataMember: string, formatString: string): IBaseBinding;
+    model(dataSource: any, dataMember: string, formatString: string, formatInfo: BindingFormatInfo): IBaseBinding;
+    model(getter: () => any, setter: (value: any) => void): IBaseBinding;
+    model(binding: IBaseBinding): IBaseBinding;
+    deactivateAll(): void;
+    reActivateAll(): void;
+    switchCase(discriminatorFn: () => any, cases: Record<string | number, (frame: Frame) => any>, defaultFn?: (frame: Frame) => any): any;
+}
+
+type Event$1<T> = (listener: (value: T) => unknown, thisArgs?: any, disposables?: IDisposable[] | DisposableStore) => IDisposable;
+
+declare class Emitter<T> {
+    private _subscriptions;
+    private _delivery;
+    private _subscribe;
+    private _disposed;
+    get event(): Event$1<T>;
+    fire(value: T): void;
+    dispose(): void;
+    private _writable;
+    private _unsubscribe;
+    private _resume;
+}
+
+type TransitionKind = 'transition' | 'animation';
+interface CSSTransitionInfo {
+    type: TransitionKind | null;
+    timeout: number;
+    propCount: number;
+    hasTransform: boolean;
+}
+interface TransitionProps {
+    name?: string;
+    type?: TransitionKind;
+    css?: boolean;
+    duration?: number | {
+        enter: number;
+        leave: number;
+    };
+    enterFromClass?: string;
+    enterActiveClass?: string;
+    enterToClass?: string;
+    appearFromClass?: string;
+    appearActiveClass?: string;
+    appearToClass?: string;
+    leaveFromClass?: string;
+    leaveActiveClass?: string;
+    leaveToClass?: string;
+}
+
+interface IHtmlElement extends HTMLElement {
+}
+interface IElement extends Node {
+}
+type ElementType = IElement | IHtmlElement | DocumentFragment | Comment | Text;
+type CustomParameters<T extends any> = T extends (...args: infer P) => any ? P[0] : never;
+type IsOptional<T> = T extends {} ? {
+    [K in keyof T]-?: {} extends Pick<T, K> ? true : false;
+}[keyof T] : false;
+type OptionalParams<T> = T extends null ? {
+    params?: undefined;
+} : T extends undefined ? {
+    params?: undefined;
+} : IsOptional<T> extends true ? T : T;
+interface EventArgs {
+    cancel: boolean;
+}
+type RouterClassingSettings = {
+    to: 'all' | 'active' | 'exact' | 'none';
+    path: string;
+    activeClass?: string;
+    exactClass?: string;
+    onActive?: () => void;
+    offActive?: () => void;
+    onExact?: () => void;
+    offExact?: () => void;
+};
+interface ComponentBaseOptions<TProps> {
+    props?: TProps;
+    [key: string]: any;
+    cache?: DocumentFragment;
+    closeFragment?: Comment;
+    transition: {
+        transitionInfo: () => {
+            in: CSSTransitionInfo;
+            out: CSSTransitionInfo;
+        };
+        name: string;
+        classes?: TransitionProps;
+        activeCssCancel: (() => void) | null;
+        activeCssPhase: 'enter' | 'leave' | null;
+        cssProps: () => TransitionProps | null;
+        skipNextLeave: boolean;
+        in: (op: {
+            keyframes: Keyframe[] | PropertyIndexedKeyframes | null;
+            options?: number | KeyframeAnimationOptions;
+        }) => void;
+        out: (op: {
+            keyframes: Keyframe[] | PropertyIndexedKeyframes | null;
+            options?: number | KeyframeAnimationOptions;
+        }) => void;
+        enterTransition: (resolve: () => void) => Animation;
+        leaveTransition: (resolve: () => void) => Animation;
+        activeAnimations: Animation[];
+        run: (keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions, resolve?: () => void) => Animation;
+    };
+    set enableRouterClassing(value: RouterClassingSettings);
+    getInstance(): any;
+    hasEvent: (name: string) => boolean;
+}
+type AnyEvents = {
+    [key: string]: any;
+};
+type HtmlElementEvents = {
+    [K in keyof IHtmlElement as K extends `on${string}` ? Uncapitalize<K extends `on${infer EventName}` ? EventName : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:passive` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:passive:prevent` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:passive:stop` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:passive:trusted` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:passive:capture` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:passive:self` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:prevent` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:prevent:stop` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:prevent:trusted` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:prevent:trusted:capture` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:prevent:trusted:self` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:stop` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:stop:trusted` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:stop:capture` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:stop:self` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:trusted` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:trusted:capture` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:once:trusted:self` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:prevent` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:prevent:stop` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:prevent:trusted` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:prevent:capture` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:prevent:self` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:stop` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:stop:trusted` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:stop:capture` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:stop:self` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:trusted` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:trusted:capture` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:trusted:self` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:capture` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:capture:self` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:passive:self` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:prevent` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:prevent:stop` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:prevent:trusted` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:prevent:capture` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:prevent:self` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:stop` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:stop:trusted` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:stop:capture` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:stop:self` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:trusted` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:trusted:capture` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:trusted:self` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:capture` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:capture:self` : never> | Uncapitalize<K extends `on${infer EventName}` ? `${EventName}:self` : never> : 'x:building' | 'x:built' | 'x:initializing' | 'x:initialized' | 'x:disposing' | 'x:disposed' | 'x:config' | 'x:configured' | 'x:visibilityChanged' | 'x:mounted']: CustomParameters<IHtmlElement[K]> extends Event ? CustomParameters<IHtmlElement[K]> : EventArgs;
+} & AnyEvents;
+
+type ElementTypes = Node | Element | HTMLElement | Text | DocumentFragment | Comment | HTMLDivElement;
+declare class controlAttribute<ElementType extends ElementTypes> implements IAttribute<ComponentBase<ElementType, any>> {
+    private _parent;
+    private _attrMap;
+    private _watchers;
+    constructor(parent: ComponentBase<ElementType, any>);
+    /** @deprecated Tek kaynak `_attrMap`; geriye dönük okuma için türetilmiş görünüm. */
+    get attributes(): {
+        name: string;
+        value: any;
+    }[];
+    add(attribute: object | string): ComponentBase<ElementType, any>;
+    remove(key: string): ComponentBase<ElementType, any>;
+    has(key: string): boolean;
+    get(key: string): string | null;
+    parse(values: any, key: any): void;
+    private _applyValue;
+    private _getElement;
+    hasMethodState(key: string): boolean;
+    getMethodState(key: string): any;
+}
+
+declare const opaqueBrand: unique symbol;
+declare const shallowBrand: unique symbol;
+type OpaqueState = Function | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | string | number | boolean | {
+    [opaqueBrand]?: true;
+};
+type DeepState<T> = T extends OpaqueState ? T : T extends Array<any> ? {
+    [Index in keyof T]: DeepState<T[Index]>;
+} : T extends object & {
+    [shallowBrand]?: never;
+} ? {
+    [Key in keyof T]: Key extends symbol ? T[Key] : DeepState<T[Key]>;
+} : T;
+interface BoxedPrimitive<T> {
+    value: T;
+}
+type UnwrapValueRefs<T> = T extends number | string | boolean ? BoxedPrimitive<T> : DeepState<T>;
+
+declare class ComponentMotif<TSelf extends ComponentBase = ComponentBase, TProps extends object = any> {
+    private readonly _component;
+    options: ComponentBaseOptions<TProps> & {
+        hideStrategy?: 'placeholder' | 'detach' | 'auto';
+        placeholder?: Comment;
+    };
+    constructor(component: TSelf, options: ComponentMotif<TSelf, TProps>['options']);
+    show(): Promise<any>;
+    hide(): Promise<any>;
+    toggle(): void;
+    on<K extends keyof HtmlElementEvents>(event: K, cb: (sender: TSelf, ev: HtmlElementEvents[K]) => any, domEvent?: boolean): Promise<TSelf>;
+    off<K extends keyof HtmlElementEvents>(event: K, cb: (sender: TSelf, ev: HtmlElementEvents[K]) => any): Promise<TSelf>;
+    trigger(event: any, ev: any): Promise<TSelf>;
+    addHandler(event: any, handler: (sender: ComponentBase, e: EventArgs) => void): void;
+    clear(): Promise<any>;
+    register(c: IDisposable): void;
+    setDisposable(c: () => void): void;
+    stopAnimations(): Promise<void>;
+}
+
+type IBaseProp<T extends any> = OptionalParams<T> & {
+    childs?: any[];
+    options?: any;
+    onElementCreating?(): any;
+    initializeComponent?(sender: ComponentBase): void;
+    onBuilding?(sender: ComponentBase, e: EventArgs): void;
+    onBuilt?(sender: ComponentBase, e: EventArgs): void;
+    onMounted?(sender: ComponentBase, e: EventArgs): void;
+    onInitializing?(sender: ComponentBase, e: EventArgs): void;
+    onInitialized?(sender: ComponentBase, e: EventArgs): void;
+    onDisposing?(sender: ComponentBase, e: EventArgs): void;
+    onDisposed?(sender: ComponentBase, e: EventArgs): void;
+    onConfig?(sender: ComponentBase, e: EventArgs): void;
+    onConfigured?(sender: ComponentBase, e: EventArgs): void;
+    onVisibilityChanged?(sender: ComponentBase, e: EventArgs): void;
+    onActivated?(sender: ComponentBase, e: EventArgs): void;
+    onDeactivated?(sender: ComponentBase, e: EventArgs): void;
+    runover?: {
+        initializeComponent?: (sender: ComponentBase) => void;
+    };
+    [key: string]: any;
+};
+interface IDisposeOptions {
+    deep?: boolean;
+    skipLeaveTransition?: boolean;
+}
+declare abstract class ComponentBase<TElement extends ElementType = any, TProps extends object = any> extends Disposable {
+    readonly motif: ComponentMotif<this, TProps>;
+    element: TElement;
+    props: TProps;
+    isBuilt: boolean;
+    isInitialized: boolean;
+    isDisposed: boolean;
+    isConfigured: boolean;
+    isPainting: boolean;
+    isPainted: boolean;
+    isVisible: boolean;
+    controls: ControlCollection;
+    private _eventHandlers?;
+    private _isWait;
+    class: IClass<TElement>;
+    attr: controlAttribute<TElement>;
+    bindings: BindingCollection;
+    /** style(fn) izleyicisi: tek tek tutulur, yeniden çağrıda önceki durdurulur. */
+    private _styleFx?;
+    useModel<TModel>(modelCtor: TModel): UnwrapValueRefs<TModel>;
+    private _computeHideStrategy;
+    private _isInDom;
+    set isWait(value: boolean);
+    get isWait(): boolean;
+    constructor(element: TElement, props?: TProps);
+    childs?: any[];
+    parent: ComponentBase | null;
+    onElementCreating?(): TElement;
+    initializeComponent?(sender: ComponentBase): void;
+    onBuilding?(sender: ComponentBase, e: EventArgs): void;
+    onBuilt?(sender: ComponentBase, e: EventArgs): void;
+    onMounted?(sender: ComponentBase, e: EventArgs): void;
+    onInitializing?(sender: ComponentBase, e: EventArgs): void;
+    onInitialized?(sender: ComponentBase, e: EventArgs): void;
+    onDisposing?(sender: ComponentBase, e: EventArgs): void;
+    onDisposed?(sender: ComponentBase, e: EventArgs): void;
+    onConfig?(sender: ComponentBase, e: EventArgs): void;
+    onConfigured?(sender: ComponentBase, e: EventArgs): void;
+    onVisibilityChanged?(sender: ComponentBase, e: EventArgs): void;
+    /** keepAlive rota bileşeni outlet'ten ayrılıp önbelleğe alındığında (RoutingEngine) tetiklenir. */
+    onDeactivated?(sender: ComponentBase, e: EventArgs): void;
+    /** keepAlive rota bileşeni önbellekten outlet'e yeniden bağlandığında (RoutingEngine) tetiklenir. */
+    onActivated?(sender: ComponentBase, e: EventArgs): void;
+    view?(): ComponentBase;
+    private _scopedContext?;
+    get context(): Application;
+    build(building?: boolean): void;
+    setState(): void;
+    reState(): void;
+    setText(value: string): void;
+    style(content: CSSStyleDeclaration | string | Array<any> | Object | (() => any)): any;
+    private _stopStyleEffect;
+    private _addHandler;
+    private _show;
+    private _hide;
+    private _toggle;
+    private _on;
+    private _trigger;
+    private _off;
+    /** Süren bertaraf: ikinci bir dispose/disposeAsync çağrısı yenisini başlatmaz, bunu bekler. */
+    private _disposing?;
+    dispose(options?: IDisposeOptions): Promise<void>;
+    private _disposeCore;
+    disposeAsync(options?: IDisposeOptions): Promise<void>;
+    private _disposeAsyncCore;
+    using<T>(waitable: Promise<any>, onfulfilled?: ((value: T) => T | PromiseLike<T>) | undefined | null, onrejected?: ((reason: any) => never | PromiseLike<never>) | undefined | null): void;
+    doWork<T>(waitable: Promise<T> | PromiseLike<T>): Promise<T>;
+    siblings: {
+        all: () => ComponentBase<any, any>[] | undefined;
+        next: () => ComponentBase<any, any> | undefined;
+        prev: () => ComponentBase<any, any> | undefined;
+        nextAll: () => any;
+        prevAll: () => any;
+    };
+    get serviceProvider(): ServiceProvider | null;
+    getService<T = any>(token: any): T | null;
+    $(selector: string): {
+        fromDom: () => any;
+        fromComponent: () => ComponentBase<any, any>[];
+    };
+    private _stopAnimations;
+}
+
+declare class Component<TElement extends ElementType = any, TProps extends object = any> extends ComponentBase<TElement, TProps> {
+    static elementTag?: string;
+    static elementNamespace?: string;
+    constructor(elementOrParams: TElement | string | IBaseProp<TProps>);
+    constructor(element: TElement | string, options: IBaseProp<TProps>);
+    constructor(elementOrParams: TElement | string | IBaseProp<TProps>, options?: IBaseProp<TProps>);
+    constructor(elementOrParams?: TElement | string | IBaseProp<TProps>, options?: IBaseProp<TProps>);
+}
+type viewFn<P extends object> = (props: P) => any;
+declare function FNComponent<P extends object>(view: viewFn<P>): (props: P) => FragmentNode<any>;
+declare function motifComponent(element: unknown, props?: any): any;
+declare function motifFragment(props?: any): FragmentNode<any>;
+declare class FragmentNode<TProps extends object = any> extends Component<Comment, TProps> {
+    constructor(options?: IBaseProp<TProps>);
+    constructor(element: any, props: any);
+    initializeComponent(sender: ComponentBase): void;
+}
+
+interface LazyOptions<T = any> {
+    Loaderview?: ComponentBase;
+    Placeholderview?: ComponentBase;
+    Fallbackview?: ComponentBase;
+    minDelayMs?: number;
+    onError?: (error: unknown) => void;
+    mapResult?: (result: T) => any;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    retry?: number | LazyRetryOptions;
+    onRetry?: (attempt: number, error: unknown) => void;
+}
+interface LazyRetryOptions {
+    count: number;
+    delayMs?: number;
+    whenOnline?: boolean;
+}
+declare function Lazy<T>(props: {
+    caller: () => Promise<T>;
+    options?: LazyOptions<T>;
+}): Component;
+declare function Lazy(props: any): Component;
+
+declare class Frame extends Component {
+    current: ComponentBase | ComponentBase[] | null;
+    isBusy: boolean;
+    constructor(props?: any);
+    dispose(): Promise<void>;
+    flush(): Promise<void>;
+    previouspage: any;
+    navigate(page: ComponentBase | ComponentBase[], keepOldControl?: boolean): Promise<void>;
+    navigateLazy<T>(caller: () => Promise<T>, options?: LazyOptions<T>, keepOldControl?: boolean): Promise<void>;
+}
+
+declare function preProcessing(callback: () => any): void;
+
+interface ContentBlockProps {
+    target: string;
+}
+declare class ContentBlock extends Component<any, ContentBlockProps> {
+    constructor(props: ContentBlockProps);
+    onConfigured(sender: ComponentBase, e: EventArgs): void;
+    onDisposing(sender: ComponentBase, e: EventArgs): void;
+    ondisposing(sender: Component<any, ContentBlockProps>): void;
+}
+interface ContentBodyProps {
+    name: string;
+    onconfig?: any;
+}
+declare class ContentBody extends Component<any, ContentBodyProps> {
+    constructor(props: ContentBodyProps);
+    ondisposing(sender: Component<any, ContentBodyProps>): void;
+}
+
+declare class Transport extends Component<any, {
+    name: string;
+    mode?: 'replace' | 'merge';
+}> {
+    mode: 'replace' | 'merge';
+    constructor(props: {
+        name: string;
+        mode?: 'replace' | 'merge';
+    });
+    initializeComponent(sender: ComponentBase): void;
+    clearSlot(): void;
+}
+
+declare class TransportTo extends Component<any, {
+    name: string;
+}> {
+    private _onAddRef?;
+    private _onRemoveRef?;
+    private _slotRegisteredListener?;
+    private _slotUnregisteredListener?;
+    private _transported;
+    constructor(props: {
+        name: string;
+    });
+    private _handleSlotChange;
+    private _clearChildrenFromSlot;
+    initializeComponent(sender: ComponentBase): void;
+    onDisposing(sender: ComponentBase, e: EventArgs): void;
+}
+
+interface TransportOptions {
+    index?: number;
+    keepState?: boolean;
+    owner?: any;
+}
+declare class Transporter {
+    static transport(child: ComponentBase, newParent: ComponentBase, options?: TransportOptions): void;
+    static transportMany(children: ComponentBase[], newParent: ComponentBase, options?: TransportOptions): void;
+    static createSlot(name: string, parent?: ComponentBase): {
+        name: string;
+        children: ComponentBase[];
+        parent: ComponentBase | undefined;
+        mount(child: ComponentBase, options?: TransportOptions): void;
+        unmount(child: ComponentBase): void;
+        detachAll(): void;
+    };
+}
+
+interface VirtualizationDataRequest {
+    page: number;
+    pageSize: number;
+    scrollTop: number;
+}
+interface VirtualizationDataResponse<T> {
+    items: T[];
+    totalCount: number;
+    hasMore: boolean;
+}
+interface VirtualizationState<T> {
+    isLoading: boolean;
+    isInitialized: boolean;
+    currentPage: number;
+    totalCount: number;
+    hasMore: boolean;
+    error?: Error;
+    data: T[];
+}
+interface VirtualizationProps<T> {
+    dataRequest: (request: VirtualizationDataRequest) => Promise<VirtualizationDataResponse<T>>;
+    itemTemplate: (item: T, index: number) => any;
+    itemHeight: number | ((item: T, index: number) => number);
+    pageSize?: number;
+    renderMode?: 'item' | 'page';
+    mainTemplate?: (content: Component, state: VirtualizationState<T>) => any;
+    loadingTemplate?: (state: VirtualizationState<T>) => any;
+    emptyTemplate?: () => any;
+    errorTemplate?: (error: Error) => any;
+    overscan?: number;
+    autoLoad?: boolean;
+    autoLoadThreshold?: number;
+    overscanPages?: number;
+    pageBuffer?: number;
+    className?: string;
+    style?: Partial<CSSStyleDeclaration>;
+    filter?: (item: T[]) => T[];
+    cacheSize?: number;
+    autoRefresh?: boolean;
+    watch?: () => unknown;
+}
+declare class Virtualization<T = any> extends Component<HTMLDivElement, VirtualizationProps<T>> {
+    private readonly _state;
+    private _virtualContent;
+    private _topSpacer;
+    private _bottomSpacer;
+    private _cache;
+    private _view;
+    private _occurrence;
+    private _occurrenceKeys;
+    private _isLoadingMore;
+    private _emptyRendered;
+    private _renderPending;
+    constructor(props: VirtualizationProps<T>);
+    contentWrapper: Component<any, any>;
+    wrapper: Component;
+    private _makeView;
+    private _initialLoadStarted;
+    onBuilding(): void;
+    onMounted(): void;
+    onDisposing(): void;
+    private _offsets;
+    private _resizeObserver?;
+    private _observed?;
+    private _observedHeight;
+    private _fixedHeight;
+    private _computeOffsets;
+    private _layoutOffsets;
+    private _offsetOf;
+    private _indexAt;
+    private _observeResize;
+    private _stopResizeObserver;
+    private _loadSeq;
+    private _dataWatchStop?;
+    private _reloadScheduled;
+    private _reloadTimes;
+    private _stopDataWatch;
+    /**
+     * dataRequest'i çağırır. `watch` açıksa çağrının senkron kısmında okunan reaktif veriyi izler;
+     * değişince yeniden yükleme planlar. Aksi hâlde çağrı hiçbir dış effect'e bağımlılık sızdırmaz.
+     */
+    private _request;
+    private _scheduleReload;
+    /** Yüklü aralığı (0..currentPage) tek istekte yeniden alır; içerik yanıt gelene kadar kalır. */
+    private _reloadLoaded;
+    private _handleScroll;
+    private _loadInitial;
+    private _loadMore;
+    private _rebuildView;
+    private _clearContent;
+    private renderViewport;
+    private _occurrenceKey;
+    private _rowFor;
+    private _detachRow;
+    private _evictCache;
+    private _renderLoadingState;
+    private _renderEmptyState;
+    private _renderErrorState;
+    refresh(): Promise<void>;
+    setData(data: T[]): void;
+    scrollToIndex(index: number): void;
+    getState(): Readonly<VirtualizationState<T>>;
+}
+
+declare const dom: {
+    readonly window: any;
+    document: any;
+    createElement(tagName: string, options?: any): any;
+    createDocumentFragment(): any;
+    createComment(content: any): any;
+    createTextNode(content: any): any;
+    querySelectorAll(selectors: string): any;
+    createElementNS(namepsaceUri: string, tagName: string, options?: any): any;
+    convertToSvgElement(element: Element): Element;
+    readonly body: any;
+};
+
+declare class ControlCollection {
+    private owner;
+    constructor(owner: ComponentBase);
+    items: ComponentBase[];
+    add(...control: ComponentBase[]): ComponentBase[];
+    add(index?: number, ...control: ComponentBase[]): ComponentBase[];
+    insert(index?: number, ...controls: ComponentBase[]): ComponentBase[];
+    remove(control: ComponentBase): void;
+    detach(control: ComponentBase): Promise<void>;
+    silentDetach(control: ComponentBase, unlinkOnly?: boolean): void;
+    silentUnlink(control: ComponentBase): void;
+    clearAsync(): Promise<void>;
+    clear(): void;
+    get length(): number;
+    forEach(callbackfn: (value: ComponentBase, index: number, array: ComponentBase[]) => void): void;
+    map(callbackfn: (value: ComponentBase, index: number, array: ComponentBase[]) => void): void[];
+    onAdd?: (control: ComponentBase) => void;
+    onRemove?: (control: ComponentBase) => void;
+    onAddBeforeBuild?: (control: ComponentBase) => void;
+    move(control: ComponentBase, before?: ComponentBase | null): void;
+    moveToIndex(control: ComponentBase, index: number): void;
+}
+
+declare class NameValuePair<KType, VType> {
+    Key: KType;
+    value: VType;
+}
+
+declare class List<T> {
+    ItemAdded: (i: T) => void;
+    ItemAddedBefore: (i: T) => void;
+    ItemSplice: (start: any, i: T) => void;
+    private __list;
+    private _map;
+    Dispose(): void;
+    Add(item: T): number;
+    AddBefore(item: T): number;
+    Insert(start: any, item: T): T[];
+    get items(): Array<T>;
+    clear(): T[];
+    get count(): number;
+    remove(item: T): T[];
+    indexOf(item: T): number;
+    FindFromKey(key: any, value: any): T[];
+    removeIndex(index: number): T[];
+    has(item: T): boolean;
+    item(index: number): T;
+    forEach(callbackfn: (value: T, index: number, array: T[]) => void): void;
+    ReverseClone(): Array<T>;
+    filter(callbackfn: (value: T, index: number, array: T[]) => boolean): Array<T>;
+}
+
+declare function toDisposable(fn: () => void): IDisposable;
+
+declare class ErrorHandler {
+    private unexpectedErrorHandler;
+    private listeners;
+    private _isDevelopment;
+    private _enableConsoleLogging;
+    setDevelopmentMode(isDev: boolean): void;
+    setConsoleLogging(enabled: boolean): void;
+    isDevelopment(): boolean;
+    reportSuppressed(context: string, error: any): void;
+    report(error: Error): void;
+    private logIfDev;
+    private serializeError;
+    addListener(listener: (error: any) => void): () => void;
+    private emit;
+    setUnexpectedErrorHandler(handler: (e: any) => void): void;
+    getUnexpectedErrorHandler(): (e: any) => void;
+    onUnexpectedError(error: any): void;
+    safeCall<T>(fn: () => T, context: string, fallback?: T): T | undefined;
+    safeCallAsync<T>(fn: () => Promise<T>, context: string, fallback?: T): Promise<T | undefined>;
+    safeCallSilent(fn: () => void, context: string): void;
+    safeCallSilentAsync<T>(fn: () => Promise<T>, context: string): Promise<T | undefined>;
+    wrapSafe<TArgs extends any[], TReturn>(fn: (...args: TArgs) => TReturn, context: string): (...args: TArgs) => TReturn | undefined;
+    wrapSafeAsync<TArgs extends any[], TReturn>(fn: (...args: TArgs) => Promise<TReturn>, context: string): (...args: TArgs) => Promise<TReturn | undefined>;
+}
+declare const errorHandler: ErrorHandler;
+declare function safeCall<T>(fn: () => T, context: string, fallback?: T): T | undefined;
+declare function safeCallAsync<T>(fn: () => Promise<T>, context: string, fallback?: T): Promise<T | undefined>;
+declare function safeCallSilent<T>(fn: () => T, context: string): void;
+declare function setUnexpectedErrorHandler(handler: (e: any) => void): void;
+
+declare class Dictionary<KType, VType> {
+    private __values;
+    Add(Key: KType, Value: VType): number;
+    has(key: KType): boolean;
+    item(key: KType): NameValuePair<KType, VType>;
+    OnItemAdded: (key: KType, value: VType) => any;
+    removeIndex(index: number): NameValuePair<KType, VType>[];
+    remove(Key: KType): void;
+    clear(): void;
+    forEach(callback: ((item: NameValuePair<KType, VType>) => void)): void;
+    get values(): List<NameValuePair<KType, VType>>;
+    filter(callbackfn: (value: NameValuePair<KType, VType>, index: number, array: NameValuePair<KType, VType>[]) => boolean): NameValuePair<KType, VType>[];
+    find(predicate: (value: NameValuePair<KType, VType>, index: number, obj: NameValuePair<KType, VType>[]) => unknown, thisArg?: any): NameValuePair<KType, VType> | undefined;
+}
+
+interface IAttribute<BaseType> {
+    add(attribute: object | string): BaseType;
+    remove(key: string): BaseType;
+    has(key: string): boolean;
+    get(key: string): string | null;
+}
+interface IClass<BaseType> {
+    add(...values: (string | any[] | {} | Function)[]): BaseType;
+    remove(classNames: string[] | string): BaseType;
+    has(className: string): boolean;
+}
+
+declare class LinkedList<T> {
+    private _ring;
+    private _count;
+    get size(): number;
+    isEmpty(): boolean;
+    push(value: T): () => void;
+    unshift(value: T): () => void;
+    pop(): T | undefined;
+    shift(): T | undefined;
+    clear(): void;
+    [Symbol.iterator](): Iterator<T>;
+    private _link;
+    private _take;
+    private _unlink;
+}
+
+type Bind<T> = T | (() => T);
+declare function toGetter<T>(value: Bind<T>): () => T;
+declare function read<T>(value: Bind<T>): T;
+
+interface Group<TKey, TElement> {
+    key: TKey;
+    items: TElement[];
+}
+declare class Query<T> implements Iterable<T> {
+    private readonly source;
+    constructor(source: Iterable<T>);
+    static from<T>(source: Iterable<T>): Query<T>;
+    where(predicate: (item: T, index: number) => boolean): Query<T>;
+    select<TResult>(selector: (item: T, index: number) => TResult): Query<TResult>;
+    orderBy<TKey>(keySelector: (item: T) => TKey): Query<T>;
+    orderByDescending<TKey>(keySelector: (item: T) => TKey): Query<T>;
+    distinctBy<TKey>(keySelector: (item: T) => TKey): Query<T>;
+    groupBy<TKey>(keySelector: (item: T) => TKey): Query<Group<TKey, T>>;
+    first(): T;
+    firstOrDefault(): T | undefined;
+    any(predicate?: (item: T) => boolean): boolean;
+    all(predicate: (item: T) => boolean): boolean;
+    aggregate<TResult>(seed: TResult, func: (acc: TResult, item: T) => TResult): TResult;
+    toArray(): T[];
+    [Symbol.iterator](): Iterator<T>;
+}
+
+declare const motifMessages: {
+    MJX101: (tag: string) => string;
+    MJX102: (description: string) => string;
+    MJX103: (tag: string) => string;
+    MJX104: () => string;
+    MJX105: () => string;
+    MJX106: () => string;
+    MJX107: () => string;
+    MJX108: () => string;
+    MJX109: () => string;
+    MJX110: (ms: number) => string;
+    MJX111: () => string;
+    MJX112: (depth: number) => string;
+    MJX113: () => string;
+    MJX114: () => string;
+    MJX115: () => string;
+    MJX116: (ms: number) => string;
+    MJX117: () => string;
+    MJX118: () => string;
+    MJX119: () => string;
+    MJX120: () => string;
+    MJX121: (compiled: number, runtime: number) => string;
+    MJX122: (hook: string) => string;
+    MJX123: (event: string) => string;
+    MJX201: () => string;
+    MJX202: (key: unknown, index: number) => string;
+    MJX203: (max: number) => string;
+    MJX204: () => string;
+    MJX205: () => string;
+    MJX206: () => string;
+    MJX207: () => string;
+    MJX208: () => string;
+    MJX301: (outlet: string, ms: number) => string;
+    MJX302: (name: string) => string;
+    MJX303: (chain: string) => string;
+    MJX304: () => string;
+    MJX305: () => string;
+    MJX306: (hook: string) => string;
+    MJX307: () => string;
+    MJX308: () => string;
+    MJX309: () => string;
+    MJX310: (parentPath: string) => string;
+    MJX311: (path: string, parentPath: string) => string;
+    MJX312: (full: string) => string;
+    MJX313: (full: string) => string;
+    MJX314: (alias: string, parentPath: string) => string;
+    MJX315: (alias: string) => string;
+    MJX316: (alias: string) => string;
+    MJX401: (token: string) => string;
+    MJX402: (token: string) => string;
+    MJX403: () => string;
+    MJX404: (chain: string) => string;
+    MJX405: () => string;
+    MJX406: (selector: string) => string;
+    MJX407: (token: string) => string;
+    MJX408: (token: string, reason: string) => string;
+    MJX409: (token: string) => string;
+    MJX410: (token: string, sources: string) => string;
+    MJX411: (token: string) => string;
+    MJX413: (token: string) => string;
+    MJX414: (token: string, reason: string) => string;
+    MJX501: () => string;
+    MJX502: () => string;
+    MJX503: () => string;
+    MJX504: () => string;
+    MJX505: () => string;
+    MJX507: (name: string, limit: number, count: number) => string;
+    MJX601: () => string;
+    MJX602: () => string;
+    MJX603: () => string;
+    MJX604: () => string;
+    MJX605: () => string;
+    MJX607: () => string;
+    MJX608: () => string;
+    MJX609: () => string;
+    MJX610: () => string;
+    MJX611: () => string;
+};
+type MotifErrorCode = keyof typeof motifMessages;
+declare class MotifError extends Error {
+    readonly code: MotifErrorCode;
+    constructor(code: MotifErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+
+declare function motifCompiled(contract: number): void;
+
+declare enum NodeTypes {
+    ELEMENT_NODE = 1,
+    ATTRIBUTE_NODE = 2,
+    TEXT_NODE = 3,
+    CDATA_SECTION_NODE = 4,
+    ENTITY_REFERENCE_NODE = 5,
+    /**deprecated */
+    ENTITY_NODE = 6,
+    /**deprecated */
+    PROCESSING_INSTRUCTION_NODE = 7,
+    COMMENT_NODE = 8,
+    DOCUMENT_NODE = 9,
+    DOCUMENT_TYPE_NODE = 10,
+    DOCUMENT_FRAGMENT_NODE = 11,
+    /**deprecated */
+    NOTATION_NODE = 12
+}
+
+declare class Signal<T> {
+    private _value;
+    private readonly _target;
+    private readonly _key;
+    private readonly _equals;
+    private _disposed;
+    static create<U>(initialValue: U, equals?: (a: U, b: U) => boolean): Signal<U>;
+    constructor(initialValue: T, equals?: (a: T, b: T) => boolean);
+    get value(): T;
+    set value(newValue: T);
+    peek(): T;
+    update(updater: (prev: T) => T): void;
+    mutate(mutator: (draft: T) => void): void;
+    notify(): void;
+    asReadonly(): ReadonlySignal<T>;
+    dispose(): void;
+    valueOf(): T;
+    toString(): string;
+}
+interface ReadonlySignal<T> {
+    readonly value: T;
+    peek(): T;
+    valueOf(): T;
+    toString(): string;
+}
+declare class Computed<T> {
+    private _value;
+    private _dirty;
+    private _computing;
+    private readonly _target;
+    private readonly _key;
+    private readonly _getter;
+    private _cleanup?;
+    constructor(getter: () => T);
+    get value(): T;
+    peek(): T;
+    dispose(): void;
+    valueOf(): T;
+    toString(): string;
+}
+declare class LazyComputed<T> {
+    private _value;
+    private _dirty;
+    private _disposed;
+    private readonly _target;
+    private readonly _key;
+    private readonly _getter;
+    private readonly _runner;
+    constructor(getter: () => T);
+    get value(): T;
+    peek(): T;
+    get isDirty(): boolean;
+    private _refresh;
+    dispose(): void;
+    valueOf(): T;
+    toString(): string;
+}
+
+type EffectFn = () => void;
+declare class Effect {
+    fn: EffectFn;
+    private callback?;
+    deps: [object, string | symbol][];
+    active: boolean;
+    running: boolean;
+    scheduler?: () => void;
+    constructor(fn: EffectFn, callback?: ((value: unknown) => void) | undefined);
+    run(): void;
+    stop(): void;
+}
+declare function configureReactivityLeakMonitor(opts?: {
+    enabled?: boolean;
+    threshold?: number;
+    name?: string;
+}): void;
+declare function effect(fn: EffectFn, onValueChanged?: <T>(value: T) => void): () => void;
+interface AsyncTrackingToken {
+    effect: Effect | undefined;
+    pushed: boolean;
+}
+declare const asyncTracking: {
+    capture(): AsyncTrackingToken;
+    suspend<T>(t: AsyncTrackingToken, value: T): T;
+    resume<T>(t: AsyncTrackingToken, value: T): T;
+    end(t: AsyncTrackingToken): void;
+};
+declare function untracked<T>(fn: () => T): T;
+
+declare function reactive<T>(model: T): UnwrapValueRefs<T>;
+declare function useModel<T>(model: T): UnwrapValueRefs<T>;
+declare function clearModel(model: any): void;
+declare function deepClone(item: any): any;
+declare function createSignal<T>(initialValue: T): Signal<T>;
+declare function createComputed<T>(getter: () => T): Computed<T>;
+declare function createLazyComputed<T>(getter: () => T): LazyComputed<T>;
+
+declare function inject<T>(token: abstract new (...args: any[]) => T): T;
+declare function inject<T = any>(token: string | symbol | object): T;
+declare class ServiceProvider {
+    private services;
+    private parent?;
+    private root;
+    private scopeName?;
+    private kind;
+    private singletonCache;
+    private scopedCache;
+    private transientSet;
+    private _autoDisposeTransients;
+    private pendingSingleton;
+    private pendingScoped;
+    private _navigation?;
+    private _ownerlessSlot;
+    private _navigationDisposed;
+    constructor(services: ServiceCollection, parent?: ServiceProvider, root?: ServiceProvider);
+    createScope(name?: string): ServiceProvider;
+    enableAutoDisposeTransients(enable?: boolean): this;
+    get<T = any>(token: any): T;
+    getAsync<T = any>(token: any): Promise<T>;
+    getAllServices(): ServiceCollection;
+    private _releaseIfUnused;
+    private _scopeFor;
+    private _handle;
+    private _handleAsync;
+    private _createHandle;
+    private _isSystemScope;
+    private _scopedInstanceSync;
+    private _scopedInstanceAsync;
+    private resolveDescriptorSync;
+    private resolveDescriptorAsync;
+    private construct;
+    private instantiateSync;
+    private instantiateAsyncIn;
+    private instantiateAsync;
+    dispose(): Promise<void>;
+    private resolveDepsSync;
+    private resolveDepsAsyncIn;
+    private injectionResolver;
+    private getDeps;
+    private resolveTokenSync;
+    private resolveTokenAsync;
+    private checkCycle;
+    private describeToken;
+    private describeTokenWithSource;
+}
+
+type ServiceLifetime = 'transient' | 'singleton' | 'scoped';
+type ServiceImplementation<V> = V extends abstract new (...args: any[]) => any ? V : V extends (...args: any[]) => any ? 'Use { useValue: fn } or { useFactory: fn } to register a function' : V;
+interface ServiceDescriptor<T = any> {
+    token: any;
+    lifetime: ServiceLifetime;
+    useClass?: new (...args: any[]) => T;
+    useFactory?: (...args: any[]) => T | Promise<T>;
+    useValue?: T;
+    deps?: any[];
+}
+declare class ServiceCollection {
+    private descriptors;
+    reset(): void;
+    addTransient<V>(token: any, impl: ServiceImplementation<V>): void;
+    addSingleton<V>(token: any, impl: ServiceImplementation<V>): void;
+    addScoped<V>(token: any, impl: ServiceImplementation<V>): void;
+    private _add;
+    private _tokenName;
+    getDescriptor(token: any): ServiceDescriptor | null;
+    /** `@Injectable` ile işaretlenmiş ama henüz kaydedilmemiş bir token var mı? */
+    canAutoRegister(token: any): boolean;
+    getService(token: any): ServiceDescriptor | null;
+    buildServiceProvider(): ServiceProvider;
+    has(token: any): boolean;
+    remove(token: any): boolean;
+    replace<V>(token: any, impl: ServiceImplementation<V>, lifetime?: ServiceLifetime): void;
+    tryAddTransient<V>(token: any, impl: ServiceImplementation<V>): boolean;
+    tryAddSingleton<V>(token: any, impl: ServiceImplementation<V>): boolean;
+    tryAddScoped<V>(token: any, impl: ServiceImplementation<V>): boolean;
+    autoRegisterInjectables(): void;
+}
+
+interface RouterValidateEventArgs {
+    uri: string;
+    key: any;
+    routes: Map<any, RouteItem>;
+    params: Record<string, any>;
+}
+type RouteControl = ComponentBase | (() => ComponentBase) | (() => Promise<ComponentBase>) | Promise<ComponentBase> | Promise<any> | any;
+type RedirectTarget = {
+    path: string;
+    params: Record<string, any>;
+    meta: Record<string, any>;
+};
+type RouteRedirect = string | ((to: RedirectTarget) => string);
+type RouteItem = RouteItemBase & ({
+    control: RouteControl;
+    redirect?: RouteRedirect;
+} | {
+    control?: RouteControl;
+    redirect: RouteRedirect;
+});
+interface RouteItemBase {
+    path: string;
+    childs?: RouteItem[];
+    extend?: Record<string, any>;
+    meta?: Record<string, any>;
+    keepAlive?: boolean;
+    name?: string | null;
+    validate?: (e: RouterValidateEventArgs) => boolean;
+    onShow?: (e: ComponentBase) => void;
+    onEntering?: (context: {
+        path?: string;
+        params?: Record<string, any>;
+        meta?: Record<string, any>;
+        to?: {
+            path: string;
+            params: Record<string, any>;
+            meta: Record<string, any>;
+        };
+    }) => void | Promise<void>;
+    onEnter?: (context: {
+        path?: string;
+        params?: Record<string, any>;
+        meta?: Record<string, any>;
+        to?: {
+            path: string;
+            params: Record<string, any>;
+            meta: Record<string, any>;
+        };
+    }) => void | Promise<void>;
+    onLeave?: (context: {
+        from: {
+            path: string;
+            params: Record<string, any>;
+            meta: Record<string, any>;
+        };
+        to: {
+            path: string;
+            params: Record<string, any>;
+            meta: Record<string, any>;
+        };
+    }) => boolean | void | {
+        cancel: true;
+        reason?: string;
+    } | Promise<boolean | void | {
+        cancel: true;
+        reason?: string;
+    }>;
+    onUpdate?: (context: {
+        from: {
+            path: string;
+            params: Record<string, any>;
+        };
+        to: {
+            path: string;
+            params: Record<string, any>;
+        };
+        meta: Record<string, any>;
+    }) => void | Promise<void>;
+    alias?: string | string[];
+    fullPath?: string | null;
+}
+
+type RouteResolveContext = {
+    uri: string;
+    context: Application;
+    rewritePath: (uri: string) => void;
+};
+type NavigationDirection = 'initial' | 'push' | 'replace' | 'back' | 'forward' | 'traverse';
+type NavigationOptions = {
+    replace?: boolean;
+    state?: any;
+    force?: boolean;
+    scroll?: 'top' | 'smooth' | 'instant' | {
+        top?: number;
+        left?: number;
+        behavior?: ScrollBehavior;
+    };
+};
+type ScrollMemoryOptions = {
+    top?: boolean;
+    anchor?: boolean;
+    settleMs?: number;
+    persist?: boolean;
+    limit?: number;
+    key?: (path: string) => string;
+    container?: string | HTMLElement | (() => HTMLElement | null | undefined);
+};
+type StackTransitionContext = {
+    direction: NavigationDirection;
+    entering: HTMLElement | null;
+    leaving: HTMLElement | null;
+};
+type StackSwipeBackOptions = {
+    edge?: number;
+    threshold?: number;
+};
+type StackOptions = {
+    retain?: boolean;
+    depth?: number;
+    persist?: boolean;
+    animation?: 'none' | 'slide' | ((context: StackTransitionContext) => Promise<void> | void);
+    duration?: number;
+    swipeBack?: boolean | StackSwipeBackOptions;
+};
+type StackEntryInfo = {
+    index: number;
+    uri: string;
+    current: boolean;
+    retained: boolean;
+};
+type RouterOptions = {
+    mode?: 'history' | 'hash' | 'file' | 'shell';
+    fallbacks?: {
+        notFound?: any;
+        error?: any;
+    };
+    middlewareCollections?: () => Array<(ctx: RouteResolveContext, next: () => Promise<void>) => any>;
+    RouteItems: RouteItem[];
+    hooks?: RouterEvents;
+    scrollMemory?: boolean | ScrollMemoryOptions;
+    stack?: boolean | StackOptions;
+};
+interface ResolveResult {
+    ok: boolean;
+    uri: string;
+    fullPath: string | null;
+    route: RouteItem | null;
+    chain: RouteItem[];
+    params: Record<string, any>;
+    extend: Record<string, any>;
+    meta?: Record<string, any>;
+    aliasOf?: string | null;
+}
+type Router = {
+    readonly params: Record<string, any>;
+    readonly route: RouteItem | null;
+    readonly ok: boolean;
+    readonly uri: string;
+    readonly fullPath: string | null;
+    readonly aliasOf: string | null;
+    navigate: (uri: string, options?: NavigationOptions) => Promise<void>;
+    navigateByName: (name: string, params?: Record<string, any>, options?: NavigationOptions) => Promise<void>;
+    evict: (route?: RouteItem | string | null) => Promise<void>;
+    readonly chain: string[];
+    readonly extend: Record<string, any>;
+    readonly meta: Record<string, any>;
+    readonly direction?: NavigationDirection;
+    readonly state?: any;
+    readonly stack?: StackEntryInfo[];
+    resolve: (uri: string) => ResolveResult;
+    href: (name: string, params?: Record<string, any>) => string;
+    readonly routes: RouteInfo[];
+};
+type RouteInfo = {
+    fullPath: string;
+    name: string | null;
+    meta: Record<string, any>;
+    route: RouteItem;
+    chain: RouteItem[];
+};
+/** `motifjs-router-navigated` olayının (`app.onRouterChanged`) yükü. */
+type RouterNavigatedEventArgs = {
+    uri: string;
+    params: Record<string, any>;
+    meta: Record<string, any>;
+    route: RouteItem | null;
+    ok: boolean;
+    /** Açılış (ilk) navigasyonu mu? */
+    initial: boolean;
+    redirectedFrom?: string;
+    direction?: NavigationDirection;
+    state?: any;
+};
+type RouterEvents = {
+    onEntering?: RouteItem['onEntering'];
+    onEnter?: RouteItem['onEnter'];
+    onLeave?: RouteItem['onLeave'];
+    onUpdate?: RouteItem['onUpdate'];
+};
+
+interface RouterViewProps extends IBaseProp<{
+    name?: string;
+}> {
+}
+declare class RouterView extends Component {
+    constructor(props: IBaseProp<RouterViewProps>);
+    get scopeId(): string;
+    disposingChilds: boolean;
+    previouspage: any;
+    current: ComponentBase | ComponentBase[] | null;
+    isBusy: boolean;
+    navigate(page: ComponentBase | ComponentBase[], keepOldControl?: boolean): Promise<void>;
+    disposeTarget(target: ComponentBase | ComponentBase[] | null): Promise<void>;
+    onBuilt(): void;
+    onDisposed(): void;
+}
+
+type RouterLinkOptions = {
+    to: string;
+    el?: string | Node;
+    showHref?: boolean;
+    text?: string;
+    exactClass?: string;
+    activeClass?: string;
+    bypass?: boolean;
+    target?: string;
+    onExact?: () => void;
+    offExact?: () => void;
+    onActive?: () => void;
+    offActive?: () => void;
+};
+declare class RouterLink extends Component<any, RouterLinkOptions> {
+    constructor(props: RouterLinkOptions);
+    onBuilt(sender: ComponentBase, e: EventArgs): void;
+}
+
+declare class ApplicationBuilder {
+    services: ServiceCollection;
+    constructor();
+    build(): Application;
+    rebuild(): Application;
+}
+interface ApplicationEvents {
+    'router-changed': 'motifjs-router-navigated';
+}
+type AppLifecycleState = 'visible' | 'hidden' | 'frozen' | 'resumed' | 'restored' | 'online' | 'offline';
+type AppLifecycleEventArgs = {
+    state: AppLifecycleState;
+    visible: boolean;
+    online: boolean;
+};
+type NavigationGuardContext = {
+    to: {
+        path: string;
+        params: Record<string, any>;
+        meta: Record<string, any>;
+        options?: NavigationOptions;
+        redirectedFrom?: string;
+        direction?: NavigationDirection;
+        state?: any;
+    };
+    from: {
+        path: string;
+        params: Record<string, any>;
+        meta: Record<string, any>;
+        options?: NavigationOptions;
+    } | null;
+};
+type NavigationGuard = (context: NavigationGuardContext, next: (redirect?: string | false) => void) => void | Promise<void>;
+declare class Application {
+    provider: ServiceProvider;
+    static get main(): Application;
+    constructor(provider: ServiceProvider);
+    private _middlewares;
+    private _beforeEachGuards;
+    readonly router: Router;
+    private events;
+    static CreateBuilder(): ApplicationBuilder;
+    private appShell;
+    getAppShell(): Component;
+    run(host: HTMLElement | string | Node, appRoot?: any): void;
+    insert(component: Component): void;
+    remove(component: Component): void;
+    attach(component: Component): void;
+    detach(component: Component): void;
+    appendToMainHost(component: Node): void;
+    dispose(): void;
+    use(callback: (ctx: RouteResolveContext, next: () => Promise<void>) => any): Application;
+    useGuard(guard: NavigationGuard): Application;
+    private urlRoutingModule;
+    private _routerConfig;
+    private _routerRoot;
+    private _startedRouter;
+    useRouter(options: RouteItem[] | {
+        routes: RouteItem[];
+        mode?: 'history' | 'hash' | 'file' | 'shell';
+        fallbacks?: {
+            notFound?: any;
+            error?: any;
+        };
+        hooks?: RouterEvents;
+        scrollMemory?: boolean | ScrollMemoryOptions;
+        stack?: boolean | StackOptions;
+    }): Application;
+    restartRouter(): this;
+    navigate(uri: string, options?: NavigationOptions): Promise<any>;
+    navigateByName(name: string, params?: Record<string, any>, options?: NavigationOptions): Promise<any>;
+    on<T>(event: ApplicationEvents[keyof ApplicationEvents & string] | any, handler: (args?: T) => void): any;
+    off<T>(event: any, handler: (args?: T) => void): void;
+    fire<T>(event: any, args?: T): void;
+    onRouterChanged(handler: (args?: RouterNavigatedEventArgs) => unknown): any;
+    get isVisible(): boolean;
+    get isOnline(): boolean;
+    private _lifecycleOff;
+    onLifecycle(handler: (args?: AppLifecycleEventArgs) => unknown): () => void;
+    private _emitLifecycle;
+    private _installLifecycleListeners;
+    private _removeLifecycleListeners;
+    private _isDevelopment;
+    private _enableErrorLogging;
+    get isDevelopmentModeEnabled(): boolean;
+    /** Enable reactive leak monitoring (dev önerilir) */
+    useReactiveMonitor(opts?: {
+        enabled?: boolean;
+        threshold?: number;
+        name?: string;
+    }): this;
+    useDevelopment(isDev?: boolean): this;
+    useLogging(enabled?: boolean): this;
+}
+declare function useNavigation(): Router;
+declare function useApplication(): {
+    application: Application;
+    services: ServiceProvider;
+    router: Router;
+    attach(...components: ComponentBase[]): void;
+};
+
+declare function Injectable(options?: {
+    lifetime?: ServiceLifetime;
+    deps?: any[];
+}): (target: any, context?: ClassDecoratorContext) => void;
+declare function FromService<T = any>(token: any): T;
+
+type AsyncOrSync<T> = Promise<T> | T;
+interface Context {
+    [key: string]: any;
+}
+type Action<T> = (ctx?: Context) => AsyncOrSync<T>;
+type ShouldHandlePredicate = (err: any) => boolean;
+declare abstract class Policy {
+    abstract execute<T>(action: Action<T>, ctx?: Context): Promise<T>;
+}
+interface RetryOptions {
+    retries?: number;
+    backoff?: 'fixed' | 'exponential' | 'none';
+    delay?: number;
+    jitter?: number;
+    shouldHandle?: ShouldHandlePredicate;
+    onRetry?: (attempt: number, err: any, delayMs: number, ctx?: Context) => void | Promise<void>;
+}
+interface TimeoutOptions {
+    timeoutMs: number;
+}
+type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+interface CircuitBreakerOptions {
+    failureThreshold?: number;
+    successThreshold?: number;
+    durationOfBreakMs?: number;
+    shouldHandle?: ShouldHandlePredicate;
+    onStateChange?: (oldState: CircuitState, newState: CircuitState) => void | Promise<void>;
+}
+interface BulkheadOptions {
+    maxConcurrent?: number;
+    maxQueue?: number;
+}
+interface RateLimiterOptions {
+    tokensPerInterval?: number;
+    intervalMs?: number;
+    capacity?: number;
+}
+interface FallbackOptions<T> {
+    fallback: (err: any, ctx?: Context) => AsyncOrSync<T>;
+    shouldHandle?: ShouldHandlePredicate;
+}
+declare function decorate<T>(policy: Policy, fn: Action<T>): (ctx?: Context) => Promise<T>;
+declare class Resilience {
+    static get create(): Resilience;
+    private resiliences;
+    retry: (opts?: RetryOptions) => Resilience;
+    timeout: (opts: TimeoutOptions) => Resilience;
+    circuitBreaker: (opts?: CircuitBreakerOptions) => Resilience;
+    bulkhead: (opts?: BulkheadOptions) => Resilience;
+    rateLimiter: (opts?: RateLimiterOptions) => Resilience;
+    fallback: <T>(opts: FallbackOptions<T>) => Resilience;
+    execute<T>(action: Action<T>, ctx?: Context): Promise<T>;
+}
+
+export { Application, ApplicationBuilder, Component, ComponentBase, ComponentMotif, Computed, ContentBlock, ContentBody, ControlCollection, Dictionary, Disposable, DisposableStore, Emitter, ErrorHandler, FNComponent, FragmentNode, Frame, FromService, Injectable, Lazy, LazyComputed, LinkedList, List, MotifError, NameValuePair, NodeTypes, Query, Resilience, RouterLink, RouterView, ServiceCollection, ServiceProvider, Signal, Transport, TransportTo, Transporter, Virtualization, asyncTracking, clearModel, configureReactivityLeakMonitor, createComputed, createLazyComputed, createSignal, decorate, deepClone, disposableCore, dom, effect, errorHandler, inject, motifCompiled, motifComponent, motifFragment, preProcessing, reactive, read, safeCall, safeCallAsync, safeCallSilent, setUnexpectedErrorHandler, toDisposable, toGetter, untracked, useApplication, useModel, useNavigation };
+export type { AnyEvents, AppLifecycleEventArgs, AppLifecycleState, AsyncTrackingToken, Bind, CSSTransitionInfo, ComponentBaseOptions, CustomParameters, EffectFn, ElementType, Event$1 as Event, EventArgs, Group, HtmlElementEvents, IAttribute, IBaseProp, IClass, IDisposable, IDisposableTracker, IDisposeOptions, IElement, IHtmlElement, IsOptional, LazyOptions, LazyRetryOptions, MotifErrorCode, NavigationDirection, NavigationGuard, NavigationGuardContext, NavigationOptions, OptionalParams, ReadonlySignal, RedirectTarget, ResolveResult, RouteControl, RouteInfo, RouteItem, RouteItemBase, RouteRedirect, RouteResolveContext, Router, RouterClassingSettings, RouterEvents, RouterNavigatedEventArgs, RouterOptions, RouterValidateEventArgs, RouterViewProps, ScrollMemoryOptions, ServiceDescriptor, ServiceLifetime, StackEntryInfo, StackOptions, StackSwipeBackOptions, StackTransitionContext, TransitionProps, TransportOptions, VirtualizationDataRequest, VirtualizationDataResponse, VirtualizationProps, VirtualizationState };