aptechka 0.16.0 → 0.18.0

package/lib/animation/Animation.d.ts

@@ -0,0 +1,34 @@
+import { Store, StoreOptions } from '../store';
+import { TickerAddOptions, TickerCallbackEntry } from '../ticker';
+export interface AnimationOptions extends TickerAddOptions {
+    min?: number;
+    max?: number;
+    equalize?: boolean;
+    restart?: boolean;
+}
+export type AnimationConstructorOptions<Options extends AnimationOptions> = StoreOptions<number> & Options;
+export declare abstract class Animation<Options extends AnimationOptions = AnimationOptions> extends Store<number> {
+    #private;
+    constructor(initial?: number, options?: StoreOptions<number>);
+    get direction(): number;
+    get target(): number;
+    get min(): number;
+    set min(value: number);
+    get max(): number;
+    set max(value: number);
+    get from(): number;
+    get isRunning(): Store<boolean>;
+    get delta(): number;
+    get deltaProgress(): number;
+    get distance(): number;
+    get distanceProgress(): number;
+    set(value: number, options?: Options): void;
+    shift(value: number, options?: Options): void;
+    reset(): void;
+    close(): void;
+    listenAnimationFrame(): void;
+    unlistenAnimationFrame(): void;
+    updateOptions(options?: AnimationOptions): void;
+    protected start(): void;
+    protected abstract handleAnimationFrame(e: TickerCallbackEntry): void;
+}

package/lib/animation/Damped.d.ts

@@ -0,0 +1,18 @@
+import { TickerCallbackEntry } from '../ticker';
+import { Animation, AnimationConstructorOptions, AnimationOptions } from './Animation';
+export interface DampedOptions extends AnimationOptions {
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+}
+export declare class Damped extends Animation<DampedOptions> {
+    #private;
+    damping: number;
+    stiffness: number;
+    mass: number;
+    constructor(initial?: number, options?: AnimationConstructorOptions<DampedOptions>);
+    get velocity(): number;
+    get speed(): number;
+    updateOptions(options?: DampedOptions): void;
+    protected handleAnimationFrame(e: TickerCallbackEntry): void;
+}

package/lib/animation/Tweened.d.ts

@@ -0,0 +1,14 @@
+import { TickerCallbackEntry } from '../ticker';
+import { EasingFunction } from '../utils';
+import { Animation, AnimationConstructorOptions, AnimationOptions } from './Animation';
+export interface TweenedOptions extends AnimationOptions {
+    easing?: EasingFunction;
+    duration?: number;
+}
+export declare class Tweened extends Animation<TweenedOptions> {
+    #private;
+    constructor(initial?: number, options?: AnimationConstructorOptions<TweenedOptions>);
+    updateOptions(options?: TweenedOptions): void;
+    protected handleAnimationFrame(e: TickerCallbackEntry): void;
+    protected start(): void;
+}

package/lib/animation/index.d.ts

@@ -0,0 +1,3 @@
+export { Animation, type AnimationOptions } from './Animation';
+export { Damped, type DampedOptions } from './Damped';
+export { Tweened, type TweenedOptions } from './Tweened';

package/lib/attribute/index.d.ts

@@ -0,0 +1,14 @@
+import { Store, StoreCallback, StoreOptions } from '../store';
+import { ElementOrSelector } from '../utils';
+export interface AttributeOptions<T> extends StoreOptions<T> {
+    sync?: boolean;
+}
+export declare class Attribute<T extends string | number | boolean> extends Store<T> {
+    #private;
+    constructor(elementOrSelector: ElementOrSelector, name: string, defaultValue: T, options?: AttributeOptions<T>);
+    subscribe(callback: StoreCallback<T>): () => void;
+    unsubscribe(callback: StoreCallback<T>): void;
+    observe(): void;
+    unobserve(): void;
+    close(): void;
+}

package/lib/canvas/index.d.ts

