aptechka 0.26.1 → 0.26.3

package/lib/animation/Animation.d.ts

@@ -0,0 +1,35 @@
+import { Store, StoreOptions } from '../store/vanilla';
+import { TickerAddOptions, TickerCallbackEntry } from '../ticker/vanilla';
+
+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,19 @@
+import { TickerCallbackEntry } from '../ticker/vanilla';
+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,15 @@
+import { TickerCallbackEntry } from '../ticker/vanilla';
+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,15 @@
+import { Store, StoreSubscribeCallback, StoreOptions } from '../store/vanilla';
+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: StoreSubscribeCallback<T>): () => void;
+    unsubscribe(callback: StoreSubscribeCallback<T>): void;
+    observe(): void;
+    unobserve(): void;
+    close(): void;
+}

package/lib/canvas/index.d.ts

@@ -0,0 +1,35 @@
+import { CSSProperty } from '../css-property';
+
+export interface CanvasRenderDetail {
+    pixelRatio: number;
+    width: number;
+    height: number;
+    element: HTMLElement;
+    canvasElement: HTMLCanvasElement;
+    context: CanvasRenderingContext2D;
+    timestamp: number;
+    timeBetweenFrames: number;
+}
+export type CanvasRenderEvent = CustomEvent<CanvasRenderDetail>;
+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(): CanvasRenderDetail;
+    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,12 @@
+import { Store } from '../store/vanilla';
+
+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,17 @@
+import { TickerAddOptions } from '../ticker/vanilla';
+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,9 @@
+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,16 @@
+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,14 @@
+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,19 @@
+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,17 @@
+import { Store, StoreSubscribeCallback, StoreOptions } from '../store/vanilla';
+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: StoreSubscribeCallback<StoreType>): () => void;
+    unsubscribe(callback: StoreSubscribeCallback<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,16 @@
+export type DeviceOS = 'macOS' | 'iOS' | 'Windows' | 'Android' | 'Linux' | 'unknown';
+declare class Device {
+    #private;
+    constructor();
+    get OS(): string;
+    get gpu(): string;
+    get gpuTier(): number;
+    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,29 @@
+import { Store } from '../store/vanilla';
+
+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/react/index.d.ts

@@ -0,0 +1,3 @@
+import { ElementResizer } from '../vanilla';
+
+export declare function useElementResizer([callback, order]: Parameters<ElementResizer['subscribe']>): void;

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

@@ -0,0 +1,10 @@
+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/en3/En3Raycaster.d.ts

@@ -0,0 +1,21 @@
+import { Intersection, Object3D } from 'three';
+
+export type En3RaycasterEventType = 'pointerDown' | 'pointerUp' | 'pointerMove' | 'pointerLeave' | 'pointerEnter' | 'pointerMove';
+export type En3RaycasterEvent = {
+    type: En3RaycasterEventType;
+    originalEvent: PointerEvent;
+    target: Object3D;
+} & Intersection<Object3D>;
+export interface En3RaycasterOptions {
+    targetName?: string;
+    eventDispatcher?: Object3D;
+    propagation?: boolean;
+}
+export type En3RaycasterCallback = (event: En3RaycasterEvent) => void;
+export declare class En3Raycaster {
+    #private;
+    constructor();
+    destroy(): void;
+    add(object3D: Object3D, options?: En3RaycasterOptions): void;
+    remove(object3D: Object3D): void;
+}

package/lib/en3/En3View.d.ts

@@ -0,0 +1,40 @@
+import { LayoutBox, LayoutBoxOptions } from '../layout-box';
+import { ElementOrSelector } from '../utils';
+import { Object3D, OrthographicCamera, PerspectiveCamera, Scene } from 'three';
+
+export interface En3ViewOptions {
+    cameraType?: 'perspective' | 'orthographic';
+    cameraDistance?: number;
+    cameraNear?: number;
+    cameraFar?: number;
+    cameraFov?: 'auto' | number;
+    sizeElement?: ElementOrSelector<HTMLElement>;
+    beforeRender?: () => void;
+}
+export type En3AttachedObject3D<T extends Object3D> = T & {
+    userData: {
+        box: LayoutBox;
+    };
+};
+export type En3AttachOptions = Omit<LayoutBoxOptions, 'containerElement' | 'cartesian' | 'scrollStep'>;
+export type En3ViewBeforeRenderCallback = () => void;
+export declare class En3View {
+    #private;
+    beforeRenderCallback: En3ViewBeforeRenderCallback | undefined;
+    constructor(name: string, options?: En3ViewOptions);
+    get name(): string;
+    get camera(): PerspectiveCamera | OrthographicCamera;
+    get scene(): Scene;
+    get box(): LayoutBox;
+    get cameraDistance(): number;
+    set cameraDistance(value: number);
+    get sizeElement(): HTMLElement;
+    get isClipped(): boolean;
+    resize(): void;
+    destroy(): void;
+    attachToHTMLElement<T extends Object3D>(element: ElementOrSelector<HTMLElement>, object: T, options?: En3AttachOptions): En3AttachedObject3D<T>;
+    detachFromHTMLElement(object: Object3D): void;
+    add<T extends Object3D<any>>(object: T): T;
+    add<T extends Object3D<any>>(object: T, element: ElementOrSelector<HTMLElement>, options?: En3AttachOptions): En3AttachedObject3D<T>;
+    remove(object: Object3D, detach?: boolean): void;
+}

package/lib/en3/en3.d.ts

@@ -0,0 +1,37 @@
+import { ElementOrSelector } from '../utils';
+import { WebGLRenderer, WebGLRendererParameters } from 'three';
+import { En3View, En3ViewOptions } from './En3View';
+import { En3Raycaster } from './En3Raycaster';
+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
+
+export interface En3Options {
+    webGLRendererParameters?: WebGLRendererParameters;
+    maxPixelRatio?: number;
+    containerElement?: ElementOrSelector<HTMLElement>;
+    view?: En3ViewOptions;
+    zIndex?: number;
+    composer?: typeof EffectComposer;
+}
+declare class En3 {
+    #private;
+    get CDNVersion(): string;
+    get containerElement(): HTMLElement;
+    get webglRenderer(): WebGLRenderer;
+    get raycaster(): En3Raycaster;
+    get views(): Map<string, En3View>;
+    get view(): En3View;
+    get camera(): import('three').PerspectiveCamera | import('three').OrthographicCamera;
+    get scene(): import('three').Scene;
+    get width(): number;
+    get height(): number;
+    get pixelRatio(): number;
+    get composer(): EffectComposer;
+    setup(options?: En3Options): void;
+    destroy(): void;
+    createView(viewName: string, viewOptions?: En3ViewOptions): En3View;
+    getView(viewName: string): En3View;
+    destroyView(viewName: string): void;
+    render(view: En3View): void;
+}
+export declare const en3: En3;
+export {};

package/lib/en3/index.d.ts

@@ -0,0 +1,7 @@
+export { en3 } from './en3';
+export { En3View, type En3ViewOptions, type En3AttachedObject3D, type En3AttachOptions, type En3ViewBeforeRenderCallback, } from './En3View';
+export { coverTexture } from './utils/coverTexture';
+export { dispose } from './utils/dispose';
+export { getCurrentViewport } from './utils/getCurrentViewport';
+export { traverseMaterials } from './utils/traverseMaterials';
+export { traverseMeshes } from './utils/traverseMeshes';

package/lib/en3/utils/coverTexture.d.ts

@@ -0,0 +1,7 @@
+import { Dot2D } from '../../utils';
+import { Texture } from 'three';
+
+/**
+ * texture.matrixAutoUpdate must be false
+ */
+export declare function coverTexture(texture: Texture, planeSize: Dot2D, aspect?: number): void;

package/lib/en3/utils/dispose.d.ts

@@ -0,0 +1,3 @@
+import { Object3D } from 'three';
+
+export declare function dispose(object3d: Object3D): void;

package/lib/en3/utils/getCurrentViewport.d.ts

@@ -0,0 +1,9 @@
+import { Vector3 } from 'three';
+
+export declare function getCurrentViewport(target: Vector3 | [number, number, number], viewName?: string): {
+    width: number;
+    height: number;
+    factor: number;
+    distance: number;
+    aspect: number;
+};

package/lib/en3/utils/traverseMaterials.d.ts

@@ -0,0 +1,3 @@
+import { Material, Object3D } from 'three';
+
+export declare function traverseMaterials(object: Object3D, callback: (material: Material) => void): void;

package/lib/en3/utils/traverseMeshes.d.ts

@@ -0,0 +1,3 @@
+import { Mesh, Object3D } from 'three';
+
+export declare function traverseMeshes(object: Object3D, callback: (mesh: Mesh) => void): void;

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

@@ -0,0 +1,5 @@
+import { Ref } from 'react';
+import { IntersectorCallback } from '../vanilla';
+import { ElementOrSelector } from '../../utils';
+
+export declare function useIntersection(element: Ref<HTMLElement> | ElementOrSelector, callback: IntersectorCallback): void;

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

@@ -0,0 +1,10 @@
+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,24 @@
+import { Store } from '../store/vanilla';
+
+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,96 @@
+import { Ladder } from '../ladder';
+import { StoreSubscribeCallback } from '../store/vanilla';
+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 = StoreSubscribeCallback<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;
+}