@ethlete/cdk 4.28.0 → 4.28.1

package/index.d.ts

@@ -0,0 +1,21 @@
+export * from './lib/components/accordion/public-api';
+export * from './lib/components/bracket/public-api';
+export * from './lib/components/button/public-api';
+export * from './lib/components/carousel/public-api';
+export * from './lib/components/filter/public-api';
+export * from './lib/components/forms/public-api';
+export * from './lib/components/icons/public-api';
+export * from './lib/components/masonry/public-api';
+export * from './lib/components/overlay/public-api';
+export * from './lib/components/pagination/public-api';
+export * from './lib/components/picture/public-api';
+export * from './lib/components/progress-spinner';
+export * from './lib/components/query-error/public-api';
+export * from './lib/components/scrollable/public-api';
+export * from './lib/components/skeleton/public-api';
+export * from './lib/components/sort/public-api';
+export * from './lib/components/table/public-api';
+export * from './lib/components/tabs/public-api';
+export * from './lib/services';
+export * from './lib/types';
+export * from './lib/utils';

package/lib/components/accordion/accordion.imports.d.ts

@@ -0,0 +1,7 @@
+import { AccordionComponent } from './components/accordion';
+import { AccordionGroupComponent } from './components/accordion-group';
+import { AccordionHintDirective } from './partials/accordion-hint';
+import { AccordionHintWrapperDirective } from './partials/accordion-hint-wrapper';
+import { AccordionLabelDirective } from './partials/accordion-label';
+import { AccordionLabelWrapperDirective } from './partials/accordion-label-wrapper';
+export declare const AccordionImports: readonly [typeof AccordionHintDirective, typeof AccordionHintWrapperDirective, typeof AccordionLabelDirective, typeof AccordionLabelWrapperDirective, typeof AccordionComponent, typeof AccordionGroupComponent];

package/lib/components/accordion/components/accordion/accordion.component.animations.d.ts

@@ -0,0 +1,3 @@
+export declare const accordionAnimations: {
+    animateOpenClose: import("@angular/animations").AnimationTriggerMetadata;
+};

package/lib/components/accordion/components/accordion/accordion.component.constants.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { AccordionComponent } from './accordion.component';
+export declare const ACCORDION_COMPONENT: InjectionToken<AccordionComponent>;

package/lib/components/accordion/components/accordion/accordion.component.d.ts