@@ -0,0 +1,34 @@
+import { CSSProperty } from '../css-property';
+export interface Canvas2DRenderDetail {
+    pixelRatio: number;
+    width: number;
+    height: number;
+    element: HTMLElement;
+    canvasElement: HTMLCanvasElement;
+    context: CanvasRenderingContext2D;
+    timestamp: number;
+    timeBetweenFrames: number;
+}
+export type CanvasRenderEvent = CustomEvent<Canvas2DRenderDetail>;
+export declare class CanvasElement extends HTMLElement {
+    #private;
+    constructor();
+    get fpsCSSProperty(): CSSProperty<number>;
+    get canvasElement(): HTMLCanvasElement;
+    get context(): CanvasRenderingContext2D;
+    get pixelRatio(): number;
+    get width(): number;
+    get height(): number;
+    get detail(): Canvas2DRenderDetail;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-canvas': CanvasElement;
+    }
+    interface HTMLElementEventMap {
+        canvasRender: CanvasRenderEvent;
+        canvasResize: CanvasRenderEvent;
+    }
+}

package/lib/class-linked-status/index.d.ts

@@ -0,0 +1,11 @@
+import { Store } from '../store';
+export declare class ClassLinkedStatus<T extends {
+    [key in string]: boolean;
+}> extends Store<T> {
+    #private;
+    constructor(element: HTMLElement, value: T);
+    isTrue(key: keyof T): boolean;
+    isFalse(key: keyof T): boolean;
+    reset(): void;
+    set(key: keyof T, value?: boolean): void;
+}

package/lib/connector/index.d.ts

@@ -0,0 +1,15 @@
+export type ConnectorConnectCallback<T extends Node = Node> = (node: T) => void;
+export type ConnectorDisconnectCallback<T extends Node = Node> = (node: T, expired?: boolean) => void;
+export interface ConnectorOptions {
+    connectCallback?: ConnectorConnectCallback;
+    disconnectCallback?: ConnectorDisconnectCallback;
+    maxWaitSec?: number;
+    unsubscribeAfterDisconnect?: boolean;
+}
+export declare class Connector {
+    #private;
+    subscribe(node: Node, options: ConnectorOptions): () => void;
+    unsubscribe(options: ConnectorOptions): void;
+    destroy(): void;
+}
+export declare const connector: Connector;

package/lib/controls/AutoplayControls.d.ts

@@ -0,0 +1,16 @@
+import { TickerAddOptions } from '../ticker';
+import { Controls } from './Controls';
+export interface AutoplayControlsOptions extends TickerAddOptions {
+    speed?: number;
+    interval?: boolean;
+}
+export declare class AutoplayControls extends Controls {
+    #private;
+    direction: number;
+    constructor(options?: AutoplayControlsOptions);
+    set interval(value: boolean);
+    set speed(value: number);
+    connect(): void;
+    disconnect(): void;
+    pauseAndContinue(duration: number): void;
+}

package/lib/controls/Controls.d.ts

@@ -0,0 +1,8 @@
+import { Notifier } from '../notifier';
+export type ControlsCallback = (type: string, value: number) => void;
+export declare abstract class Controls {
+    #private;
+    get changeEvent(): Notifier<ControlsCallback>;
+    abstract connect(): void;
+    abstract disconnect(): void;
+}

package/lib/controls/DragControls.d.ts

@@ -0,0 +1,15 @@
+import { Axes2D } from '../utils';
+import { Controls } from './Controls';
+export interface DragControlsOptions {
+    element?: HTMLElement;
+    axis?: Axes2D;
+    swipe?: boolean;
+}
+export declare class DragControls extends Controls {
+    #private;
+    axis: Axes2D;
+    swipe: boolean;
+    constructor(options?: DragControlsOptions);
+    connect(): void;
+    disconnect(): void;
+}

package/lib/controls/KeyboardControls.d.ts

@@ -0,0 +1,13 @@
+import { Controls } from './Controls';
+export type KeyboardControlsDimension = 'height' | 'width';
+export interface KeyboardControlsOptions {
+    element?: HTMLElement;
+    dimension?: KeyboardControlsDimension;
+}
+export declare class KeyboardControls extends Controls {
+    #private;
+    constructor(options?: KeyboardControlsOptions);
+    set dimension(value: KeyboardControlsDimension | undefined | null);
+    connect(): void;
+    disconnect(): void;
+}

package/lib/controls/WheelControls.d.ts

@@ -0,0 +1,18 @@
+import { Axes2D } from '../utils';
+import { Controls } from './Controls';
+export type WheelControlsAxis = Axes2D | 'max';
+export interface WheelControlsOptions {
+    axis?: WheelControlsAxis;
+    speed?: number;
+    debounce?: boolean;
+    element?: HTMLElement;
+}
+export declare class WheelControls extends Controls {
+    #private;
+    axis: WheelControlsAxis;
+    speed: number;
+    debounce: boolean;
+    constructor(options?: WheelControlsOptions);
+    connect(): void;
+    disconnect(): void;
+}

