aptechka 0.26.1 → 0.26.2

package/lib/need_redo_tweaker/select/SelectHeadElement.d.ts

@@ -0,0 +1,13 @@
+import { SelectUserElement } from './SelectUserElement';
+
+export declare class SelectHeadElement extends SelectUserElement {
+    #private;
+    constructor();
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-select-head': SelectHeadElement;
+    }
+}

package/lib/need_redo_tweaker/select/SelectOptionElement.d.ts

@@ -0,0 +1,14 @@
+import { SelectUserElement } from './SelectUserElement';
+
+export declare class SelectOptionElement extends SelectUserElement {
+    #private;
+    constructor();
+    get value(): string;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-select-option': SelectOptionElement;
+    }
+}

package/lib/need_redo_tweaker/select/SelectUserElement.d.ts

@@ -0,0 +1,7 @@
+import { SelectElement } from './SelectElement';
+
+export declare class SelectUserElement extends HTMLElement {
+    #private;
+    get selectElement(): SelectElement;
+    protected connectedCallback(): void;
+}

package/lib/need_redo_tweaker/select/index.d.ts

@@ -0,0 +1,4 @@
+export { SelectElement } from './SelectElement';
+export { SelectUserElement } from './SelectUserElement';
+export { SelectOptionElement } from './SelectOptionElement';
+export { SelectHeadElement } from './SelectHeadElement';

package/lib/need_redo_tweaker/theme/index.d.ts

@@ -0,0 +1,35 @@
+export declare const aptechkaTheme: {
+    borderRadius: {
+        var: "var(--aptechka-border-radius)";
+        value: "12px";
+    };
+    colorMain: {
+        var: "var(--aptechka-color-main)";
+        value: "#1c1c1c";
+    };
+    colorMainAux: {
+        var: "var(--aptechka-color-main-aux)";
+        value: "#282828";
+    };
+    colorFont: {
+        var: "var(--aptechka-color-font)";
+        value: "#ffffff";
+    };
+    colorActive: {
+        var: "var(--aptechka-color-active)";
+        value: "#00E5B0";
+    };
+    borderRadiusSmall: {
+        var: "var(--aptechka-border-radius-small)";
+        value: "4px";
+    };
+} & {
+    style: {
+        "--aptechka-border-radius": string;
+        "--aptechka-color-main": string;
+        "--aptechka-color-main-aux": string;
+        "--aptechka-color-font": string;
+        "--aptechka-color-active": string;
+        "--aptechka-border-radius-small": string;
+    };
+};

package/lib/need_redo_tweaker/tweakerManagerConstructors.d.ts

@@ -0,0 +1,15 @@
+import { TweakerBooleanManagerElement } from './TweakerBooleanManagerElement';
+import { TweakerColorManagerElement } from './TweakerColorManagerElement';
+import { TweakerLinkManagerElement } from './TweakerLinkManagerElement';
+import { TweakerNumberManagerElement } from './TweakerNumberManagerElement';
+import { TweakerSelectManagerElement } from './TweakerSelectManagerElement';
+import { TweakerStringManagerElement } from './TweakerStringManagerElement';
+
+export declare const tweakerManagerConstructors: {
+    boolean: typeof TweakerBooleanManagerElement;
+    color: typeof TweakerColorManagerElement;
+    link: typeof TweakerLinkManagerElement;
+    number: typeof TweakerNumberManagerElement;
+    select: typeof TweakerSelectManagerElement;
+    string: typeof TweakerStringManagerElement;
+};

package/lib/need_redo_tweaker/tweakerStorage.d.ts

@@ -0,0 +1,23 @@
+export type TweakerOpenedPanels = Array<string>;
+export type TweakerChangedSizes = {
+    [key: string]: number;
+};
+export interface TweakerStorageState {
+    openedPanels: TweakerOpenedPanels;
+    changedSizes: TweakerChangedSizes;
+    scrollValue: number;
+}
+declare class TweakerStorage {
+    #private;
+    scrollValue: number;
+    constructor();
+    openPanel(key: string): void;
+    closePanel(key: string): void;
+    isPanelOpened(key: string): boolean;
+    changedSizes(key: string): number;
+    changeSize(key: string, value?: number | undefined | null): void;
+    save(): void;
+    load(): void;
+}
+export declare const tweakerStorage: TweakerStorage;
+export {};

