@atlas-viewer/atlas 1.6.6 → 2.0.0-alpha.0

package/dist/types/clean-objects/base.object.d.ts

@@ -0,0 +1,31 @@
+import { SupportedEventNames, SupportedEvents } from '../events';
+import { ContainerDefinition, GenericObject, GenericObjectProps } from './traits/generic-object';
+import { Evented, EventListenerProps, EventedHelpers } from './traits/evented';
+import { Revision } from './traits/revision';
+import { Paint, PaintableObject } from './traits/paintable';
+import { Strand } from '@atlas-viewer/dna';
+export interface BaseObjectProps extends GenericObjectProps, EventListenerProps {
+}
+export declare abstract class BaseObject implements GenericObject, Evented, EventedHelpers, Revision, PaintableObject {
+    readonly id: GenericObject['id'];
+    abstract readonly type: GenericObject['type'];
+    readonly display: GenericObject['display'];
+    readonly points: GenericObject['points'];
+    readonly node: GenericObject['node'];
+    readonly buffers: GenericObject['buffers'];
+    revision: Revision['revision'];
+    events: Evented['events'];
+    protected constructor(options: {
+        type: 'container' | 'node';
+    });
+    getObjectsAt(target: Strand, zone?: PaintableObject<ContainerDefinition<PaintableObject>>): PaintableObject[];
+    getAllPointsAt(target: Strand, scale: number, aggregate?: Strand): Paint[];
+    addEventListener<Name extends SupportedEventNames>(name: Name, cb: (e: any) => void, options?: {
+        capture: boolean;
+        passive: boolean;
+    }): void;
+    removeEventListener<Name extends SupportedEventNames>(name: Name, cb: (e: any) => void): void;
+    dispatchEvent<Name extends keyof SupportedEvents>(name: Name, e: any): boolean;
+    captureEvent<Name extends keyof SupportedEvents>(name: Name, e: any): boolean;
+    applyProps(props: BaseObjectProps): boolean;
+}

package/dist/types/clean-objects/box.object.d.ts

@@ -0,0 +1,17 @@
+import { GenericObjectProps, NodeDefinition } from './traits/generic-object';
+import { HasStyles, HasStylesProps } from './traits/has-styles';
+import { BaseObject } from './base.object';
+export interface BoxProps extends GenericObjectProps, HasStylesProps {
+    readonly type: 'box';
+    interactive?: boolean;
+    html?: boolean;
+}
+export declare class Box extends BaseObject implements HasStyles {
+    node: NodeDefinition;
+    readonly type = "box";
+    style: HasStyles['style'];
+    interactive: boolean;
+    isHTML: boolean;
+    constructor();
+    applyProps(props: BoxProps): boolean;
+}

package/dist/types/clean-objects/composite.object.d.ts

@@ -0,0 +1,4 @@
+import { GenericObject } from './traits/generic-object';
+export interface CompositeObjectProps extends GenericObject {
+    readonly type: 'composite';
+}

package/dist/types/clean-objects/container.object.d.ts

@@ -0,0 +1,11 @@
+import { BaseObject, BaseObjectProps } from './base.object';
+import { HasStyles, HasStylesProps } from './traits/has-styles';
+import { ContainerDefinition } from './traits/generic-object';
+export interface ContainerObjectProps extends HasStylesProps, BaseObjectProps {
+}
+export declare class ContainerObject extends BaseObject implements HasStyles {
+    node: ContainerDefinition<any>;
+    readonly type = "container";
+    readonly style: HasStyles['style'];
+    constructor();
+}

package/dist/types/clean-objects/image.object.d.ts

@@ -0,0 +1,20 @@
+import { GenericObjectProps, NodeDefinition } from './traits/generic-object';
+import { HasStyles } from './traits/has-styles';
+import { BaseObject } from './base.object';
+declare type ImageStyles = {
+    opacity?: number;
+};
+export interface ImageObjectProps extends GenericObjectProps {
+    src: string;
+    priority?: boolean;
+    style?: ImageStyles;
+}
+export declare class ImageObject extends BaseObject implements HasStyles<ImageStyles> {
+    node: NodeDefinition;
+    readonly type = "image";
+    src?: string;
+    style: HasStyles<ImageStyles>['style'];
+    constructor();
+    applyProps(props: ImageObjectProps): boolean;
+}
+export {};