package/lib/controls/index.d.ts

@@ -0,0 +1,5 @@
+export { Controls } from './Controls';
+export { KeyboardControls } from './KeyboardControls';
+export { AutoplayControls, type AutoplayControlsOptions, } from './AutoplayControls';
+export { WheelControls, type WheelControlsOptions } from './WheelControls';
+export { DragControls, type DragControlsOptions } from './DragControls';

package/lib/css-property/index.d.ts

@@ -0,0 +1,16 @@
+import { Store, StoreCallback, StoreOptions } from '../store';
+import { ElementOrSelector } from '../utils';
+export interface CSSPropertyOptions<StoreType extends number | boolean | string> extends StoreOptions<StoreType> {
+    rawValueCheck?: boolean;
+}
+export declare class CSSProperty<StoreType extends number | boolean | string> extends Store<StoreType> {
+    #private;
+    constructor(elementOrSelector: ElementOrSelector<HTMLElement>, property: string, defaultValue: StoreType, options?: CSSPropertyOptions<StoreType>);
+    get currentRawValue(): string;
+    observe(): void;
+    unobserve(): void;
+    subscribe(callback: StoreCallback<StoreType>): () => void;
+    unsubscribe(callback: StoreCallback<StoreType>): void;
+    close(): void;
+    check(): void;
+}

package/lib/css-unit-parser/index.d.ts

@@ -0,0 +1,6 @@
+declare class CSSUnitParser {
+    #private;
+    parse(value: string): number;
+}
+export declare const cssUnitParser: CSSUnitParser;
+export {};

package/lib/css-value-parser/index.d.ts

@@ -0,0 +1,6 @@
+declare class CSSValueParser {
+    static CSS_UNITS: Set<string>;
+    parse(value: string, element?: HTMLElement): any;
+}
+export declare const cssValueParser: CSSValueParser;
+export {};

package/lib/dev/index.d.ts

@@ -0,0 +1 @@
+export declare function devMode(): void;

package/lib/device/Device.d.ts

@@ -0,0 +1,18 @@
+import { TierResult } from 'detect-gpu';
+export type DeviceOS = 'macOS' | 'iOS' | 'Windows' | 'Android' | 'Linux' | 'unknown';
+declare class Device {
+    #private;
+    constructor();
+    get OS(): string;
+    get gpu(): string;
+    get gpuTier(): number;
+    get gpuDetection(): Promise<TierResult>;
+    get isMobile(): boolean;
+    get isTouch(): boolean;
+    get isWebgl(): boolean;
+    get isWebp(): boolean;
+    get isApple(): boolean;
+    resize: () => void;
+}
+export declare const device: Device;
+export {};

package/lib/device/Viewport.d.ts

@@ -0,0 +1,28 @@
+import { Store } from '../store';
+export declare enum ViewportBreakpoints {
+    'mobile' = "600px",
+    'tablet' = "1024px",
+    'notebook' = "1280px",
+    'desktop' = "1281px"
+}
+export declare enum ViewportMediaRules {
+    '<=mobile' = "(max-width: 600px)",
+    '>=mobile' = "(min-width: 601px)",
+    '<=tablet' = "(max-width: 1024px)",
+    '>=tablet' = "(min-width: 1025px)",
+    '<=notebook' = "(max-width: 1280px)",
+    '>=notebook' = "(min-width: 1281px)",
+    '<=desktop' = "(max-width: 1280px)",
+    '>=desktop' = "(min-width: 1281px)"
+}
+declare class Viewport {
+    #private;
+    constructor();
+    get width(): number;
+    get height(): number;
+    get type(): Store<"mobile" | "tablet" | "notebook" | "desktop" | undefined>;
+    get pixelRatio(): number;
+    resize: () => void;
+}
+export declare const viewport: Viewport;
+export {};

package/lib/device/index.d.ts

@@ -0,0 +1,2 @@
+export { device, type DeviceOS } from './Device';
+export { viewport, ViewportBreakpoints, ViewportMediaRules } from './Viewport';

package/lib/element-resizer/index.d.ts