package/lib/notifier/index.d.ts

@@ -0,0 +1,8 @@
+export type NotifierCallback = (...args: any[]) => void;
+export declare class Notifier<Callback extends NotifierCallback = NotifierCallback> {
+    #private;
+    close(): void;
+    subscribe(callback: Callback, order?: number): () => void;
+    unsubscribe(callback: Callback): void;
+    notify(...parameters: Parameters<Callback>): void;
+}

package/lib/order/index.d.ts

@@ -0,0 +1,22 @@
+export declare enum RESIZE_ORDER {
+    FIRST = -10000,
+    DEVICE = -9999,
+    CSS_VARIABLE = -9998,
+    MEDIA = -9997,
+    SOURCE_MANAGER = -9996,
+    SCROLL = -9995,
+    LAYOUT_BOX = -9994,
+    CANVAS = -9993,
+    LAST = 10000
+}
+export declare enum TICK_ORDER {
+    FIRST = -10000,
+    CONNECTOR = -9999,
+    CONTROLS = -9998,
+    SCROLL = -9997,
+    ANIMATION = -9996,
+    LAYOUT_BOX = -9995,
+    LADDER = -9994,
+    CANVAS = -9993,
+    LAST = 10000
+}

package/lib/pointer/Pointer.d.ts

@@ -0,0 +1,23 @@
+import { Damped, DampedOptions } from '../animation';
+import { ElementOrSelector } from '../utils';
+
+export interface PointerParameters {
+    element: ElementOrSelector<HTMLElement>;
+    damped?: DampedOptions;
+    cartesian?: boolean;
+    normalize?: boolean;
+}
+export declare class Pointer {
+    #private;
+    constructor(parameters: PointerParameters);
+    get element(): HTMLElement;
+    get x(): Damped;
+    get y(): Damped;
+    get z(): Damped;
+    get cartesian(): boolean;
+    set cartesian(value: boolean);
+    get normalize(): boolean;
+    set normalize(value: boolean);
+    connect(): void;
+    disconnect(): void;
+}

package/lib/pointer/PointerElement.d.ts

@@ -0,0 +1,14 @@
+import { Pointer } from './Pointer';
+
+export declare class PointerElement extends HTMLElement {
+    #private;
+    constructor();
+    get pointer(): Pointer;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-pointer': PointerElement;
+    }
+}

package/lib/pointer/index.d.ts

@@ -0,0 +1,2 @@
+export { Pointer, type PointerParameters } from './Pointer';
+export { PointerElement } from './PointerElement';

package/lib/router/Link.d.ts

@@ -0,0 +1,7 @@
+import { Router } from './Router';
+
+export declare class Link {
+    #private;
+    constructor(router: Router, element: HTMLElement);
+    destroy(): void;
+}

package/lib/router/Route.d.ts

@@ -0,0 +1,21 @@
+export type RouteModule = () => Promise<any>;
+export type RouteURLParams<T extends string = string> = Partial<{
+    [key in T]: string;
+}>;
+export type RouteParameters<PathnameParams extends string = string, SearchParams extends string = string> = {
+    pathnameParams: RouteURLParams<PathnameParams>;
+    searchParams: RouteURLParams<SearchParams>;
+};
+export declare class Route {
+    #private;
+    constructor(pattern: string, module: RouteModule);
+    get pattern(): string;
+    get urlPattern(): URLPattern;
+    get isActive(): boolean;
+    get element(): HTMLElement | null;
+    get nest(): HTMLElement | ShadowRoot | null;
+    testPathname(pathname: string): boolean;
+    render(containerElement: HTMLElement | ShadowRoot, pathname: string): Promise<void>;
+    close(): void;
+    getAnchorElements(): HTMLAnchorElement[];
+}

package/lib/router/Router.d.ts