package/dist/types/clean-objects/traits/container.d.ts

@@ -0,0 +1,5 @@
+import { ContainerDefinition, GenericObject } from './generic-object';
+export declare function append(object: GenericObject<ContainerDefinition>, toAppend: GenericObject): void;
+export declare function insertBefore(object: GenericObject<ContainerDefinition>, item: GenericObject, before: GenericObject): void;
+export declare function hideInstance(object: GenericObject): void;
+export declare function remove(object: GenericObject<ContainerDefinition>, item: GenericObject): void;

package/dist/types/clean-objects/traits/evented.d.ts

@@ -0,0 +1,312 @@
+import { AllEvents } from '../../modules/react-reconciler';
+import { GenericObject } from './generic-object';
+import { PaintableObject } from './paintable';
+import { SupportedEvents } from '../../events';
+export declare type SupportedEventNames = 'mousedown' | 'mouseenter' | 'mouseleave' | 'mousemove' | 'mouseout' | 'mouseover' | 'mouseup' | 'touchcancel' | 'touchend' | 'touchmove' | 'touchstart' | 'pointerdown' | 'pointermove' | 'pointerup' | 'pointercancel' | 'pointerenter' | 'pointerleave' | 'pointerover' | 'pointerout' | 'dragstart' | 'dragend' | 'dragenter' | 'dragexit' | 'drag' | 'dragover' | 'scroll' | 'wheel' | 'click';
+export declare type SupportedEventFunctionNames = 'onMouseDown' | 'onMouseEnter' | 'onMouseLeave' | 'onMouseMove' | 'onMouseOut' | 'onMouseOver' | 'onMouseUp' | 'onTouchCancel' | 'onTouchEnd' | 'onTouchMove' | 'onTouchStart' | 'onPointerDown' | 'onPointerMove' | 'onPointerUp' | 'onPointerCancel' | 'onPointerEnter' | 'onPointerLeave' | 'onPointerOver' | 'onPointerOut' | 'onDragStart' | 'onDragEnd' | 'onDragEnter' | 'onDragExit' | 'onDrag' | 'onDragOver' | 'onScroll' | 'onWheel' | 'onClick';
+export declare type SupportedEventTypeMapping = {
+    mousedown: 'onMouseDown';
+    mouseenter: 'onMouseEnter';
+    mouseleave: 'onMouseLeave';
+    mousemove: 'onMouseMove';
+    mouseout: 'onMouseOut';
+    mouseover: 'onMouseOver';
+    mouseup: 'onMouseUp';
+    touchcancel: 'onTouchCancel';
+    touchend: 'onTouchEnd';
+    touchmove: 'onTouchMove';
+    touchstart: 'onTouchStart';
+    pointerdown: 'onPointerDown';
+    pointermove: 'onPointerMove';
+    pointerup: 'onPointerUp';
+    pointercancel: 'onPointerCancel';
+    pointerenter: 'onPointerEnter';
+    pointerleave: 'onPointerLeave';
+    pointerover: 'onPointerOver';
+    pointerout: 'onPointerOut';
+    dragstart: 'onDragStart';
+    dragend: 'onDragEnd';
+    dragenter: 'onDragEnter';
+    dragexit: 'onDragExit';
+    drag: 'onDrag';
+    dragover: 'onDragOver';
+    scroll: 'onScroll';
+    wheel: 'onWheel';
+    click: 'onClick';
+};
+export declare type SupportedEventFunctions = {
+    onMouseDown(e: MouseEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onMouseEnter(e: MouseEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onMouseLeave(e: MouseEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onMouseMove(e: MouseEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onMouseOut(e: MouseEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onMouseOver(e: MouseEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onMouseUp(e: MouseEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onTouchCancel(e: TouchEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onTouchEnd(e: TouchEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onTouchMove(e: TouchEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onTouchStart(e: TouchEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onPointerDown(e: PointerEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onPointerMove(e: PointerEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onPointerUp(e: PointerEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onPointerCancel(e: PointerEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onPointerEnter(e: PointerEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onPointerLeave(e: PointerEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onPointerOver(e: PointerEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onPointerOut(e: PointerEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onDragStart(e: DragEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onDragEnd(e: DragEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onDragEnter(e: DragEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onDragExit(e: DragEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onDrag(e: DragEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onDragOver(e: DragEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onScroll(e: UIEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onWheel(e: WheelEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onClick(e: MouseEvent & {
+        atlas: {
+            x: number;
+            y: number;
+        };
+    }): void;
+};
+export declare type EventMap = {
+    [Name in SupportedEventFunctionNames]: Array<{
+        listener: SupportedEventFunctions[Name];
+        options?: {
+            capture?: boolean;
+        };
+    }>;
+};
+export declare const supportedEventAttributes: Array<SupportedEventFunctionNames>;
+export interface Evented {
+    events: {
+        props: AllEvents;
+        handlers: EventMap;
+        targets: GenericObject[];
+    };
+}
+export interface EventedHelpers {
+    addEventListener<Name extends SupportedEventNames>(name: Name, cb: (e: any) => void, options?: {
+        capture: boolean;
+        passive: boolean;
+    }): void;
+    removeEventListener<Name extends SupportedEventNames>(name: Name, cb: (e: any) => void): void;
+    dispatchEvent<Name extends SupportedEventFunctionNames>(name: Name, e: any): void;
+}
+export declare type EventListenerProps = Partial<SupportedEventFunctions>;
+export declare const supportedEventMap: {
+    mousedown: "onMouseDown";
+    mouseenter: "onMouseEnter";
+    mouseleave: "onMouseLeave";
+    mousemove: "onMouseMove";
+    mouseout: "onMouseOut";
+    mouseover: "onMouseOver";
+    mouseup: "onMouseUp";
+    touchcancel: "onTouchCancel";
+    touchend: "onTouchEnd";
+    touchmove: "onTouchMove";
+    touchstart: "onTouchStart";
+    pointerdown: "onPointerDown";
+    pointermove: "onPointerMove";
+    pointerup: "onPointerUp";
+    pointercancel: "onPointerCancel";
+    pointerenter: "onPointerEnter";
+    pointerleave: "onPointerLeave";
+    pointerover: "onPointerOver";
+    pointerout: "onPointerOut";
+    scroll: "onScroll";
+    wheel: "onWheel";
+    click: "onClick";
+    dragstart: "onDragStart";
+    dragend: "onDragEnd";
+    dragenter: "onDragEnter";
+    dragexit: "onDragExit";
+    drag: "onDrag";
+    dragover: "onDragOver";
+} & {
+    onMouseDown: "onMouseDown";
+    onMouseEnter: "onMouseEnter";
+    onMouseLeave: "onMouseLeave";
+    onMouseMove: "onMouseMove";
+    onMouseOut: "onMouseOut";
+    onMouseOver: "onMouseOver";
+    onMouseUp: "onMouseUp";
+    onTouchCancel: "onTouchCancel";
+    onTouchEnd: "onTouchEnd";
+    onTouchMove: "onTouchMove";
+    onTouchStart: "onTouchStart";
+    onPointerDown: "onPointerDown";
+    onPointerMove: "onPointerMove";
+    onPointerUp: "onPointerUp";
+    onPointerCancel: "onPointerCancel";
+    onPointerEnter: "onPointerEnter";
+    onPointerLeave: "onPointerLeave";
+    onPointerOver: "onPointerOver";
+    onPointerOut: "onPointerOut";
+    onScroll: "onScroll";
+    onWheel: "onWheel";
+    onClick: "onClick";
+    onDragStart: "onDragStart";
+    onDragEnd: "onDragEnd";
+    onDragEnter: "onDragEnter";
+    onDragExit: "onDragExit";
+    onDrag: "onDrag";
+    onDragOver: "onDragOver";
+};
+export declare function createDefaultEventMap(): EventMap;
+export declare function addEventListener<Name extends SupportedEventNames>(object: Evented, name: Name, cb: (e: any) => void, options?: {
+    capture?: boolean;
+    passive?: boolean;
+}): void;
+export declare function removeEventListener<Name extends SupportedEventNames>(object: Evented, name: Name, cb: (e: any) => void): void;
+export declare function isEvented(t: unknown): t is Evented;
+export declare function dispatchEvent<Name extends SupportedEventFunctionNames | SupportedEventNames>(obj: unknown, name: Name, e: any, toCapture?: boolean): boolean;
+export declare function eventsDefaults(): Evented;
+export declare function applyEventProps(instance: Evented, props: EventListenerProps): boolean;
+export declare function propagatePointerEvent<Name extends keyof SupportedEvents>(object: PaintableObject, eventName: Name, e: any, x: number, y: number, opts?: {
+    bubbles?: boolean;
+    cancelable?: boolean;
+}): GenericObject<import("./generic-object").NodeDefinition | import("./generic-object").ContainerDefinition<any>>[];
+export declare function propagateTouchEvent(object: PaintableObject, eventName: string, e: TouchEvent, touchTargets: Array<{
+    x: number;
+    y: number;
+}>): void;
+export declare function propagateEvent(object: GenericObject & Evented, eventName: string, e: any, filteredObjects: PaintableObject[][], { bubbles, cancelable }?: {
+    bubbles?: boolean;
+    cancelable?: boolean;
+}): GenericObject<import("./generic-object").NodeDefinition | import("./generic-object").ContainerDefinition<any>>[];

package/dist/types/clean-objects/traits/generic-object.d.ts

@@ -0,0 +1,61 @@
+import { DisplayData } from '../../types';
+import { Strand } from '@atlas-viewer/dna';
+export interface GenericObject<Node extends NodeDefinition | ContainerDefinition<any> = NodeDefinition | ContainerDefinition<any>> {
+    readonly id: string;
+    readonly type: string;
+    readonly display: DisplayData;
+    points: Strand;
+    readonly node: Node;
+    readonly buffers: {
+        filteredPoints: Strand;
+        readonly intersectionPoints: Strand;
+        readonly aggregateTransform: Strand;
+        readonly invertedTransform: Strand;
+    };
+}
+export declare type NodeDefinition = {
+    readonly type: 'node';
+    cropped: boolean;
+    crop: Strand;
+    hidden: boolean;
+    parent?: ContainerDefinition;
+};
+export declare type ContainerDefinition<Contains extends GenericObject = GenericObject> = {
+    readonly type: 'container';
+    list: Array<Contains | null>;
+    listPoints: Strand;
+    lazy: boolean;
+    zone: boolean;
+    hidden: boolean;
+    cropped: boolean;
+    crop: Strand;
+    ordered: boolean;
+    order: number[];
+    parent?: ContainerDefinition;
+};
+export interface GenericObjectProps {
+    id?: string;
+    target?: {
+        x?: number;
+        y?: number;
+        width: number;
+        height: number;
+    };
+    display?: {
+        width: number;
+        height?: number;
+    };
+    crop?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+export declare function isGeneric(t: unknown): t is GenericObject;
+export declare function genericObjectDefaults(type: 'node'): GenericObject<NodeDefinition>;
+export declare function genericObjectDefaults(type: 'container'): GenericObject<ContainerDefinition>;
+export declare function genericObjectDefaults(type: 'container' | 'node'): GenericObject<NodeDefinition | ContainerDefinition>;
+export declare function applyGenericObjectProps(toObject: GenericObject, props: GenericObjectProps): boolean;
+export declare function objectForEach<Contains extends GenericObject<any> = GenericObject<any>>(object: GenericObject, cb: (obj: Contains, index: number) => void): void;
+export declare function getTopParent(object: GenericObject): GenericObject;

package/dist/types/clean-objects/traits/has-styles.d.ts

@@ -0,0 +1,60 @@
+import { Evented } from './evented';
+import { Revision } from './revision';
+export interface HasStylesProps<T extends BoxStyle = BoxStyle> {
+    className?: string;
+    relativeStyle?: boolean;
+    style?: T;
+}
+export interface HasStyles<S extends _BoxStyle = _BoxStyle> {
+    style: {
+        className: string | null;
+        rules: S | null;
+        hoverRules: S | null;
+        activeRules: S | null;
+        parsed: {
+            border: {
+                id: string | null;
+                match: string[];
+            };
+            outline: {
+                id: string | null;
+                match: string[];
+            };
+        };
+        relative: boolean;
+        activeEvents: boolean;
+        hoverEvents: boolean;
+        isHovering: boolean;
+        isActive?: boolean;
+        handlers: {
+            addHover?: () => void;
+            removeHover?: () => void;
+            addActive?: () => void;
+            removeActive?: () => void;
+        };
+    };
+}
+export declare type BoxStyle<T extends _BoxStyle = _BoxStyle> = T & {
+    ':hover'?: T;
+    ':active'?: T;
+};
+declare type _BoxStyle = Partial<{
+    backgroundColor: string;
+    opacity: number;
+    boxShadow: string;
+    borderColor: string;
+    borderWidth: string;
+    borderStyle: string;
+    outlineColor: string;
+    outlineWidth: string;
+    outlineOffset: string;
+    outlineStyle: string;
+    border: string;
+    outline: string;
+    background: string;
+}>;
+export declare function hasStyles(obj: unknown): obj is HasStyles;
+export declare function hasStylesDefaults(): HasStyles;
+export declare function stylesDidUpdate(a: _BoxStyle | null, b: _BoxStyle | null): boolean;
+export declare function applyHasStylesProps(object: HasStyles & Evented & Revision, props: HasStylesProps): boolean;
+export {};

package/dist/types/clean-objects/traits/hosts.d.ts

@@ -0,0 +1,59 @@
+import { GenericObject } from './generic-object';
+export interface Hosts {
+    hosts: {
+        html?: HTMLContainerHost;
+        image?: DOMImageHost;
+        images?: DOMImageListHost;
+        canvas?: CanvasHost;
+        webgl?: WebGLImageHost;
+    };
+    readonly hostCreators?: {
+        readonly html?: (obj: GenericObject) => HTMLContainerHost;
+        readonly image?: (obj: GenericObject) => DOMImageHost;
+        readonly images?: (obj: GenericObject) => DOMImageListHost;
+        readonly canvas?: (obj: GenericObject) => CanvasHost;
+        readonly webgl?: (obj: GenericObject) => WebGLImageHost;
+    };
+}
+export interface HTMLContainerHost {
+    element: HTMLElement;
+    revision: number;
+    relative: boolean;
+}
+export interface DOMImageHost {
+    element: HTMLImageElement;
+}
+export interface DOMImageListHost {
+    elements: Array<{
+        image: HTMLImageElement;
+    }>;
+}
+export interface CanvasHost {
+    canvas: HTMLCanvasElement;
+    indices: number[];
+    loaded: number[];
+    loading: boolean;
+}
+export interface WebGLImageHost {
+    height: number;
+    width: number;
+    textures: WebGLTexture[];
+    loading: number[];
+    loaded: number[];
+    lastLevelRendered: number;
+    onLoad: (index: number, image: TexImageSource) => void;
+    lastImage?: string;
+    error?: Error;
+}
+export declare type CreateHosts<Obj extends GenericObject> = {
+    [Host in keyof Hosts['hosts']]?: (object: Obj) => Required<Hosts['hosts'][Host]>;
+};
+export declare type SupportedHost<Host extends keyof Hosts['hosts']> = {
+    hostCreators: {
+        [key in Host]-?: Hosts['hosts'];
+    };
+    hosts: {
+        [key in Host]-?: Hosts['hosts'];
+    };
+};
+export declare function supportsHost<Host extends keyof Hosts['hosts']>(object: unknown, host: Host): object is SupportedHost<Host>;

package/dist/types/clean-objects/traits/layout.d.ts

@@ -0,0 +1,61 @@
+export interface Layout {
+    layout: {
+        triggerQueue: LayoutEvent[];
+        flushed: string[];
+        subscriptions: Array<(type: string, changes?: unknown) => void>;
+    };
+}
+export interface LayoutEvent {
+    type: string;
+    data?: any;
+}
+export interface RepaintLayoutEvent extends LayoutEvent {
+    type: 'repaint';
+    data?: never;
+}
+export interface EventActivationLayoutEvent extends LayoutEvent {
+    type: 'event-activation';
+    data?: never;
+}
+export interface GoToRegionLayoutEvent extends LayoutEvent {
+    type: 'goto-region';
+    data: {
+        x: number;
+        y: number;
+        height: number;
+        width: number;
+        padding?: number;
+        nudge?: boolean;
+        immediate?: boolean;
+    };
+}
+export interface GoHomeLayoutEvent extends LayoutEvent {
+    type: 'go-home';
+    data: {
+        immediate?: boolean;
+    };
+}
+export interface ConstrainBoundsLayoutEvent extends LayoutEvent {
+    type: 'constrain-bounds';
+    data: {
+        immediate?: boolean;
+    };
+}
+export interface ZoomToLayoutEvent extends LayoutEvent {
+    type: 'zoom-to';
+    data: {
+        factor: number;
+        point?: {
+            x: number;
+            y: number;
+        };
+        stream?: boolean;
+    };
+}
+declare type AllLayoutEvents = RepaintLayoutEvent | EventActivationLayoutEvent | GoToRegionLayoutEvent | GoHomeLayoutEvent | ConstrainBoundsLayoutEvent | ZoomToLayoutEvent;
+export declare function revisionDefaults(): Layout;
+export declare function hasLayouts(obj: unknown): obj is Layout;
+export declare function addLayoutSubscription<T extends LayoutEvent = AllLayoutEvents>(input: unknown, subscription: (type: T['type'], data: T['data']) => void): () => void;
+export declare function triggerLayout(object: unknown, event: AllLayoutEvents): void;
+export declare function flushLayoutSubscriptions(input: Layout): void;
+export {};

package/dist/types/clean-objects/traits/paintable.d.ts

@@ -0,0 +1,16 @@
+import { Strand } from '@atlas-viewer/dna';
+import { ContainerDefinition, GenericObject, NodeDefinition } from './generic-object';
+import { Evented } from './evented';
+export interface PaintableObject<Node extends NodeDefinition | ContainerDefinition<PaintableObject> = NodeDefinition | ContainerDefinition<any>> extends GenericObject<Node>, Evented {
+}
+export declare function isPaintable(obj: unknown): obj is PaintableObject;
+export declare function getObjectsAt(object: PaintableObject, target: Strand, options?: {
+    loadLazy?: boolean;
+    zone?: PaintableObject<ContainerDefinition<any>>;
+}): PaintableObject[];
+export declare type Paint = [PaintableObject, Strand, Strand | undefined];
+export declare function getAllPointsAt(object: PaintableObject<any>, target: Strand, scaleFactor: number, options?: {
+    loadLazy?: boolean;
+    zone?: PaintableObject<ContainerDefinition<PaintableObject>>;
+    aggregate?: Strand;
+}): Paint[];

package/dist/types/clean-objects/traits/revision.d.ts

@@ -0,0 +1,7 @@
+export interface Revision {
+    revision: {
+        id: number;
+    };
+}
+export declare function revisionDefaults(): Revision;
+export declare function hasRevision(obj: unknown): obj is Revision;