@@ -0,0 +1,9 @@
+import { ElementOrSelector } from '../utils';
+export type ElementResizerCallback = (entry: ResizeObserverEntry) => void;
+export declare class ElementResizer {
+    #private;
+    constructor();
+    subscribe(elementOrSelector: ElementOrSelector, callback: ElementResizerCallback): () => void;
+    unsubscribe(callback: ElementResizerCallback): void;
+}
+export declare const elementResizer: ElementResizer;

package/lib/image/index.d.ts

@@ -0,0 +1,10 @@
+import { SourceElement } from '../source';
+export declare class ImageElement extends SourceElement<HTMLImageElement> {
+    protected createConsumer(): HTMLImageElement;
+    protected consumeSource(url: string | null): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-image': ImageElement;
+    }
+}

package/lib/intersector/index.d.ts

@@ -0,0 +1,9 @@
+import { ElementOrSelector } from '../utils';
+export type IntersectorCallback = (entry: IntersectionObserverEntry) => void;
+export declare class Intersector {
+    #private;
+    constructor();
+    subscribe(elementOrSelector: ElementOrSelector, callback: IntersectorCallback): () => void;
+    unsubscribe(callback: IntersectorCallback): void;
+}
+export declare const intersector: Intersector;

package/lib/ladder/index.d.ts

@@ -0,0 +1,23 @@
+import { Store } from '../store';
+export type LadderDefaultStepName = number | string;
+export type LadderOperation = '+' | '*' | '/' | '-';
+export type LadderStep<T> = [LadderOperation, T];
+export type LadderSteps<K, T> = Map<K, LadderStep<T>>;
+export type LadderDefaultValueType = {
+    [key: string]: number;
+};
+export declare class Ladder<V extends LadderDefaultValueType = LadderDefaultValueType, K extends LadderDefaultStepName = LadderDefaultStepName> extends Store<V> {
+    #private;
+    constructor(base: V);
+    get base(): V;
+    get steps(): LadderSteps<K, V>;
+    close(): void;
+    bind(sub: V): void;
+    unbind(sub: V): void;
+    deleteStep(stepName: K): void;
+    getStepValue(stepName: K): V;
+    getExcludedStepsValue(...stepNames: Array<K>): V;
+    getIncludedStepsValue(...stepNames: Array<K>): V;
+    setStep(stepName: K, action: LadderOperation, value: Partial<V>): void;
+    calculate(): void;
+}

package/lib/layout-box/index.d.ts