@@ -0,0 +1,41 @@
+import { splitPath, ChangeHistoryAction } from '../utils';
+import { Route, RouteModule } from './Route';
+import { Link } from './Link';
+
+export interface RouterPreprocessorEntry {
+    path: ReturnType<typeof splitPath>;
+    resolve: () => void;
+    reject: () => void;
+}
+export type RouterPreprocessor = (entry: RouterPreprocessorEntry) => void;
+export interface RouterPostprocessorEntry {
+    pathname: string;
+}
+export type RouterPostprocessor = (entry: RouterPostprocessorEntry) => void;
+export interface RouterAfterNavigationEntry {
+    pathname: string;
+}
+export type RouterAfterNavigationCallback = (entry: RouterAfterNavigationEntry) => void;
+export interface RouterParameters {
+    rootElement?: HTMLElement;
+    base?: string;
+}
+export declare class Router {
+    #private;
+    preprocessor?: RouterPreprocessor;
+    postprocessor?: RouterPostprocessor;
+    constructor(parameters?: RouterParameters);
+    get currentPathname(): string;
+    get candidatePathname(): string | undefined;
+    get routes(): Route[];
+    get links(): Link[];
+    navigationEvent(callback: RouterAfterNavigationCallback): () => void;
+    defineRoute(pattern: string, module: RouteModule): void;
+    navigate(path: string, action?: ChangeHistoryAction): Promise<void>;
+    normalizePath(path: string): {
+        leaf: string;
+        pathname: string;
+        parameters: string;
+        hash: string;
+    };
+}

package/lib/router/index.d.ts

@@ -0,0 +1,2 @@
+export { Router, type RouterPreprocessorEntry, type RouterPreprocessor, type RouterPostprocessor, type RouterAfterNavigationCallback, type RouterParameters, } from './Router';
+export { type RouteModule, type RouteParameters, type RouteURLParams, } from './Route';

package/lib/scroll/react/Scroll.d.ts

@@ -0,0 +1,14 @@
+import { ScrollElement } from '../vanilla';
+import { ReactCustomElement } from '../../utils';
+import { RefObject } from 'react';
+
+export type ReactScroll = ReactCustomElement<ScrollElement>;
+export declare function useScroll(): RefObject<ScrollElement>;
+export declare const Scroll: import('react').ForwardRefExoticComponent<Omit<ReactScroll, "ref"> & import('react').RefAttributes<ScrollElement>>;
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'e-scroll': ReactScroll;
+        }
+    }
+}

package/lib/scroll/react/ScrollBulletButtons.d.ts

@@ -0,0 +1,12 @@
+import { ScrollBulletButtonsElement } from '../vanilla';
+import { ReactCustomElement } from '../../utils';
+
+export type ReactScrollBulletButtons = ReactCustomElement<ScrollBulletButtonsElement>;
+export declare const ScrollBulletButtons: React.FC<ReactScrollBulletButtons>;
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'e-scroll-bullet-buttons': ReactScrollBulletButtons;
+        }
+    }
+}

package/lib/scroll/react/ScrollSegment.d.ts

@@ -0,0 +1,19 @@
+import { ScrollSegmentElement } from '../vanilla';
+import { ReactCustomElement } from '../../utils';
+
+export type ReactScrollSegment = ReactCustomElement<ScrollSegmentElement, {
+    onCapture?: () => void;
+    onCaptureFromStart?: () => void;
+    onCaptureFromFinish?: () => void;
+    onRelease?: () => void;
+    onReleaseFromStart?: () => void;
+    onReleaseFromFinish?: () => void;
+}>;
+export declare const ScrollSegment: import('react').ForwardRefExoticComponent<Omit<ReactScrollSegment, "ref"> & import('react').RefAttributes<ScrollSegmentElement>>;
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'e-scroll-segment': ReactScrollSegment;
+        }
+    }
+}

package/lib/scroll/react/ScrollSetButton.d.ts

@@ -0,0 +1,15 @@
+import { ScrollBehaviour, ScrollSetButtonElement } from '../vanilla';
+import { ReactCustomElement } from '../../utils';
+
+export type ReactScrollSetButton = ReactCustomElement<ScrollSetButtonElement, {
+    index?: number | string;
+    behaviour?: ScrollBehaviour;
+}>;
+export declare const ScrollSetButton: React.FC<ReactScrollSetButton>;
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'e-scroll-set-button': ReactScrollSetButton;
+        }
+    }
+}

package/lib/scroll/react/ScrollStepButton.d.ts

@@ -0,0 +1,15 @@
+import { ScrollBehaviour, ScrollStepButtonElement } from '../vanilla';
+import { ReactCustomElement } from '../../utils';
+
+export type ReactScrollStepButton = ReactCustomElement<ScrollStepButtonElement, {
+    step?: number | string;
+    behaviour?: ScrollBehaviour;
+}>;
+export declare const ScrollStepButton: React.FC<ReactScrollStepButton>;
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'e-scroll-step-button': ReactScrollStepButton;
+        }
+    }
+}