@@ -0,0 +1,28 @@
+import { OnInit } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { AccordionHintWrapperDirective } from '../../partials/accordion-hint-wrapper';
+import { AccordionLabelWrapperDirective } from '../../partials/accordion-label-wrapper';
+import * as i0 from "@angular/core";
+export declare class AccordionComponent implements OnInit {
+    private readonly _id;
+    isOpenByDefault: boolean;
+    disabled: boolean;
+    label: string;
+    protected readonly templateLabel: AccordionLabelWrapperDirective;
+    protected readonly templateHint: AccordionHintWrapperDirective;
+    protected readonly bodyId: string;
+    protected readonly headerId: string;
+    _isFirst: boolean;
+    _isLast: boolean;
+    protected readonly _isOpen$: BehaviorSubject<boolean>;
+    get isOpen$(): import("rxjs").Observable<boolean>;
+    get isOpen(): boolean;
+    ngOnInit(): void;
+    toggleAccordionOpen(): void;
+    open(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionComponent, "et-accordion", never, { "isOpenByDefault": { "alias": "isOpenByDefault"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, ["templateLabel", "templateHint"], ["*"], true, never>;
+    static ngAcceptInputType_isOpenByDefault: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}

package/lib/components/accordion/components/accordion-group/accordion-group.component.d.ts

@@ -0,0 +1,11 @@
+import { AfterContentInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AccordionGroupComponent implements AfterContentInit {
+    private readonly _destroy$;
+    autoCloseOthers: boolean;
+    private readonly _accordions?;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionGroupComponent, "et-accordion-group", never, { "autoCloseOthers": { "alias": "autoCloseOthers"; "required": false; }; }, {}, ["_accordions"], ["et-accordion"], true, never>;
+    static ngAcceptInputType_autoCloseOthers: unknown;
+}

package/lib/components/accordion/partials/accordion-hint/accordion-hint.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class AccordionHintDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionHintDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionHintDirective, "[et-accordion-hint]", never, {}, {}, never, never, true, never>;
+}

package/lib/components/accordion/partials/accordion-hint-wrapper/accordion-hint-wrapper.directive.constants.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { AccordionHintWrapperDirective } from './accordion-hint-wrapper.directive';
+export declare const ACCORDION_HINT_WRAPPER_DIRECTIVE: InjectionToken<AccordionHintWrapperDirective>;

package/lib/components/accordion/partials/accordion-hint-wrapper/accordion-hint-wrapper.directive.d.ts

@@ -0,0 +1,8 @@
+import { CdkPortal } from '@angular/cdk/portal';
+import { TemplateRef, ViewContainerRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AccordionHintWrapperDirective extends CdkPortal {
+    constructor(templateRef: TemplateRef<unknown>, viewContainerRef: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionHintWrapperDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionHintWrapperDirective, "ng-template[et-accordion-hint-wrapper]", never, {}, {}, never, never, true, never>;
+}

package/lib/components/accordion/partials/accordion-label/accordion-label.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class AccordionLabelDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionLabelDirective, "[et-accordion-label]", never, {}, {}, never, never, true, never>;
+}

package/lib/components/accordion/partials/accordion-label-wrapper/accordion-label-wrapper.directive.constants.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { AccordionLabelWrapperDirective } from './accordion-label-wrapper.directive';
+export declare const ACCORDION_LABEL_WRAPPER_DIRECTIVE: InjectionToken<AccordionLabelWrapperDirective>;

package/lib/components/accordion/partials/accordion-label-wrapper/accordion-label-wrapper.directive.d.ts

@@ -0,0 +1,8 @@
+import { CdkPortal } from '@angular/cdk/portal';
+import { TemplateRef, ViewContainerRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AccordionLabelWrapperDirective extends CdkPortal {
+    constructor(templateRef: TemplateRef<unknown>, viewContainerRef: ViewContainerRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionLabelWrapperDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionLabelWrapperDirective, "ng-template[et-accordion-label-wrapper]", never, {}, {}, never, never, true, never>;
+}

package/lib/components/bracket/bracket.imports.d.ts

@@ -0,0 +1,4 @@
+import { BracketComponent } from './components/bracket';
+import { BracketMatchComponent } from './partials/bracket-match';
+import { BracketRoundHeaderComponent } from './partials/bracket-round-header';
+export declare const BracketImports: readonly [typeof BracketComponent, typeof BracketMatchComponent, typeof BracketRoundHeaderComponent];

package/lib/components/bracket/components/bracket/bracket.component.d.ts

@@ -0,0 +1,55 @@
+import { ComponentPortal, ComponentType } from '@angular/cdk/portal';
+import { TrackByFunction } from '@angular/core';
+import { RoundStageStructureWithMatchesView } from '@ethlete/types';
+import { BehaviorSubject } from 'rxjs';
+import { BracketConfig, BracketMatch, BracketRound } from '../../types';
+import { Bracket } from '../../utils';
+import { ConnectedMatches } from './bracket.component.types';
+import * as i0 from "@angular/core";
+export declare class BracketComponent {
+    private _elementRef;
+    private _bracketConfig;
+    private _injector;
+    get itemWith(): string;
+    set itemWith(v: string);
+    private _itemWith;
+    get itemHeight(): string;
+    set itemHeight(v: string);
+    private _itemHeight;
+    get roundHeaderHeight(): string;
+    set roundHeaderHeight(v: string);
+    private _roundHeaderHeight;
+    get upperLowerBracketGap(): string;
+    set upperLowerBracketGap(v: string);
+    private _upperLowerBracketGap;
+    get columnGap(): string;
+    set columnGap(v: string);
+    private _columnGap;
+    get rowGap(): string;
+    set rowGap(v: string);
+    private _rowGap;
+    get roundsWithMatches(): RoundStageStructureWithMatchesView[] | null | undefined;
+    set roundsWithMatches(v: RoundStageStructureWithMatchesView[] | null | undefined);
+    private _roundsWithMatches;
+    get componentConfig(): BracketConfig | null;
+    set componentConfig(v: BracketConfig | null);
+    private _componentConfig;
+    get hasRoundHeaders(): boolean;
+    protected _config: BracketConfig;
+    protected _bracket$: BehaviorSubject<Bracket | null>;
+    trackByRound: TrackByFunction<BracketRound>;
+    trackByMatch: TrackByFunction<BracketMatch>;
+    getBracketMatchById(id: string): import("rxjs").Observable<BracketMatch | null>;
+    getBracketRoundById(id: string): import("rxjs").Observable<BracketRound | null>;
+    protected getConnectedMatches(match: BracketMatch, bracket: Bracket): ConnectedMatches;
+    protected getChildConnectorShape(currentMatch: BracketMatch, nextMatch: BracketMatch | null): "straight" | "down" | "up" | null;
+    protected getLineMultiAfter(roundIndex: number, bracket: Bracket): number;
+    protected getLineSpan(affectedRound: BracketRound | null, previousRound: BracketRound | null, currentRound: BracketRound | null, nextRound: BracketRound | null, bracket: Bracket): number;
+    protected createRoundPortal(round: BracketRound, component: ComponentType<unknown>): ComponentPortal<unknown>;
+    protected createMatchPortal(match: BracketMatch, component: ComponentType<unknown>): ComponentPortal<unknown>;
+    private _getRoundById;
+    private _getPreviousMatches;
+    private _getNextMatch;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BracketComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BracketComponent, "et-bracket", never, { "itemWith": { "alias": "itemWith"; "required": false; }; "itemHeight": { "alias": "itemHeight"; "required": false; }; "roundHeaderHeight": { "alias": "roundHeaderHeight"; "required": false; }; "upperLowerBracketGap": { "alias": "upperLowerBracketGap"; "required": false; }; "columnGap": { "alias": "columnGap"; "required": false; }; "rowGap": { "alias": "rowGap"; "required": false; }; "roundsWithMatches": { "alias": "roundsWithMatches"; "required": false; }; "componentConfig": { "alias": "componentConfig"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/bracket/components/bracket/bracket.component.types.d.ts

@@ -0,0 +1,5 @@
+import { BracketMatch } from '../../types';
+export interface ConnectedMatches {
+    previousMatches: (BracketMatch | null)[] | null;
+    nextMatch: BracketMatch | null;
+}

package/lib/components/bracket/constants/bracket.constants.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+import { BracketComponent } from '../components/bracket';
+import { BracketConfig } from '../types';
+export declare const BRACKET_TOKEN: InjectionToken<BracketComponent>;
+export declare const BRACKET_CONFIG_TOKEN: InjectionToken<BracketConfig>;
+export declare const BRACKET_ROUND_ID_TOKEN: InjectionToken<string>;
+export declare const BRACKET_MATCH_ID_TOKEN: InjectionToken<string>;
+export declare const BRACKET_DEFAULT_CONFIG: BracketConfig;

package/lib/components/bracket/directives/bracket-match/bracket-match.directive.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class BracketMatchDirective {
+    matchId: string;
+    bracket: import("@ethlete/cdk").BracketComponent;
+    match$: import("rxjs").Observable<import("@ethlete/cdk").BracketMatch | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BracketMatchDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BracketMatchDirective, never, never, {}, {}, never, never, true, never>;
+}

package/lib/components/bracket/directives/bracket-round/bracket-round.directive.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class BracketRoundDirective {
+    roundId: string;
+    bracket: import("@ethlete/cdk").BracketComponent;
+    round$: import("rxjs").Observable<import("@ethlete/cdk").BracketRound | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BracketRoundDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BracketRoundDirective, never, never, {}, {}, never, never, true, never>;
+}

package/lib/components/bracket/partials/bracket-match/bracket-match.component.d.ts

@@ -0,0 +1,8 @@
+import { BracketMatchDirective } from '../../directives/bracket-match';
+import * as i0 from "@angular/core";
+import * as i1 from "../../directives/bracket-match/bracket-match.directive";
+export declare class BracketMatchComponent {
+    matchData: BracketMatchDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BracketMatchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BracketMatchComponent, "et-bracket-match", never, {}, {}, never, never, true, [{ directive: typeof i1.BracketMatchDirective; inputs: {}; outputs: {}; }]>;
+}

package/lib/components/bracket/partials/bracket-round-header/bracket-round-header.component.d.ts

@@ -0,0 +1,8 @@
+import { BracketRoundDirective } from '../../directives/bracket-round';
+import * as i0 from "@angular/core";
+import * as i1 from "../../directives/bracket-round/bracket-round.directive";
+export declare class BracketRoundHeaderComponent {
+    roundData: BracketRoundDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BracketRoundHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BracketRoundHeaderComponent, "et-bracket-round-header", never, {}, {}, never, never, true, [{ directive: typeof i1.BracketRoundDirective; inputs: {}; outputs: {}; }]>;
+}

package/lib/components/bracket/types/bracket-config.types.d.ts

@@ -0,0 +1,5 @@
+import { ComponentType } from '@angular/cdk/portal';
+export interface BracketConfig {
+    roundHeaderComponent: ComponentType<unknown> | null;
+    matchComponent: ComponentType<unknown>;
+}

package/lib/components/bracket/types/bracket.types.d.ts

@@ -0,0 +1,30 @@
+import { MatchListView, RoundStageStructureView } from '@ethlete/types';
+export interface BracketRound {
+    matchCount: number;
+    name: string | null;
+    matches: BracketMatch[];
+    data: RoundStageStructureView;
+    row: {
+        start: number;
+        end: number;
+    };
+    column: {
+        start: number;
+        end: number;
+    };
+}
+export interface BracketMatch {
+    data: MatchListView;
+    row: {
+        start: number;
+        end: number;
+    };
+    previousMatches: {
+        roundId: string;
+        matchIds: string[];
+    } | null;
+    nextMatch: {
+        roundId: string;
+        matchId: string;
+    } | null;
+}

package/lib/components/bracket/utils/bracket-config.utils.d.ts

@@ -0,0 +1,6 @@
+import { BracketConfig } from '../types';
+export declare const createBracketConfig: (globalConfig?: Partial<BracketConfig> | null | undefined, localConfig?: Partial<BracketConfig> | null | undefined) => BracketConfig;
+export declare const provideBracketConfig: (config?: Partial<BracketConfig> | null | undefined) => {
+    provide: import("@angular/core").InjectionToken<BracketConfig>;
+    useValue: BracketConfig;
+};

package/lib/components/bracket/utils/bracket.utils.d.ts

@@ -0,0 +1,37 @@
+import { RoundStageStructureWithMatchesView } from '@ethlete/types';
+import { BracketMatch, BracketRound } from '../types';
+export declare const isUpperBracketMatch: (match: RoundStageStructureWithMatchesView | null | undefined) => boolean;
+export declare const orderRounds: (rounds: RoundStageStructureWithMatchesView[]) => RoundStageStructureWithMatchesView[];
+export declare const orderRoundsByRoundNumber: (rounds: RoundStageStructureWithMatchesView[]) => RoundStageStructureWithMatchesView[];
+export declare const normalizeRoundType: (roundType: string | null | undefined) => "upper" | "lower" | null;
+export declare class Bracket {
+    private _roundsWithMatches;
+    get winnerRounds(): RoundStageStructureWithMatchesView[];
+    get loserRounds(): RoundStageStructureWithMatchesView[];
+    get firstWinnerRound(): RoundStageStructureWithMatchesView | null;
+    get firstLoserRound(): RoundStageStructureWithMatchesView | null;
+    get winnerRoundCount(): number;
+    get loserRoundCount(): number;
+    get bracketSize(): number;
+    get bracketType(): "single" | "double";
+    get winnerBracketRowCount(): number;
+    get loserBracketRowCount(): number;
+    get totalRowCount(): number;
+    get totalColCount(): number;
+    get winnerRowStart(): number;
+    get winnerRowEnd(): number;
+    get loserRowStart(): number;
+    get loserRowEnd(): number;
+    get indexOfLooserRoundStart(): number;
+    get looserRowAdditionalRoundCount(): number;
+    get isPartialDoubleElimination(): boolean;
+    readonly bracketRounds: BracketRound[];
+    readonly id: number;
+    private readonly _bracketMatches;
+    constructor(_roundsWithMatches: RoundStageStructureWithMatchesView[]);
+    getRoundById(roundId: string): BracketRound | undefined;
+    getMatchById(matchId: string): BracketMatch | undefined;
+    private _computeBracket;
+    private _transformRound;
+    private _transformMatch;
+}

package/lib/components/button/button.imports.d.ts

@@ -0,0 +1,3 @@
+import { ButtonComponent } from './components/button';
+import { QueryButtonComponent } from './components/query-button';
+export declare const ButtonImports: readonly [typeof ButtonComponent, typeof QueryButtonComponent];

package/lib/components/button/components/button/button.component.d.ts

@@ -0,0 +1,8 @@
+import { ButtonDirective } from '../../directives/button';
+import * as i0 from "@angular/core";
+import * as i1 from "../../directives/button/button.directive";
+export declare class ButtonComponent {
+    protected button: ButtonDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "[et-button]", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.ButtonDirective; inputs: { "disabled": "disabled"; "type": "type"; "pressed": "pressed"; }; outputs: {}; }]>;
+}

package/lib/components/button/components/query-button/query-button.component.d.ts

@@ -0,0 +1,9 @@
+import { QueryButtonDirective } from '../../directives/query-button';
+import * as i0 from "@angular/core";
+import * as i1 from "../../directives/query-button/query-button.directive";
+import * as i2 from "../../directives/button/button.directive";
+export declare class QueryButtonComponent {
+    protected queryButton: QueryButtonDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QueryButtonComponent, "[et-query-button]", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.QueryButtonDirective; inputs: { "query": "query"; "skipSuccess": "skipSuccess"; "skipFailure": "skipFailure"; "skipLoading": "skipLoading"; }; outputs: {}; }, { directive: typeof i2.ButtonDirective; inputs: { "disabled": "disabled"; "type": "type"; "pressed": "pressed"; }; outputs: {}; }]>;
+}

package/lib/components/button/directives/button/button.directive.d.ts

@@ -0,0 +1,37 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+type ButtonType = 'button' | 'submit' | 'reset' | 'menu';
+export declare class ButtonDirective {
+    readonly isButton: boolean;
+    readonly isAnchor: boolean;
+    get disabled(): boolean;
+    set disabled(value: unknown);
+    get disabled$(): Observable<boolean>;
+    private _disabled$;
+    get type(): ButtonType;
+    set type(value: ButtonType);
+    get type$(): Observable<ButtonType>;
+    private _type$;
+    get pressed(): boolean;
+    set pressed(value: unknown);
+    private _pressed$;
+    readonly hostAttributeBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    readonly hostClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    _removeDisabledBindings(): void;
+    _removeTabIndexBindings(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ButtonDirective, never, ["etButton"], { "disabled": { "alias": "disabled"; "required": false; }; "type": { "alias": "type"; "required": false; }; "pressed": { "alias": "pressed"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/components/button/directives/query-button/query-button.directive.d.ts

@@ -0,0 +1,42 @@
+import { AnyQuery, AnyQueryCollection } from '@ethlete/query';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class QueryButtonDirective {
+    private readonly _elementRef;
+    private readonly _destroy$;
+    private readonly _button;
+    private _cleanupTimeout;
+    readonly showSuccess$: BehaviorSubject<boolean>;
+    readonly showFailure$: BehaviorSubject<boolean>;
+    readonly didLoadOnce$: BehaviorSubject<boolean>;
+    readonly isLoading$: BehaviorSubject<boolean>;
+    get skipSuccess(): boolean;
+    set skipSuccess(value: boolean);
+    private _skipSuccess;
+    get skipFailure(): boolean;
+    set skipFailure(value: boolean);
+    private _skipFailure;
+    get skipLoading(): boolean;
+    set skipLoading(value: boolean);
+    private _skipLoading;
+    get query(): AnyQuery | AnyQueryCollection | null;
+    set query(v: AnyQuery | AnyQueryCollection | null);
+    get query$(): import("rxjs").Observable<AnyQuery | {
+        type: string;
+        query: import("@ethlete/query").Query<any, any, any, any, any, any>;
+    } | null>;
+    private readonly _query$;
+    readonly hostAttributeBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<QueryButtonDirective, never, ["etQueryButton"], { "skipSuccess": { "alias": "skipSuccess"; "required": false; }; "skipFailure": { "alias": "skipFailure"; "required": false; }; "skipLoading": { "alias": "skipLoading"; "required": false; }; "query": { "alias": "query"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_skipSuccess: unknown;
+    static ngAcceptInputType_skipFailure: unknown;
+    static ngAcceptInputType_skipLoading: unknown;
+}

package/lib/components/carousel/carousel.component.d.ts

@@ -0,0 +1,11 @@
+import { ElementRef } from '@angular/core';
+import { CarouselDirective } from './carousel.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "./carousel.directive";
+export declare class CarouselComponent {
+    carousel: CarouselDirective;
+    carouselItemsWrapper: import("@angular/core").Signal<ElementRef<HTMLElement>>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CarouselComponent, "et-carousel", never, {}, {}, never, ["et-carousel-item, [etCarouselItem]", "*"], true, [{ directive: typeof i1.CarouselDirective; inputs: { "loop": "loop"; "autoPlay": "autoPlay"; "autoPlayTime": "autoPlayTime"; "pauseAutoPlayOnHover": "pauseAutoPlayOnHover"; "pauseAutoPlayOnFocus": "pauseAutoPlayOnFocus"; "transitionType": "transitionType"; "transitionDuration": "transitionDuration"; }; outputs: {}; }]>;
+}

package/lib/components/carousel/carousel.directive.d.ts

@@ -0,0 +1,59 @@
+import { ElementRef, InjectionToken, Injector } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const CAROUSEL_TOKEN: InjectionToken<CarouselDirective>;
+export type CarouselTransitionType = 'mask-slide';
+export type CarouselTransitionDirection = 'left' | 'right';
+export declare class CarouselDirective {
+    injector: Injector;
+    loop: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    autoPlay: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    autoPlayTime: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    pauseAutoPlayOnHover: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    pauseAutoPlayOnFocus: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    transitionType: import("@angular/core").InputSignal<"mask-slide">;
+    transitionDuration: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    activeIndex: import("@angular/core").WritableSignal<number>;
+    previousActiveIndex: import("@angular/core").Signal<number | undefined>;
+    transitionDirection: import("@angular/core").WritableSignal<CarouselTransitionDirection>;
+    carouselItemsWrapper: import("@angular/core").WritableSignal<ElementRef<HTMLDivElement> | null>;
+    isAutoPlayPaused: import("@angular/core").WritableSignal<boolean>;
+    isAutoPlayPausedByInternalHover: import("@angular/core").WritableSignal<boolean>;
+    isAutoPlayPausedByInternalFocus: import("@angular/core").WritableSignal<boolean>;
+    isNavigationLocked: import("@angular/core").Signal<boolean>;
+    items: import("@angular/core").Signal<readonly import("./et-carousel-item.directive").CarouselItemDirective[]>;
+    activeItem: import("@angular/core").Signal<import("./et-carousel-item.directive").CarouselItemDirective | null>;
+    isAtStart: import("@angular/core").Signal<boolean>;
+    isAtEnd: import("@angular/core").Signal<boolean>;
+    hostClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    hostAttributeBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    hostStyleBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    activeItemAutoPlayDuration: import("@angular/core").Signal<number | null>;
+    activeItemAutoPlayProgress: import("@angular/core").Signal<number | null>;
+    shouldPlayNextItem: import("@angular/core").Signal<boolean>;
+    constructor();
+    next(): void;
+    prev(): void;
+    goTo(index: number): void;
+    stopAutoPlay(): void;
+    resumeAutoPlay(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CarouselDirective, never, never, { "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "autoPlay": { "alias": "autoPlay"; "required": false; "isSignal": true; }; "autoPlayTime": { "alias": "autoPlayTime"; "required": false; "isSignal": true; }; "pauseAutoPlayOnHover": { "alias": "pauseAutoPlayOnHover"; "required": false; "isSignal": true; }; "pauseAutoPlayOnFocus": { "alias": "pauseAutoPlayOnFocus"; "required": false; "isSignal": true; }; "transitionType": { "alias": "transitionType"; "required": false; "isSignal": true; }; "transitionDuration": { "alias": "transitionDuration"; "required": false; "isSignal": true; }; }, {}, ["items"], never, true, never>;
+}

package/lib/components/carousel/carousel.imports.d.ts

@@ -0,0 +1,4 @@
+import { CarouselComponent } from './carousel.component';
+import { CarouselItemNavComponent, CarouselNextButtonDirective, CarouselPreviousButtonDirective, CarouselToggleAutoPlayButtonDirective } from './controls';
+import { CarouselItemComponent } from './et-carousel-item.component';
+export declare const CarouselImports: readonly [typeof CarouselComponent, typeof CarouselItemComponent, typeof CarouselItemNavComponent, typeof CarouselNextButtonDirective, typeof CarouselPreviousButtonDirective, typeof CarouselToggleAutoPlayButtonDirective];

package/lib/components/carousel/controls/carousel-item-nav.component.d.ts

@@ -0,0 +1,18 @@
+import { ElementRef } from '@angular/core';
+import { CarouselItemNavDirective } from './carousel-item-nav.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "./carousel-item-nav.directive";
+export declare class CarouselItemNavComponent {
+    nav: CarouselItemNavDirective;
+    progressBars: import("@angular/core").Signal<readonly ElementRef<HTMLElement>[][]>;
+    activeProgressBar: import("@angular/core").Signal<ElementRef<HTMLElement>[] | undefined>;
+    progressBarStyleBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselItemNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CarouselItemNavComponent, "et-carousel-item-nav", never, {}, {}, never, never, true, [{ directive: typeof i1.CarouselItemNavDirective; inputs: {}; outputs: {}; }]>;
+}

package/lib/components/carousel/controls/carousel-item-nav.directive.d.ts

@@ -0,0 +1,11 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const CAROUSEL_ITEM_NAV_TOKEN: InjectionToken<CarouselItemNavDirective>;
+export declare class CarouselItemNavDirective {
+    carousel: import("../carousel.directive").CarouselDirective;
+    autoPlayProgress: import("@angular/core").Signal<number | null>;
+    autoPlayEnabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    goTo(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselItemNavDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CarouselItemNavDirective, never, never, {}, {}, never, never, true, never>;
+}

package/lib/components/carousel/controls/carousel-next-button.directive.d.ts

@@ -0,0 +1,18 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const CAROUSEL_NEXT_BUTTON_TOKEN: InjectionToken<CarouselNextButtonDirective>;
+export declare class CarouselNextButtonDirective {
+    carousel: import("../carousel.directive").CarouselDirective;
+    readonly isButton: boolean;
+    canGoNext: import("@angular/core").Signal<boolean>;
+    hostAttributeBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselNextButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CarouselNextButtonDirective, "[etCarouselNextButton]", never, {}, {}, never, never, true, never>;
+}

package/lib/components/carousel/controls/carousel-previous-button.directive.d.ts

@@ -0,0 +1,18 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const CAROUSEL_PREVIOUS_BUTTON_TOKEN: InjectionToken<CarouselPreviousButtonDirective>;
+export declare class CarouselPreviousButtonDirective {
+    carousel: import("../carousel.directive").CarouselDirective;
+    readonly isButton: boolean;
+    canGoPrevious: import("@angular/core").Signal<boolean>;
+    hostAttributeBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselPreviousButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CarouselPreviousButtonDirective, "[etCarouselPreviousButton]", never, {}, {}, never, never, true, never>;
+}

package/lib/components/carousel/controls/carousel-toggle-auto-play-button.directive.d.ts

@@ -0,0 +1,16 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const CAROUSEL_TOGGLE_AUTO_PLAY_BUTTON_TOKEN: InjectionToken<CarouselToggleAutoPlayButtonDirective>;
+export declare class CarouselToggleAutoPlayButtonDirective {
+    carousel: import("../carousel.directive").CarouselDirective;
+    hostClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CarouselToggleAutoPlayButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CarouselToggleAutoPlayButtonDirective, "[etCarouselToggleAutoPlayButton]", never, {}, {}, never, never, true, never>;
+}