@@ -0,0 +1,95 @@
+import { Ladder } from '../ladder';
+import { StoreCallback } from '../store';
+import { ElementOrSelector, Axes3D, Axes2D } from '../utils';
+import { Notifier } from '../notifier';
+export declare function decomposeCSSMatrix(matrix: WebKitCSSMatrix): {
+    scaleX: number;
+    scaleY: number;
+    scaleZ: number;
+    rotationX: number;
+    rotationY: number;
+    rotationZ: number;
+    translationX: number;
+    translationY: number;
+    translationZ: number;
+};
+export interface LayoutBoxOptions {
+    containerElement?: ElementOrSelector<HTMLElement>;
+    cartesian?: boolean;
+    scrollAxis?: Axes3D | 'auto';
+    frontSide?: LayoutBoxFrontSide;
+    sizeStep?: boolean;
+    positionStep?: boolean;
+    culling?: boolean;
+    transformStep?: boolean;
+    scrollStep?: boolean;
+}
+export interface LayoutBoxScrollStepCallbackReturn {
+    axis: Axes2D;
+    value: number;
+}
+export type LayoutBoxXYZ = {
+    x: number;
+    y: number;
+    z: number;
+};
+export type LayoutBoxScrollStepCallback = () => LayoutBoxScrollStepCallbackReturn;
+export type LayoutBoxStepCallback = StoreCallback<LayoutBoxXYZ>;
+export type LayoutBoxFrontSide = 'left' | 'top';
+export interface LayoutBoxBindedObject {
+    position?: LayoutBoxXYZ;
+    scale?: LayoutBoxXYZ;
+    rotation?: LayoutBoxXYZ;
+}
+export type LayoutBoxLadder = {
+    x: number;
+    y: number;
+    z: number;
+};
+export declare class LayoutBox {
+    #private;
+    constructor(element: ElementOrSelector<HTMLElement>, options?: LayoutBoxOptions);
+    get element(): HTMLElement;
+    get containerElement(): HTMLElement;
+    get position(): LayoutBoxLadder;
+    get rotation(): LayoutBoxLadder;
+    get scale(): LayoutBoxLadder;
+    get scrollValue(): LayoutBoxXYZ;
+    get left(): number;
+    get top(): number;
+    get CSSTranslation(): LayoutBoxXYZ;
+    get CSSRotation(): LayoutBoxXYZ;
+    get CSSScale(): LayoutBoxXYZ;
+    get front(): number;
+    get width(): number;
+    get height(): number;
+    get depth(): number;
+    destroy(): void;
+    bindObject(object: LayoutBoxBindedObject): void;
+    unbindObject(object: LayoutBoxBindedObject): void;
+    setScrollStep(callback: LayoutBoxScrollStepCallback): () => void;
+    deleteScrollStep(callback: LayoutBoxScrollStepCallback): void;
+    setPositionStep(...args: Parameters<Ladder<LayoutBoxLadder>['setStep']>): void;
+    getPositionStep(...args: Parameters<Ladder<LayoutBoxLadder>['getStepValue']>): LayoutBoxLadder;
+    setRotationStep(...args: Parameters<Ladder<LayoutBoxLadder>['setStep']>): void;
+    getRotationStep(...args: Parameters<Ladder<LayoutBoxLadder>['getStepValue']>): LayoutBoxLadder;
+    getExcludedRotationSteps(...args: Parameters<Ladder<LayoutBoxLadder>['getExcludedStepsValue']>): LayoutBoxLadder;
+    getIncludedRotationSteps(...args: Parameters<Ladder<LayoutBoxLadder>['getIncludedStepsValue']>): LayoutBoxLadder;
+    setScaleStep(...args: Parameters<Ladder<LayoutBoxLadder>['setStep']>): void;
+    getScaleStep(...args: Parameters<Ladder<LayoutBoxLadder>['getStepValue']>): LayoutBoxLadder;
+    getExcludedScaleSteps(...args: Parameters<Ladder<LayoutBoxLadder>['getExcludedStepsValue']>): LayoutBoxLadder;
+    getIncludedScaleSteps(...args: Parameters<Ladder<LayoutBoxLadder>['getIncludedStepsValue']>): LayoutBoxLadder;
+    deletePositionStep(...args: Parameters<Ladder<LayoutBoxLadder>['deleteStep']>): void;
+    getExcludedPositionSteps(...args: Parameters<Ladder<LayoutBoxLadder>['getExcludedStepsValue']>): LayoutBoxLadder;
+    getIncludedPositionSteps(...args: Parameters<Ladder<LayoutBoxLadder>['getIncludedStepsValue']>): LayoutBoxLadder;
+    deleteRotationStep(...args: Parameters<Ladder<LayoutBoxLadder>['deleteStep']>): void;
+    deleteScaleStep(...args: Parameters<Ladder<LayoutBoxLadder>['deleteStep']>): void;
+    onPosition(...args: Parameters<Ladder<LayoutBoxLadder>['subscribe']>): () => void;
+    offPosition(...args: Parameters<Ladder<LayoutBoxLadder>['unsubscribe']>): void;
+    onScale(...args: Parameters<Ladder<LayoutBoxLadder>['subscribe']>): () => void;
+    offScale(...args: Parameters<Ladder<LayoutBoxLadder>['unsubscribe']>): void;
+    onRotation(...args: Parameters<Ladder<LayoutBoxLadder>['subscribe']>): () => void;
+    offRotation(...args: Parameters<Ladder<LayoutBoxLadder>['unsubscribe']>): void;
+    onResize(...args: Parameters<Notifier['subscribe']>): () => void;
+    offResize(...args: Parameters<Notifier['unsubscribe']>): void;
+}

package/lib/loading/index.d.ts

@@ -0,0 +1,38 @@
+import { Notifier } from '../notifier';
+export interface LoadingProgressDetail {
+    loaded: number;
+    total: number;
+    progress: number;
+    namespace: string;
+}
+export interface LoadingErrorDetail {
+    namespace: string;
+    url: string;
+}
+export interface LoadingCompleteDetail {
+    total: number;
+}
+export type LoadingProgressSubscriber = (detail: LoadingProgressDetail) => void;
+export type LoadingErrorSubscriber = (detail: LoadingErrorDetail) => void;
+export type LoadingCompleteSubscriber = (detail: LoadingCompleteDetail) => void;
+declare class Loading {
+    #private;
+    get progressEvent(): Notifier<LoadingProgressSubscriber>;
+    get completeEvent(): Notifier<LoadingCompleteSubscriber>;
+    get errorEvent(): Notifier<LoadingErrorSubscriber>;
+    get _counter(): Map<string, {
+        total: number;
+        loaded: number;
+    }>;
+    get isComplete(): boolean;
+    reset(): void;
+    setTotal(namespace: string, total?: number): void;
+    setLoaded(namespace: string, loaded?: number): void;
+    setError(namespace: string, url: string): void;
+    getStats(): {
+        loaded: number;
+        total: number;
+    };
+}
+export declare const loading: Loading;
+export {};