package/lib/scroll/react/Scrollbar.d.ts

@@ -0,0 +1,12 @@
+import { ScrollbarElement } from '../vanilla';
+import { ReactCustomElement } from '../../utils';
+
+export type ReactScrollbar = ReactCustomElement<ScrollbarElement>;
+export declare const Scrollbar: React.FC<ReactScrollbar>;
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'e-scrollbar': ReactScrollbar;
+        }
+    }
+}

package/lib/scroll/react/index.d.ts

@@ -0,0 +1,6 @@
+export { Scroll, useScroll, type ReactScroll } from './Scroll';
+export { Scrollbar, type ReactScrollbar } from './Scrollbar';
+export { ScrollBulletButtons, type ReactScrollBulletButtons, } from './ScrollBulletButtons';
+export { ScrollSegment, type ReactScrollSegment } from './ScrollSegment';
+export { ScrollSetButton, type ReactScrollSetButton } from './ScrollSetButton';
+export { ScrollStepButton, type ReactScrollStepButton, } from './ScrollStepButton';

package/lib/scroll/vanilla/ScrollBulletButtonsElement.d.ts

@@ -0,0 +1,12 @@
+import { ScrollUserElement } from './ScrollUserElement';
+
+export declare class ScrollBulletButtonsElement extends ScrollUserElement {
+    #private;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-scroll-bullet-buttons': ScrollBulletButtonsElement;
+    }
+}

package/lib/scroll/vanilla/ScrollButtonElement.d.ts

@@ -0,0 +1,6 @@
+import { ScrollUserElement } from './ScrollUserElement';
+
+export declare abstract class ScrollButtonElement extends ScrollUserElement {
+    constructor();
+    protected abstract handleClick(): void;
+}

package/lib/scroll/vanilla/ScrollElement.d.ts

@@ -0,0 +1,84 @@
+import { Damped } from '../../animation';
+import { Store } from '../../store/vanilla';
+import { Axes2D, EasingFunction } from '../../utils';
+import { CSSProperty } from '../../css-property';
+import { ScrollSection } from './ScrollSection';
+
+export interface ScrollEvents {
+    scrollSectionsChange: CustomEvent;
+}
+export type ScrollBehaviour = 'smooth' | 'instant';
+export interface ScrollSetOptions {
+    behaviour?: ScrollBehaviour;
+    tween?: {
+        easing?: EasingFunction;
+        duration: number;
+    };
+}
+export declare class ScrollElement extends HTMLElement {
+    #private;
+    constructor();
+    get damped(): Damped;
+    get controlsCSSProperty(): CSSProperty<boolean>;
+    get axisCSSProperty(): CSSProperty<Axes2D>;
+    get directionCSSProperty(): CSSProperty<number>;
+    get pagesCSSProperty(): CSSProperty<number>;
+    get splitCSSProperty(): CSSProperty<boolean>;
+    get sectionalCSSProperty(): CSSProperty<boolean>;
+    get autoSizeCSSProperty(): CSSProperty<boolean>;
+    get wheelMaxDeltaCSSProperty(): CSSProperty<boolean>;
+    get sectionsInViewCSSProperty(): CSSProperty<number>;
+    get loopCSSProperty(): CSSProperty<boolean>;
+    get dampingCSSProperty(): CSSProperty<number>;
+    get massCSSProperty(): CSSProperty<number>;
+    get stiffnessCSSProperty(): CSSProperty<number>;
+    get mouseDragCSSProperty(): CSSProperty<boolean>;
+    get sectionDistanceScaleCSSProperty(): CSSProperty<number>;
+    get autoplayCSSProperty(): CSSProperty<number>;
+    get autoplayPauseDurationCSSProperty(): CSSProperty<number>;
+    get autoplayUserDirectionCSSProperty(): CSSProperty<boolean>;
+    get classesCSSProperty(): CSSProperty<boolean>;
+    get currentIndexStartOffsetCSSProperty(): CSSProperty<number>;
+    get currentIndexEndOffsetCSSProperty(): CSSProperty<number>;
+    get focusDelayCSSProperty(): CSSProperty<number>;
+    get focusDurationCSSProperty(): CSSProperty<number>;
+    get disabledCSSProperty(): CSSProperty<boolean>;
+    get hibernatedCSSProperty(): CSSProperty<boolean>;
+    get currentScrollValue(): number;
+    get targetScrollValue(): number;
+    get contentElement(): HTMLElement;
+    get sections(): ScrollSection[];
+    get position(): number;
+    get contentPosition(): number;
+    get viewportSize(): number;
+    get scrollSize(): number;
+    get gap(): number;
+    get counter(): Store<number>;
+    get limit(): number;
+    get distance(): number;
+    get loopDistance(): number;
+    get overscroll(): number;
+    get vertical(): boolean;
+    get currentProgress(): number;
+    get targetProgress(): number;
+    get scrollWidth(): number;
+    get scrollHeight(): number;
+    onScroll(...parameters: Parameters<Damped['subscribe']>): () => void;
+    offScroll(...parameters: Parameters<Damped['unsubscribe']>): void;
+    range(from: number, distance: number, margin?: number): number;
+    curve(from: number, distance: number, margin?: number): number;
+    visible(from: number, distance: number, margin?: number): boolean;
+    scrollToSection(sectionIndex: number, options?: ScrollSetOptions): void;
+    shiftSections(step: number, options?: ScrollSetOptions): void;
+    setPosition(value: number, options?: ScrollSetOptions): void;
+    shiftPosition(value: number, options?: ScrollSetOptions): void;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-scroll': ScrollElement;
+    }
+    interface HTMLElementEventMap extends ScrollEvents {
+    }
+}

