@ethlete/cdk 4.28.0 → 4.28.1

package/lib/components/pagination/partials/pagination-link/pagination-link.directive.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from '@angular/core';
+import { PaginationItem } from '../../types';
+import * as i0 from "@angular/core";
+export declare class PaginationLinkDirective {
+    page: PaginationItem;
+    pageClick: EventEmitter<PaginationItem>;
+    onClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PaginationLinkDirective, "[etPaginationLink]", never, { "page": { "alias": "etPaginationLink"; "required": false; }; }, { "pageClick": "pageClick"; }, never, never, true, never>;
+}

package/lib/components/pagination/services/pagination-head.service.d.ts

@@ -0,0 +1,19 @@
+import { OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class PaginationHeadService implements OnDestroy {
+    private _config;
+    private _document;
+    private _titleService;
+    private _router;
+    private _head;
+    private get config();
+    set addCanonicalTag(v: boolean);
+    set titleTemplate(v: string | null);
+    set firstPageTitle(v: string | null);
+    ngOnDestroy(): void;
+    _updateHead(page: number): void;
+    private _getCanonicalElement;
+    private _removeCanonicalElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationHeadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PaginationHeadService>;
+}

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

@@ -0,0 +1,34 @@
+export interface PaginateOptions {
+    currentPage: number;
+    totalPageCount: number;
+    /**
+     * @default false
+     */
+    omitFirstLast?: boolean;
+    /**
+     * @default false
+     */
+    omitPreviousNext?: boolean;
+    /**
+     * @default 2
+     */
+    pagesBeforeAfter?: number;
+    /**
+     * @default 1
+     */
+    firstPage?: number;
+}
+export interface PaginationItem {
+    current: boolean;
+    page: number;
+    ariaLabel: string;
+    disabled: boolean;
+    type: 'page' | 'hotLink';
+    explicitType: 'first' | 'last' | 'previous' | 'next' | 'current' | 'page-number-close' | 'page-number-far';
+    url: string;
+}
+export interface PaginationHeadServiceConfig {
+    firstPageTitle: string | null;
+    titleTemplate: string | null;
+    addCanonicalTag: boolean;
+}

package/lib/components/pagination/utils/pagination.util.d.ts

@@ -0,0 +1,2 @@
+import { PaginateOptions, PaginationItem } from '../types';
+export declare const paginate: (value?: PaginateOptions | null) => PaginationItem[] | null;

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

@@ -0,0 +1,28 @@
+import { ElementRef } from '@angular/core';
+import { NgClassType } from '@ethlete/core';
+import { PictureSource } from '../../types/picture.types';
+import * as i0 from "@angular/core";
+export declare class PictureComponent {
+    _config: import("../../types/picture.types").PictureConfig | null;
+    sources: import("@angular/core").InputSignal<(string | PictureSource)[]>;
+    hasPriority: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    imgClass: import("@angular/core").InputSignal<NgClassType>;
+    figureClass: import("@angular/core").InputSignal<NgClassType>;
+    figcaptionClass: import("@angular/core").InputSignal<NgClassType>;
+    pictureClass: import("@angular/core").InputSignal<NgClassType>;
+    defaultSrc: import("@angular/core").InputSignal<string | PictureSource | null>;
+    alt: import("@angular/core").InputSignal<string | null>;
+    figcaption: import("@angular/core").InputSignal<string | null>;
+    width: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
+    height: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
+    sizes: import("@angular/core").InputSignalWithTransform<string | null, string | string[] | null>;
+    img: import("@angular/core").Signal<ElementRef<HTMLImageElement> | undefined>;
+    img$: import("rxjs").Observable<HTMLImageElement | null>;
+    imgLoaded: import("@angular/core").OutputRef<boolean>;
+    imgError: import("@angular/core").OutputRef<boolean>;
+    sourcesWithConfig: import("@angular/core").Signal<PictureSource[]>;
+    defaultSourceWithConfig: import("@angular/core").Signal<PictureSource | null>;
+    _combineWithConfig(src: PictureSource): PictureSource;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PictureComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PictureComponent, "et-picture", never, { "sources": { "alias": "sources"; "required": false; "isSignal": true; }; "hasPriority": { "alias": "hasPriority"; "required": false; "isSignal": true; }; "imgClass": { "alias": "imgClass"; "required": false; "isSignal": true; }; "figureClass": { "alias": "figureClass"; "required": false; "isSignal": true; }; "figcaptionClass": { "alias": "figcaptionClass"; "required": false; "isSignal": true; }; "pictureClass": { "alias": "pictureClass"; "required": false; "isSignal": true; }; "defaultSrc": { "alias": "defaultSrc"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "figcaption": { "alias": "figcaption"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "sizes": { "alias": "sizes"; "required": false; "isSignal": true; }; }, { "imgLoaded": "imgLoaded"; "imgError": "imgError"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,16 @@
+export interface PictureSource {
+    /**
+     * The mime type of the image.
+     * @example `image/jpeg`
+     */
+    type: string | null;
+    /**
+     * The source set of the image. Can be either a single URL or a comma-separated list of URLs.
+     * @example `https://example.com/image.jpg`
+     * @example `https://example.com/image.jpg, https://example.com/image@2x.jpg`
+     */
+    srcset: string;
+}
+export interface PictureConfig {
+    baseUrl?: string;
+}

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

@@ -0,0 +1,9 @@
+import { InjectionToken } from '@angular/core';
+import { PictureConfig, PictureSource } from '../types/picture.types';
+export declare const IMAGE_CONFIG_TOKEN: InjectionToken<PictureConfig>;
+export declare const provideImageConfig: (config?: Partial<PictureConfig> | null | undefined) => {
+    provide: InjectionToken<PictureConfig>;
+    useValue: Partial<PictureConfig> | null;
+};
+export declare const normalizePictureSource: (source: string | PictureSource) => PictureSource;
+export declare const normalizePictureSizes: (sizes: string | string[] | null) => string | null;

package/lib/components/progress-spinner/progress-spinner.component.d.ts

@@ -0,0 +1,32 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export type ProgressSpinnerMode = 'determinate' | 'indeterminate';
+export interface ProgressSpinnerDefaultOptions {
+    diameter?: number;
+    strokeWidth?: number;
+}
+export declare const PROGRESS_SPINNER_DEFAULT_OPTIONS: InjectionToken<ProgressSpinnerDefaultOptions>;
+export declare function PROGRESS_SPINNER_DEFAULT_OPTIONS_FACTORY(): ProgressSpinnerDefaultOptions;
+export declare class ProgressSpinnerComponent {
+    private readonly _elementRef;
+    private readonly _defaults;
+    multiColor: boolean;
+    mode: ProgressSpinnerMode;
+    get value(): number;
+    set value(v: unknown);
+    private _value;
+    diameter: number;
+    get strokeWidth(): number;
+    set strokeWidth(value: unknown);
+    private _strokeWidth;
+    constructor();
+    protected _circleRadius(): number;
+    protected _viewBox(): string;
+    protected _strokeCircumference(): number;
+    protected _strokeDashOffset(): number | null;
+    protected _circleStrokeWidth(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressSpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressSpinnerComponent, "et-progress-spinner, et-spinner", never, { "multiColor": { "alias": "multiColor"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "value": { "alias": "value"; "required": false; }; "diameter": { "alias": "diameter"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_multiColor: unknown;
+    static ngAcceptInputType_diameter: unknown;
+}

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

@@ -0,0 +1,15 @@
+import { TrackByFunction } from '@angular/core';
+import { QueryErrorDirective } from '../../directives/query-error';
+import { QueryErrorItem } from '../../types';
+import * as i0 from "@angular/core";
+import * as i1 from "../../directives/query-error/query-error.directive";
+export declare class QueryErrorComponent {
+    protected readonly host: QueryErrorDirective;
+    protected readonly errorList: import("@angular/core").Signal<import("../../types").QueryErrorList | null>;
+    protected readonly canBeRetried: import("@angular/core").Signal<boolean>;
+    protected readonly isList: import("@angular/core").Signal<boolean>;
+    protected trackByFn: TrackByFunction<QueryErrorItem>;
+    protected retry(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QueryErrorComponent, "et-query-error", never, {}, {}, never, never, true, [{ directive: typeof i1.QueryErrorDirective; inputs: { "error": "error"; "query": "query"; "language": "language"; }; outputs: {}; }]>;
+}

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

@@ -0,0 +1,20 @@
+import { InjectionToken } from '@angular/core';
+import { AnyQuery, HttpStatusCode, RequestError } from '@ethlete/query';
+import { QueryErrorList } from '../../types';
+import * as i0 from "@angular/core";
+export declare const QUERY_ERROR_TOKEN: InjectionToken<QueryErrorDirective>;
+export declare const convertHttpStatusCodeToMessageEn: (statusCode: HttpStatusCode) => "Sorry, we could not process your request. Please try again later." | "You are not authorized to perform this action. Please log in to continue." | "Payment is required to complete this action." | "You do not have permission to perform this action." | "The requested resource was not found." | "The requested method is not allowed for this resource." | "The requested resource is not capable of generating a response matching the list of acceptable values." | "Proxy authentication is required to complete this action." | "The server timed out waiting for the request." | "The request conflicts with the current state of the resource." | "The requested resource is no longer available and will not be available again." | "The request did not specify the length of its content, which is required by the requested resource." | "The server does not meet one of the preconditions that the requester put on the request." | "The request is larger than the server is willing or able to process." | "The URL provided was too long for the server to process." | "The request entity has a media type which the server or resource does not support." | "The client has asked for a portion of the file, but the server cannot supply that portion." | "The server cannot meet the requirements of the Expect request-header field." | "I am a teapot." | "The request was directed at a server that is not able to produce a response." | "The request was well-formed but was unable to be followed due to semantic errors." | "The resource that is being accessed is locked." | "The request failed due to failure of a previous request." | "The server is unwilling to process the request because the user has not been authenticated." | "The client should switch to a different protocol such as TLS/1.0, given in the Upgrade header field." | "The origin server requires the request to be conditional." | "You have sent too many requests in a given amount of time. Please try again later." | "The server is unwilling to process the request because its header fields are too large." | "The resource is unavailable due to a legal demand." | "Something went wrong on our end. Please try again later." | "The server does not support the functionality required to fulfill the request." | "The server is currently unable to handle the request due to a temporary overload or maintenance of the server." | "The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URL or some other auxiliary server it needed to access in attempting to complete the request." | "The server does not support the HTTP protocol version used in the request." | "The server has an internal configuration error: the chosen variant resource is configured to engage in transparent content negotiation itself, and is therefore not a proper end point in the negotiation process." | "The method could not be performed on the resource because the server is unable to store the representation needed to successfully complete the request." | "The server detected an infinite loop while processing the request." | "Further extensions to the request are required for the server to fulfill it." | "You need to authenticate to gain network access." | "Something went wrong. Check your internet connection and try again later.";
+export declare const convertHttpStatusCodeToMessageDe: (statusCode: HttpStatusCode) => "Entschuldigung, wir konnten Ihre Anfrage nicht bearbeiten. Bitte versuchen Sie es später erneut." | "Sie sind nicht berechtigt, diese Aktion auszuführen. Bitte melden Sie sich an, um fortzufahren." | "Zur Ausführung dieser Aktion ist eine Zahlung erforderlich." | "Sie haben keine Berechtigung, diese Aktion auszuführen." | "Die angeforderte Ressource wurde nicht gefunden." | "Die angeforderte Methode ist für diese Ressource nicht zulässig." | "Die angeforderte Ressource ist nicht in der Lage, eine Antwort zu generieren, die der Liste der akzeptablen Werte entspricht." | "Zur Ausführung dieser Aktion ist eine Proxy-Authentifizierung erforderlich." | "Der Server hat auf die Anforderung gewartet." | "Die Anforderung steht im Widerspruch zum aktuellen Zustand der Ressource." | "Die angeforderte Ressource ist nicht mehr verfügbar und wird auch nicht mehr verfügbar sein." | "Die Anforderung hat die Länge ihres Inhalts nicht angegeben, die von der angeforderten Ressource benötigt wird." | "Der Server erfüllt eine der Voraussetzungen nicht, die der Anforderer an die Anforderung gestellt hat." | "Die Anforderung ist größer als der Server bereit oder in der Lage ist, zu verarbeiten." | "Die bereitgestellte URL war für den Server zu lang, um sie zu verarbeiten." | "Die Anforderungseinheit hat einen Medientyp, den der Server oder die Ressource nicht unterstützt." | "Der Client hat einen Teil der Datei angefordert, aber der Server kann diesen Teil nicht liefern." | "Der Server kann die Anforderungen des Erwartung-Anforderungskopffelds nicht erfüllen." | "Ich bin eine Teekanne." | "Die Anforderung wurde an einen Server gerichtet, der nicht in der Lage ist, eine Antwort zu generieren." | "Die Anforderung war gut formuliert, konnte aber aufgrund semantischer Fehler nicht befolgt werden." | "Die Ressource, auf die zugegriffen wird, ist gesperrt." | "Die Anforderung ist aufgrund eines Fehlers einer vorherigen Anforderung fehlgeschlagen." | "Der Server ist nicht bereit, die Anforderung zu verarbeiten, weil der Benutzer nicht authentifiziert wurde." | "Der Client sollte zu einem anderen Protokoll wie TLS/1.0 wechseln, das im Upgrade-Anforderungskopffeld angegeben ist." | "Der Ursprungsserver erfordert, dass die Anforderung bedingt ist." | "Sie haben in einer bestimmten Zeit zu viele Anfragen gesendet. Bitte versuchen Sie es später erneut." | "Der Server ist nicht bereit, die Anforderung zu verarbeiten, weil seine Kopffelder zu groß sind." | "Die Ressource ist aufgrund einer rechtlichen Forderung nicht verfügbar." | "Etwas ist schief gelaufen. Bitte versuchen Sie es später erneut." | "Der Server unterstützt die zur Erfüllung der Anforderung erforderliche Funktionalität nicht." | "Der Server kann die Anforderung derzeit nicht bearbeiten, da er vorübergehend überlastet oder gewartet wird." | "Der Server hat beim Versuch, die Anforderung abzuschließen, keine rechtzeitige Antwort vom Server erhalten." | "Der Server unterstützt die in der Anforderung verwendete HTTP-Protokollversion nicht." | "Der Server hat einen internen Konfigurationsfehler: Die ausgewählte Variantenressource ist so konfiguriert, dass sie sich selbst in die transparente Inhaltsverhandlung einbindet, und ist daher kein geeigneter Endpunkt im Verhandlungsprozess." | "Die Methode konnte auf die Ressource nicht angewendet werden, weil der Server nicht in der Lage ist, die für die erfolgreiche Ausführung der Anforderung erforderliche Darstellung zu speichern." | "Der Server hat eine Endlosschleife erkannt, während er die Anforderung verarbeitet." | "Weitere Erweiterungen der Anforderung sind erforderlich, damit der Server sie erfüllen kann." | "Sie müssen sich authentifizieren, um Zugang zum Netzwerk zu erhalten." | "Etwas ist schief gelaufen. Überprüfen Sie Ihre Internetverbindung und versuchen Sie es später erneut.";
+export declare const convertHttpStatusCodeToTitleEn: (statusCode: HttpStatusCode) => "Bad request" | "Unauthorized" | "Payment required" | "Forbidden" | "Not found" | "Method not allowed" | "Not acceptable" | "Proxy authentication required" | "Request timeout" | "Conflict" | "Gone" | "Length required" | "Precondition failed" | "Payload too large" | "URI too long" | "Unsupported media type" | "Range not satisfiable" | "Expectation failed" | "I am a teapot" | "Misdirected request" | "Unprocessable entity" | "Locked" | "Failed dependency" | "Too early" | "Upgrade required" | "Precondition required" | "Too many requests" | "Request header fields too large" | "Unavailable for legal reasons" | "Internal server error" | "Not implemented" | "Bad gateway" | "Service unavailable" | "Gateway timeout" | "HTTP version not supported" | "Variant also negotiates" | "Insufficient storage" | "Loop detected" | "Not extended" | "Network authentication required" | "Something went wrong";
+export declare const convertHttpStatusCodeToTitleDe: (statusCode: HttpStatusCode) => "Ungültige Anfrage" | "Nicht autorisiert" | "Zahlung erforderlich" | "Verboten" | "Nicht gefunden" | "Methode nicht erlaubt" | "Nicht akzeptabel" | "Proxy-Authentifizierung erforderlich" | "Anforderungszeitüberschreitung" | "Konflikt" | "Weg" | "Länge erforderlich" | "Vorbedingung fehlgeschlagen" | "Nutzlast zu groß" | "URI zu lang" | "Nicht unterstützter Medientyp" | "Bereich nicht zufriedenstellend" | "Erwartung fehlgeschlagen" | "Ich bin eine Teekanne" | "Fehlgeleitete Anfrage" | "Unverarbeitbare Entität" | "Gesperrt" | "Fehlgeschlagene Abhängigkeit" | "Zu früh" | "Upgrade erforderlich" | "Vorbedingung erforderlich" | "Zu viele Anfragen" | "Anforderungskopffelder zu groß" | "Aus rechtlichen Gründen nicht verfügbar" | "Interner Serverfehler" | "Nicht implementiert" | "Schlechtes Gateway" | "Dienst nicht verfügbar" | "Gateway-Zeitüberschreitung" | "HTTP-Version nicht unterstützt" | "Variante verhandelt auch" | "Unzureichender Speicher" | "Schleifenerkennung" | "Nicht erweitert" | "Netzwerkauthentifizierung erforderlich" | "Etwas ist schief gelaufen";
+export declare class QueryErrorDirective {
+    error: import("@angular/core").InputSignal<RequestError<unknown> | null>;
+    query: import("@angular/core").InputSignal<AnyQuery | {
+        type: string;
+        query: import("@ethlete/query").Query<any, any, any, any, any, any>;
+    } | null>;
+    language: import("@angular/core").InputSignal<"en" | "de">;
+    readonly errorList: import("@angular/core").Signal<QueryErrorList | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryErrorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<QueryErrorDirective, never, ["etQueryError"], { "error": { "alias": "error"; "required": true; "isSignal": true; }; "query": { "alias": "query"; "required": true; "isSignal": true; }; "language": { "alias": "language"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/query-error/types/query-error.types.d.ts

@@ -0,0 +1,10 @@
+export interface QueryErrorList {
+    title: string;
+    isList: boolean;
+    canBeRetried: boolean;
+    retryDelay: number;
+    items: QueryErrorItem[];
+}
+export interface QueryErrorItem {
+    message: string;
+}

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

@@ -0,0 +1,144 @@
+import { ElementRef } from '@angular/core';
+import { NgClassType, ScrollObserverScrollState, ScrollToElementOptions } from '@ethlete/core';
+import { ScrollableIsActiveChildDirective } from '../../directives/scrollable-is-active-child';
+import { ScrollableIntersectionChange, ScrollableScrollMode } from '../../types';
+import * as i0 from "@angular/core";
+interface ScrollableNavigationItem {
+    isActive: boolean;
+    activeOffset: number;
+    element: HTMLElement;
+}
+export type ScrollableButtonPosition = 'inside' | 'footer';
+export type ScrollableScrollOrigin = 'auto' | 'center' | 'start' | 'end';
+export type ScrollableDirection = 'horizontal' | 'vertical';
+export type ScrollableItemSize = 'auto' | 'same' | 'full';
+export type ScrollableLoadingTemplatePosition = 'start' | 'end';
+export declare class ScrollableComponent {
+    private _disableSnapping$;
+    private _manualActiveNavigationIndex;
+    elementRef: ElementRef<HTMLElement>;
+    itemSize: import("@angular/core").InputSignal<ScrollableItemSize>;
+    direction: import("@angular/core").InputSignal<ScrollableDirection>;
+    scrollableRole: import("@angular/core").InputSignal<string | null>;
+    scrollableClass: import("@angular/core").InputSignal<NgClassType>;
+    renderNavigation: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    renderMasks: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    renderButtons: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    buttonPosition: import("@angular/core").InputSignal<ScrollableButtonPosition>;
+    renderScrollbars: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    stickyButtons: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    cursorDragScroll: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    disableActiveElementScrolling: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    scrollMode: import("@angular/core").InputSignal<ScrollableScrollMode>;
+    snap: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    scrollMargin: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    scrollOrigin: import("@angular/core").InputSignal<ScrollableScrollOrigin>;
+    darkenNonIntersectingItems: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    showLoadingTemplate: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    loadingTemplatePosition: import("@angular/core").InputSignal<ScrollableLoadingTemplatePosition>;
+    scrollable: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+    firstElement: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+    lastElement: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+    activeElementList: import("@angular/core").Signal<readonly ScrollableIsActiveChildDirective[]>;
+    navigationDotsContainer: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+    firstNavigationDot: import("@angular/core").Signal<ElementRef<HTMLButtonElement> | undefined>;
+    loadingTemplate: import("@angular/core").Signal<import("../../directives/scrollable-loading-template").ScrollableLoadingTemplateDirective | undefined>;
+    navigationDotDimensions: import("@angular/core").Signal<import("@ethlete/core").NullableElementDimensions>;
+    scrollState: import("@angular/core").Signal<import("@ethlete/core").ElementScrollState>;
+    isRendered: {
+        state: import("@angular/core").WritableSignal<boolean>;
+        bind: () => import("@angular/core").EffectRef;
+    };
+    canAnimate: {
+        state: import("@angular/core").Signal<boolean>;
+    };
+    cursorDragScrollState: {
+        isDragging: import("@angular/core").Signal<boolean>;
+        currentDragAmount: import("@angular/core").Signal<{
+            x: number;
+            y: number;
+        }>;
+    };
+    isCursorDragging$: import("rxjs").Observable<boolean>;
+    renderButtonsInside: import("@angular/core").Signal<boolean>;
+    renderButtonsInFooter: import("@angular/core").Signal<boolean>;
+    containerScrollState: import("@angular/core").Signal<import("@ethlete/core").ElementScrollState>;
+    firstElementIntersection: import("@angular/core").Signal<IntersectionObserverEntry[]>;
+    lastElementIntersection: import("@angular/core").Signal<IntersectionObserverEntry[]>;
+    allScrollableChildren: import("@angular/core").Signal<HTMLElement[]>;
+    scrollableChildren: import("@angular/core").Signal<HTMLElement[]>;
+    scrollableContentIntersections: import("@angular/core").Signal<IntersectionObserverEntry[]>;
+    scrollableContentIntersections$: import("rxjs").Observable<IntersectionObserverEntry[]>;
+    nonScrollableIntersections: import("@angular/core").Signal<HTMLElement[]>;
+    isAtStart: import("@angular/core").Signal<boolean>;
+    isAtEnd: import("@angular/core").Signal<boolean>;
+    canScroll: import("@angular/core").Signal<boolean>;
+    scrollableNavigation: import("@angular/core").Signal<ScrollableNavigationItem[]>;
+    activeIndex: import("@angular/core").Signal<number>;
+    intersectionChange: import("@angular/core").OutputRef<ScrollableIntersectionChange[]>;
+    scrollStateChange: import("@angular/core").OutputRef<ScrollObserverScrollState>;
+    allChildElementClassBindings: {
+        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;
+    };
+    nonFullIntersectingElementClassBindings: {
+        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;
+    };
+    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;
+    };
+    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;
+    };
+    scrollableDotsContainerStyleBindings: {
+        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();
+    getNavigationDotsContainerTranslate(navigationDotCount: number, activeIndex: number): string;
+    scrollOneContainerSize(direction: 'start' | 'end'): void;
+    scrollOneItemSize(direction: 'start' | 'end'): void;
+    getElementScrollCoordinates(options: Omit<ScrollToElementOptions, 'container'> & {
+        ignoreForcedOrigin?: boolean;
+    }): ScrollToOptions;
+    scrollToElement(options: Omit<ScrollToElementOptions, 'container'> & {
+        ignoreForcedOrigin?: boolean;
+    }): void;
+    scrollToElementByIndex(options: Omit<ScrollToElementOptions, 'container'> & {
+        index: number;
+        ignoreForcedOrigin?: boolean;
+    }): void;
+    protected scrollToElementViaNavigation(elementIndex: number): void;
+    protected scrollToStartDirection(): void;
+    protected scrollToEndDirection(): void;
+    private _enableSnapping;
+    private _disableSnapping;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollableComponent, "et-scrollable", never, { "itemSize": { "alias": "itemSize"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "scrollableRole": { "alias": "scrollableRole"; "required": false; "isSignal": true; }; "scrollableClass": { "alias": "scrollableClass"; "required": false; "isSignal": true; }; "renderNavigation": { "alias": "renderNavigation"; "required": false; "isSignal": true; }; "renderMasks": { "alias": "renderMasks"; "required": false; "isSignal": true; }; "renderButtons": { "alias": "renderButtons"; "required": false; "isSignal": true; }; "buttonPosition": { "alias": "buttonPosition"; "required": false; "isSignal": true; }; "renderScrollbars": { "alias": "renderScrollbars"; "required": false; "isSignal": true; }; "stickyButtons": { "alias": "stickyButtons"; "required": false; "isSignal": true; }; "cursorDragScroll": { "alias": "cursorDragScroll"; "required": false; "isSignal": true; }; "disableActiveElementScrolling": { "alias": "disableActiveElementScrolling"; "required": false; "isSignal": true; }; "scrollMode": { "alias": "scrollMode"; "required": false; "isSignal": true; }; "snap": { "alias": "snap"; "required": false; "isSignal": true; }; "scrollMargin": { "alias": "scrollMargin"; "required": false; "isSignal": true; }; "scrollOrigin": { "alias": "scrollOrigin"; "required": false; "isSignal": true; }; "darkenNonIntersectingItems": { "alias": "darkenNonIntersectingItems"; "required": false; "isSignal": true; }; "showLoadingTemplate": { "alias": "showLoadingTemplate"; "required": false; "isSignal": true; }; "loadingTemplatePosition": { "alias": "loadingTemplatePosition"; "required": false; "isSignal": true; }; }, { "intersectionChange": "intersectionChange"; "scrollStateChange": "scrollStateChange"; }, ["activeElementList", "loadingTemplate"], ["*"], true, never>;
+}
+export {};

package/lib/components/scrollable/components/scrollable-placeholder/scrollable-placeholder.component.d.ts

@@ -0,0 +1,15 @@
+import { TemplateRef } from '@angular/core';
+import { NgClassType } from '@ethlete/core';
+import * as i0 from "@angular/core";
+export declare class ScrollablePlaceholderComponent {
+    renderMasks: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    renderStartMask: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    renderEndMask: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    repeatContentCount: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    scrollableClass: import("@angular/core").InputSignal<NgClassType>;
+    repeat: import("@angular/core").Signal<unknown[]>;
+    contentTemplate: import("@angular/core").Signal<TemplateRef<any>>;
+    overlayTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollablePlaceholderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollablePlaceholderComponent, "et-scrollable-placeholder", never, { "renderMasks": { "alias": "renderMasks"; "required": false; "isSignal": true; }; "renderStartMask": { "alias": "renderStartMask"; "required": false; "isSignal": true; }; "renderEndMask": { "alias": "renderEndMask"; "required": false; "isSignal": true; }; "repeatContentCount": { "alias": "repeatContentCount"; "required": false; "isSignal": true; }; "scrollableClass": { "alias": "scrollableClass"; "required": false; "isSignal": true; }; }, {}, ["contentTemplate", "overlayTemplate"], ["*"], true, never>;
+}

package/lib/components/scrollable/directives/scrollable-ignore-child/scrollable-ignore-child.directive.d.ts

@@ -0,0 +1,19 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const SCROLLABLE_IGNORE_CHILD_TOKEN: InjectionToken<ScrollableIgnoreChildDirective>;
+export declare const SCROLLABLE_IGNORE_CHILD_ATTRIBUTE = "etScrollableIgnoreChild";
+export declare const isScrollableChildIgnored: (e: HTMLElement) => boolean;
+export declare class ScrollableIgnoreChildDirective {
+    set _ignoreChildEnabled(v: boolean);
+    readonly ignoreChildEnabled: import("@angular/core").WritableSignal<boolean>;
+    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;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollableIgnoreChildDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollableIgnoreChildDirective, "[etScrollableIgnoreChild]", never, { "_ignoreChildEnabled": { "alias": "etScrollableIgnoreChild"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType__ignoreChildEnabled: unknown;
+}

package/lib/components/scrollable/directives/scrollable-is-active-child/scrollable-is-active-child.directive.d.ts

@@ -0,0 +1,20 @@
+import { ElementRef, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const SCROLLABLE_IS_ACTIVE_CHILD_TOKEN: InjectionToken<ScrollableIsActiveChildDirective>;
+export declare const SCROLLABLE_IS_ACTIVE_CHILD_ATTRIBUTE = "etScrollableIsActiveChild";
+export declare const isScrollableChildActive: (e: HTMLElement) => boolean;
+export declare class ScrollableIsActiveChildDirective {
+    readonly elementRef: ElementRef<HTMLElement>;
+    set _isActiveChildEnabled(v: boolean);
+    readonly isActiveChildEnabled: import("@angular/core").WritableSignal<boolean>;
+    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;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollableIsActiveChildDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollableIsActiveChildDirective, "[etScrollableIsActiveChild]", never, { "_isActiveChildEnabled": { "alias": "etScrollableIsActiveChild"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType__isActiveChildEnabled: unknown;
+}

package/lib/components/scrollable/directives/scrollable-loading-template/scrollable-loading-template.directive.d.ts

@@ -0,0 +1,10 @@
+import { InjectionToken, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const SCROLLABLE_LOADING_TEMPLATE_TOKEN: InjectionToken<ScrollableLoadingTemplateDirective>;
+export declare class ScrollableLoadingTemplateDirective {
+    templateRef: TemplateRef<any>;
+    repeatContentCount: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    repeat: import("@angular/core").Signal<unknown[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollableLoadingTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollableLoadingTemplateDirective, "ng-template[etScrollableLoadingTemplate]", never, { "repeatContentCount": { "alias": "repeatContentCount"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/scrollable/directives/scrollable-placeholder-item-template/scrollable-placeholder-item-template.directive.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const SCROLLABLE_PLACEHOLDER_ITEM_TEMPLATE_TOKEN: InjectionToken<ScrollablePlaceholderItemTemplateDirective>;
+export declare class ScrollablePlaceholderItemTemplateDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollablePlaceholderItemTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollablePlaceholderItemTemplateDirective, "ng-template[etScrollablePlaceholderItemTemplate]", never, {}, {}, never, never, true, never>;
+}

package/lib/components/scrollable/directives/scrollable-placeholder-overlay-template/scrollable-placeholder-overlay-template.directive.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const SCROLLABLE_PLACEHOLDER_OVERLAY_TEMPLATE_TOKEN: InjectionToken<ScrollablePlaceholderOverlayTemplateDirective>;
+export declare class ScrollablePlaceholderOverlayTemplateDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollablePlaceholderOverlayTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollablePlaceholderOverlayTemplateDirective, "ng-template[etScrollablePlaceholderOverlayTemplate]", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,8 @@
+import { ScrollableComponent } from './components/scrollable';
+import { ScrollablePlaceholderComponent } from './components/scrollable-placeholder';
+import { ScrollableIgnoreChildDirective } from './directives/scrollable-ignore-child';
+import { ScrollableIsActiveChildDirective } from './directives/scrollable-is-active-child';
+import { ScrollableLoadingTemplateDirective } from './directives/scrollable-loading-template';
+import { ScrollablePlaceholderItemTemplateDirective } from './directives/scrollable-placeholder-item-template';
+import { ScrollablePlaceholderOverlayTemplateDirective } from './directives/scrollable-placeholder-overlay-template';
+export declare const ScrollableImports: readonly [typeof ScrollableComponent, typeof ScrollableIsActiveChildDirective, typeof ScrollableIgnoreChildDirective, typeof ScrollableLoadingTemplateDirective, typeof ScrollablePlaceholderItemTemplateDirective, typeof ScrollablePlaceholderOverlayTemplateDirective, typeof ScrollablePlaceholderComponent];

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

@@ -0,0 +1,7 @@
+export type ScrollableScrollMode = 'container' | 'element';
+export interface ScrollableIntersectionChange {
+    element: HTMLElement;
+    intersectionRatio: number;
+    isIntersecting: boolean;
+    index: number;
+}

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

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class SkeletonComponent {
+    loadingAllyText: string;
+    animated: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonComponent, "et-skeleton", never, { "loadingAllyText": { "alias": "loadingAllyText"; "required": false; }; "animated": { "alias": "animated"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_animated: unknown;
+}

package/lib/components/skeleton/partials/skeleton-item/skeleton-item.component.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class SkeletonItemComponent {
+    ariaHidden: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonItemComponent, "et-skeleton-item", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,3 @@
+import { SkeletonComponent } from './components/skeleton';
+import { SkeletonItemComponent } from './partials/skeleton-item';
+export declare const SkeletonImports: readonly [typeof SkeletonComponent, typeof SkeletonItemComponent];

package/lib/components/sort/components/sort-header/sort-header.component.d.ts

@@ -0,0 +1,52 @@
+import { AfterViewInit, OnDestroy, OnInit } from '@angular/core';
+import { SortHeaderArrowPosition, Sortable } from '../../partials/sort';
+import { SortDirection } from '../../types';
+import { ArrowViewStateTransition } from './sort-header.types';
+import * as i0 from "@angular/core";
+export declare class SortHeaderComponent implements Sortable, OnDestroy, OnInit, AfterViewInit {
+    private readonly _intl;
+    private readonly _changeDetectorRef;
+    private readonly _sort;
+    private readonly _columnDef;
+    private readonly _focusMonitor;
+    private readonly _elementRef;
+    private readonly _ariaDescriber;
+    private readonly _sortDefaultOptions;
+    private _rerenderSubscription?;
+    private _sortButton;
+    _showIndicatorHint: boolean;
+    _viewState: ArrowViewStateTransition;
+    _arrowDirection: SortDirection;
+    disabled: boolean;
+    id: string;
+    arrowPosition: SortHeaderArrowPosition;
+    start: SortDirection;
+    get sortActionDescription(): string;
+    set sortActionDescription(value: string);
+    private _sortActionDescription;
+    disableClear: boolean;
+    get _isSorted(): boolean;
+    get _getArrowDirectionState(): string;
+    get _getArrowViewState(): string;
+    get _isDisabled(): boolean;
+    get _renderArrow(): boolean;
+    get _ariaSortAttr(): "none" | "ascending" | "descending";
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    _handleMouseEnter(): void;
+    _handleMouseLeave(): void;
+    _setIndicatorHintVisible(visible: boolean): void;
+    _setAnimationTransitionState(viewState: ArrowViewStateTransition): void;
+    _toggleOnInteraction(): void;
+    _handleClick(): void;
+    _handleKeydown(event: KeyboardEvent): void;
+    _updateArrowDirection(): void;
+    private _updateSortActionDescription;
+    private _handleStateChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SortHeaderComponent, "[et-sort-header]", ["etSortHeader"], { "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "et-sort-header"; "required": false; }; "arrowPosition": { "alias": "arrowPosition"; "required": false; }; "start": { "alias": "start"; "required": false; }; "sortActionDescription": { "alias": "sortActionDescription"; "required": false; }; "disableClear": { "alias": "disableClear"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_disableClear: unknown;
+}

package/lib/components/sort/components/sort-header/sort-header.types.d.ts

@@ -0,0 +1,9 @@
+import { SortDirection } from '../../types';
+export type ArrowViewState = SortDirection | 'hint' | 'active';
+export interface ArrowViewStateTransition {
+    fromState?: ArrowViewState;
+    toState?: ArrowViewState;
+}
+export interface SortHeaderColumnDef {
+    name: string;
+}