package/lib/media/index.d.ts

@@ -0,0 +1,11 @@
+import { Store } from '../store';
+export type MediaCallback = () => void;
+export type MediaQueries<T extends string = string> = Map<T, {
+    match: MediaCallback;
+    unmatch?: MediaCallback;
+}>;
+export declare class Media extends Store<boolean> {
+    #private;
+    constructor(query: string);
+    close(): void;
+}

package/lib/need_redo_tweaker/CheckboxElement.d.ts

@@ -0,0 +1,14 @@
+export declare class CheckboxElement extends HTMLElement {
+    #private;
+    static formAssociated: boolean;
+    constructor();
+    get checked(): boolean;
+    set checked(state: boolean);
+    get value(): string;
+    set value(value: string);
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-checkbox': CheckboxElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerBooleanManagerElement.d.ts

@@ -0,0 +1,10 @@
+import { Store } from '../store/Store';
+import { TweakerStoreManagerElement } from './TweakerStoreManagerElement';
+export declare class TweakerBooleanManagerElement extends TweakerStoreManagerElement<Store<boolean>> {
+    constructor(...stores: Array<Store<boolean>>);
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker-boolean-manager': TweakerBooleanManagerElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerColorManagerElement.d.ts

@@ -0,0 +1,10 @@
+import { Store } from '../store/Store';
+import { TweakerStoreManagerElement } from './TweakerStoreManagerElement';
+export declare class TweakerColorManagerElement extends TweakerStoreManagerElement<Store<string>> {
+    constructor(...stores: Array<Store<string>>);
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker-color-manager': TweakerColorManagerElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerElement.d.ts

@@ -0,0 +1,17 @@
+import { Store } from '../store';
+import { TweakerFolderElement } from './TweakerFolderElement';
+export interface StoreBox {
+    store: Store;
+    remainingFolders: Array<string>;
+}
+export declare class TweakerElement extends TweakerFolderElement {
+    #private;
+    constructor();
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker': TweakerElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerFieldElement.d.ts

@@ -0,0 +1,19 @@
+import { Store } from '../store';
+export interface TweakerFieldParameters {
+    store: Store<any>;
+}
+export declare class TweakerFieldElement extends HTMLElement {
+    #private;
+    constructor(parameters: TweakerFieldParameters);
+    get key(): string;
+    get name(): string;
+    get stores(): Store<any>[];
+    addStore(store: Store<any>): void;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker-field': TweakerFieldElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerFolderElement.d.ts

@@ -0,0 +1,23 @@
+import { Store } from '../store';
+import { TweakerFieldElement } from './TweakerFieldElement';
+import { StoreBox } from './TweakerElement';
+export interface TweakerFolderParameters {
+    key: string;
+    storeBox?: StoreBox;
+}
+export declare class TweakerFolderElement extends HTMLElement {
+    #private;
+    constructor(parameters: TweakerFolderParameters);
+    get key(): string;
+    get head(): Store<any>;
+    get content(): Store<(TweakerFieldElement | TweakerFolderElement)[]>;
+    get bodyElement(): HTMLElement;
+    get contentElement(): HTMLElement;
+    protected connectedCallback(): void;
+    protected handleStore(storeBox: StoreBox): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker-folder': TweakerFolderElement;
+    }
+}

package/lib/need_redo_tweaker/TweakerLinkManagerElement.d.ts

@@ -0,0 +1,10 @@
+import { Store } from '../store';
+import { TweakerStoreManagerElement } from './TweakerStoreManagerElement';
+export declare class TweakerLinkManagerElement extends TweakerStoreManagerElement<Store<string>> {
+    constructor(...stores: Array<Store<string>>);
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-tweaker-link-manager': TweakerLinkManagerElement;
+    }
+}