package/lib/scroll/vanilla/ScrollSection.d.ts

@@ -0,0 +1,26 @@
+import { ScrollElement } from './ScrollElement';
+
+export type ScrollSectionMark = 'current' | 'previous' | 'next' | null;
+export type ScrollSectionMarkChangeDetail = {
+    mark: ScrollSectionMark;
+};
+export interface ScrollSectionEvents {
+    scrollSectionMarkChange: ScrollSectionMarkChangeEvent;
+}
+export type ScrollSectionMarkChangeEvent = CustomEvent<ScrollSectionMarkChangeDetail>;
+export declare class ScrollSection {
+    #private;
+    constructor(element: HTMLElement, index: number, scrollElement: ScrollElement);
+    get index(): number;
+    get size(): number;
+    get position(): number;
+    destroy(): void;
+    setSize(value?: number): void;
+    resize(): void;
+    transform(): void;
+    mark(mark: ScrollSectionMark): void;
+}
+declare global {
+    interface HTMLElementEventMap extends ScrollSectionEvents {
+    }
+}

package/lib/scroll/vanilla/ScrollSegmentElement.d.ts

@@ -0,0 +1,67 @@
+import { CSSProperty } from '../../css-property';
+import { Store } from '../../store/vanilla';
+import { Damped } from '../../animation';
+import { ScrollUserElement } from './ScrollUserElement';
+
+export interface ScrollSegmentEvents {
+    scrollSegmentCapture: CustomEvent;
+    scrollSegmentCaptureFromStart: CustomEvent;
+    scrollSegmentCaptureFromFinish: CustomEvent;
+    scrollSegmentRelease: CustomEvent;
+    scrollSegmentReleaseFromStart: CustomEvent;
+    scrollSegmentReleaseFromFinish: CustomEvent;
+}
+export declare class ScrollSegmentElement extends ScrollUserElement {
+    #private;
+    get distanceOffsetCSSProperty(): CSSProperty<number>;
+    get startOffsetCSSProperty(): CSSProperty<number>;
+    get captureOnceCSSProperty(): CSSProperty<boolean>;
+    get capturedCSSProperty(): CSSProperty<string>;
+    get releasedCSSProperty(): CSSProperty<string>;
+    get capturedFromStartCSSProperty(): CSSProperty<string>;
+    get capturedFromFinishCSSProperty(): CSSProperty<string>;
+    get releasedFromStartCSSProperty(): CSSProperty<string>;
+    get releasedFromFinishCSSProperty(): CSSProperty<string>;
+    get passedVarCSSProperty(): CSSProperty<string>;
+    get progressVarCSSProperty(): CSSProperty<string>;
+    get distanceVarCSSProperty(): CSSProperty<string>;
+    get startVarCSSProperty(): CSSProperty<string>;
+    get finishVarCSSProperty(): CSSProperty<string>;
+    get disabledCSSProperty(): CSSProperty<boolean>;
+    get dampingCSSProperty(): CSSProperty<number>;
+    get massCSSProperty(): CSSProperty<number>;
+    get stiffnessCSSProperty(): CSSProperty<number>;
+    get targetCSSProperty(): CSSProperty<string>;
+    get isCaptured(): Store<boolean>;
+    get isReleased(): Store<boolean>;
+    get isCapturedFromStart(): Store<boolean>;
+    get isReleasedFromStart(): Store<boolean>;
+    get isCapturedFromFinish(): Store<boolean>;
+    get isReleasedFromFinish(): Store<boolean>;
+    get directionPosition(): number;
+    get directionSize(): number;
+    get passed(): Damped;
+    get progress(): number;
+    get start(): number;
+    get finish(): number;
+    get distance(): number;
+    get isCapturedOnce(): boolean;
+    get isDisabled(): boolean;
+    resize(): void;
+    tick(): void;
+    disable(): void;
+    enable(): void;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+    protected removeVar(name: string | undefined): void;
+    protected setVar(name: string | undefined, value: string | number): void;
+    protected getDistance(): number;
+    protected getStart(): number;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-scroll-segment': ScrollSegmentElement;
+    }
+    interface HTMLElementEventMap extends ScrollSegmentEvents {
+    }
+}

