import { AbstractControl } from '@angular/forms';
import * as i0 from '@angular/core';
import { Signal, TemplateRef, InputSignal } from '@angular/core';
import { SkeletonAdapterComponent, Schema, TSchemaConfig, ISkeletonizerColorSchema, SkeletonAbstractComponent as SkeletonAbstractComponent$1 } from '@skeletonizer/utils';

declare module '@skeletonizer/utils' {
    interface ISchemaLeafTypes {
        angularAbstractControl: AbstractControl;
        angularSignal: Signal<unknown>;
    }
}

declare class SkeletonizerSkeletonComponent<T extends object, Scope extends T> extends SkeletonAdapterComponent<T> {
    readonly templateRef: TemplateRef<{
        $implicit: Schema<T> | Scope;
    }>;
    readonly showSkeleton: InputSignal<boolean>;
    readonly scope: InputSignal<Scope>;
    readonly configInput: InputSignal<TSchemaConfig<T>>;
    readonly colorSchema: InputSignal<ISkeletonizerColorSchema | undefined>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonizerSkeletonComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonizerSkeletonComponent<any, any>, "skeletonizer-skeleton", never, { "showSkeleton": { "alias": "showSkeleton"; "required": true; "isSignal": true; }; "scope": { "alias": "scope"; "required": true; "isSignal": true; }; "configInput": { "alias": "config"; "required": true; "isSignal": true; }; "colorSchema": { "alias": "colorSchema"; "required": false; "isSignal": true; }; }, {}, ["templateRef"], never, true, never>;
}

type TAbstractComponent<T extends object> = {
    [K in keyof SkeletonAbstractComponent$1<T>]: K extends 'proxy' ? SkeletonAbstractComponent$1<T>[K] : Signal<SkeletonAbstractComponent$1<T>[K]>;
};
/**
 * Angular-specific abstract component for skeletonizer.
 * Every Angular component that uses Skeletonizer should extend this class.
 *
 * This version uses Angular signals for reactive state management.
 *
 * @template T - The type of the data model for the skeletonized part of the component
 */
declare abstract class SkeletonAbstractComponent<T extends object> implements TAbstractComponent<T> {
    /**
     * Configuration for the skeleton schema.
     * Defines how the skeleton data should be generated.
     */
    abstract skeletonConfig: Signal<TSchemaConfig<T>>;
    /**
     * Signal that controls whether the skeleton is shown or the actual content.
     * Use `.set()` to update the value if using WritableSignal.
     */
    abstract showSkeleton: Signal<boolean>;
    /**
     * Proxy method for type-safe access to properties/methods within the skeletonized part of the view.
     *
     * When accessing component properties/methods from within the skeletonized template,
     * they should be accessed via this proxy method. This ensures:
     * - All accessed properties/methods are part of the skeleton schema
     * - TypeScript understands the correct type of each property/method
     *
     * @param scope - Either the skeleton schema or the actual scope object
     * @returns The unwrapped scope object with proper typing
     *
     * @example
     * ```html
     * <ng-template let-context>
     *   <div>{{ proxy(context).userName }}</div>
     * </ng-template>
     * ```
     */
    proxy(scope: T | Schema<T>): T;
}

export { SkeletonAbstractComponent, SkeletonizerSkeletonComponent };