package/lib/scroll/vanilla/ScrollSetButtonElement.d.ts

@@ -0,0 +1,10 @@
+import { ScrollButtonElement } from './ScrollButtonElement';
+
+export declare class ScrollSetButtonElement extends ScrollButtonElement {
+    protected handleClick(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-scroll-set-button': ScrollSetButtonElement;
+    }
+}

package/lib/scroll/vanilla/ScrollStepButtonElement.d.ts

@@ -0,0 +1,10 @@
+import { ScrollButtonElement } from './ScrollButtonElement';
+
+export declare class ScrollStepButtonElement extends ScrollButtonElement {
+    protected handleClick(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-scroll-step-button': ScrollStepButtonElement;
+    }
+}

package/lib/scroll/vanilla/ScrollUserElement.d.ts

@@ -0,0 +1,7 @@
+import { ScrollElement } from './ScrollElement';
+
+export declare class ScrollUserElement extends HTMLElement {
+    #private;
+    get scrollElement(): ScrollElement;
+    protected connectedCallback(): void;
+}

package/lib/scroll/vanilla/ScrollbarElement.d.ts

@@ -0,0 +1,14 @@
+import { ScrollUserElement } from './ScrollUserElement';
+
+export declare class ScrollbarElement extends ScrollUserElement {
+    #private;
+    constructor();
+    get thumbElement(): HTMLElement;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-scrollbar': ScrollbarElement;
+    }
+}

package/lib/scroll/vanilla/index.d.ts

@@ -0,0 +1,6 @@
+export { ScrollElement, type ScrollBehaviour, type ScrollEvents, } from './ScrollElement';
+export { ScrollbarElement } from './ScrollbarElement';
+export { ScrollSetButtonElement } from './ScrollSetButtonElement';
+export { ScrollStepButtonElement } from './ScrollStepButtonElement';
+export { ScrollBulletButtonsElement } from './ScrollBulletButtonsElement';
+export { ScrollSegmentElement, type ScrollSegmentEvents, } from './ScrollSegmentElement';

package/lib/scroll-entries/index.d.ts

@@ -0,0 +1,21 @@
+import { Notifier } from '../notifier';
+import { Axes2D } from '../utils';
+
+export interface ScrollEntry {
+    axis: Axes2D;
+    value: number;
+    element: HTMLElement;
+}
+export type ScrollEntriesRegisterCallback = () => void;
+declare class ScrollEntries {
+    #private;
+    get notifier(): Notifier<ScrollEntriesRegisterCallback>;
+    register(element: HTMLElement): void;
+    unregister(element: HTMLElement): void;
+    update(element: HTMLElement, axis: Axes2D, value: number): void;
+    hasEntry(element: HTMLElement): boolean;
+    getEntry(element: HTMLElement): ScrollEntry;
+    getAll(element: HTMLElement): ScrollEntry[];
+}
+export declare const scrollEntries: ScrollEntries;
+export {};