scandit-datacapture-frameworks-core 6.21.0-beta.2

package/dist/dts/BaseController.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from "./EventEmitter";
+export declare class BaseController<PROXY> {
+    protected eventEmitter: EventEmitter;
+    private proxyName;
+    protected get _proxy(): PROXY;
+    constructor(proxyName: string);
+    emit(event: any, payload: any): void;
+}
+export declare class BaseNativeProxy {
+    protected eventEmitter: EventEmitter;
+    constructor();
+}

package/dist/dts/EventEmitter.d.ts

@@ -0,0 +1,3 @@
+import EventEmitter from "eventemitter3";
+export declare function createEventEmitter(): void;
+export { EventEmitter };

package/dist/dts/Expiration.d.ts

@@ -0,0 +1,5 @@
+export declare enum Expiration {
+    Available = "available",
+    Perpetual = "perpetual",
+    NotAvailable = "notAvailable"
+}

package/dist/dts/FactoryMaker.d.ts

@@ -0,0 +1,12 @@
+interface FactoryMakerItem {
+    instance?: any;
+    builder?: () => any;
+}
+export declare class FactoryMaker {
+    static instances: Map<string, FactoryMakerItem>;
+    static bindInstance(clsName: string, instance: any): void;
+    static bindLazyInstance<T>(clsName: string, builder: () => T): void;
+    static bindInstanceIfNotExists(clsName: string, instance: any): void;
+    static getInstance<T>(clsName: string): T | undefined;
+}
+export {};

package/dist/dts/LicenseInfo.d.ts

@@ -0,0 +1,6 @@
+import { DefaultSerializeable } from "./serializable";
+import { Expiration } from "./Expiration";
+export declare class LicenseInfo extends DefaultSerializeable {
+    private _expiration;
+    get expiration(): Expiration;
+}

package/dist/dts/camera/Camera.d.ts

@@ -0,0 +1,44 @@
+import { DataCaptureContext } from "../context";
+import { FrameSource, FrameSourceListener, FrameSourceState } from "../frame";
+import { DefaultSerializeable } from "../serializable";
+import { CameraController } from "./CameraController";
+import { TorchState } from "./TorchState";
+import { CameraPosition } from "./CameraPosition";
+import { CameraSettings } from "./CameraSettings";
+export declare class Camera extends DefaultSerializeable implements FrameSource {
+    private type;
+    private settings;
+    private position;
+    private _desiredTorchState;
+    private _desiredState;
+    private listeners;
+    private _context;
+    private static get coreDefaults();
+    private set context(value);
+    private get context();
+    private controller;
+    static get default(): Camera | null;
+    static atPosition(cameraPosition: CameraPosition): Camera | null;
+    get desiredState(): FrameSourceState;
+    set desiredTorchState(desiredTorchState: TorchState);
+    get desiredTorchState(): TorchState;
+    private constructor();
+    switchToDesiredState(state: FrameSourceState): Promise<void>;
+    getCurrentState(): Promise<FrameSourceState>;
+    getIsTorchAvailable(): Promise<boolean>;
+    addListener(listener: FrameSourceListener | null): void;
+    removeListener(listener: FrameSourceListener | null): void;
+    applySettings(settings: CameraSettings): Promise<void>;
+    private didChange;
+}
+export interface PrivateCamera {
+    context: DataCaptureContext | null;
+    position: CameraPosition;
+    _desiredState: FrameSourceState;
+    desiredTorchState: TorchState;
+    settings: CameraSettings;
+    listeners: FrameSourceListener[];
+    controller: CameraController;
+    initialize: () => void;
+    didChange: () => Promise<void>;
+}

package/dist/dts/camera/CameraController.d.ts

@@ -0,0 +1,30 @@
+import { Camera } from "./Camera";
+import { FrameData, FrameSourceState } from "../frame";
+import { CameraPosition } from "./CameraPosition";
+export interface CameraProxy {
+    getLastFrame(): Promise<string>;
+    getLastFrameOrNull(): Promise<string | null>;
+    getCurrentCameraState(position: CameraPosition): Promise<FrameSourceState>;
+    isTorchAvailable(position: CameraPosition): Promise<boolean>;
+    registerListenerForCameraEvents(): void;
+    unregisterListenerForCameraEvents(): void;
+    subscribeDidChangeState(): void;
+    unsubscribeDidChangeState(): void;
+}
+export declare enum FrameSourceListenerEvents {
+    didChangeState = "FrameSourceListener.onStateChanged"
+}
+export declare class CameraController {
+    private camera;
+    private eventEmitter;
+    private static get _proxy();
+    static forCamera(camera: Camera): CameraController;
+    private constructor();
+    private get privateCamera();
+    static getLastFrame(): Promise<FrameData>;
+    static getLastFrameOrNull(): Promise<FrameData | null>;
+    getCurrentState(): Promise<FrameSourceState>;
+    getIsTorchAvailable(): Promise<boolean>;
+    subscribeListener(): void;
+    unsubscribeListener(): void;
+}

package/dist/dts/camera/CameraPosition.d.ts

@@ -0,0 +1,5 @@
+export declare enum CameraPosition {
+    WorldFacing = "worldFacing",
+    UserFacing = "userFacing",
+    Unspecified = "unspecified"
+}

package/dist/dts/camera/CameraSettings.d.ts

@@ -0,0 +1,39 @@
+import { DefaultSerializeable } from "../serializable";
+import { FocusGestureStrategy } from "./FocusGestureStrategy";
+import { FocusRange } from "./FocusRange";
+import { VideoResolution } from "./VideoResolution";
+export interface CameraSettingsJSON {
+    preferredResolution: string;
+    zoomFactor: number;
+    focusRange: string;
+    zoomGestureZoomFactor: number;
+    focusGestureStrategy: string;
+    shouldPreferSmoothAutoFocus: boolean;
+    properties: {
+        [key: string]: any;
+    };
+}
+export interface PrivateCameraSettings {
+    fromJSON(json: CameraSettingsJSON): CameraSettings;
+}
+export declare class CameraSettings extends DefaultSerializeable {
+    private static get coreDefaults();
+    private focusHiddenProperties;
+    preferredResolution: VideoResolution;
+    zoomFactor: number;
+    zoomGestureZoomFactor: number;
+    private focus;
+    get focusRange(): FocusRange;
+    set focusRange(newRange: FocusRange);
+    get focusGestureStrategy(): FocusGestureStrategy;
+    set focusGestureStrategy(newStrategy: FocusGestureStrategy);
+    get shouldPreferSmoothAutoFocus(): boolean;
+    set shouldPreferSmoothAutoFocus(newShouldPreferSmoothAutoFocus: boolean);
+    get maxFrameRate(): number;
+    set maxFrameRate(newValue: number);
+    private static fromJSON;
+    constructor();
+    constructor(settings: CameraSettings);
+    setProperty(name: string, value: any): void;
+    getProperty(name: string): any;
+}

package/dist/dts/camera/FocusGesture.d.ts

@@ -0,0 +1,2 @@
+export interface FocusGesture {
+}

package/dist/dts/camera/FocusGestureStrategy.d.ts

@@ -0,0 +1,6 @@
+export declare enum FocusGestureStrategy {
+    None = "none",
+    Manual = "manual",
+    ManualUntilCapture = "manualUntilCapture",
+    AutoOnLocation = "autoOnLocation"
+}

package/dist/dts/camera/FocusRange.d.ts

@@ -0,0 +1,5 @@
+export declare enum FocusRange {
+    Full = "full",
+    Near = "near",
+    Far = "far"
+}

package/dist/dts/camera/LogoStyle.d.ts

@@ -0,0 +1,4 @@
+export declare enum LogoStyle {
+    Minimal = "minimal",
+    Extended = "extended"
+}

package/dist/dts/camera/PrivateFocusGestureDeserializer.d.ts

@@ -0,0 +1,7 @@
+import { FocusGesture } from "./FocusGesture";
+export interface FocusGestureJSON {
+    type: string;
+}
+export declare class PrivateFocusGestureDeserializer {
+    static fromJSON(json: FocusGestureJSON | null): FocusGesture | null;
+}

package/dist/dts/camera/SwipeToZoom.d.ts

@@ -0,0 +1,6 @@
+import { DefaultSerializeable } from "../serializable";
+import { ZoomGesture } from "./ZoomGesture";
+export declare class SwipeToZoom extends DefaultSerializeable implements ZoomGesture {
+    private type;
+    constructor();
+}

package/dist/dts/camera/TapToFocus.d.ts

@@ -0,0 +1,6 @@
+import { DefaultSerializeable } from "../serializable";
+import { FocusGesture } from "./FocusGesture";
+export declare class TapToFocus extends DefaultSerializeable implements FocusGesture {
+    private type;
+    constructor();
+}

package/dist/dts/camera/TorchState.d.ts

@@ -0,0 +1,5 @@
+export declare enum TorchState {
+    On = "on",
+    Off = "off",
+    Auto = "auto"
+}

package/dist/dts/camera/TorchSwitchControl.d.ts

@@ -0,0 +1,15 @@
+import { DefaultSerializeable } from "../serializable";
+import { Control } from "../view";
+export declare class TorchSwitchControl extends DefaultSerializeable implements Control {
+    private type;
+    private icon;
+    private view;
+    get torchOffImage(): string | null;
+    set torchOffImage(torchOffImage: string | null);
+    get torchOffPressedImage(): string | null;
+    set torchOffPressedImage(torchOffPressedImage: string | null);
+    get torchOnImage(): string | null;
+    set torchOnImage(torchOnImage: string | null);
+    get torchOnPressedImage(): string | null;
+    set torchOnPressedImage(torchOnPressedImage: string | null);
+}

package/dist/dts/camera/VideoResolution.d.ts

@@ -0,0 +1,6 @@
+export declare enum VideoResolution {
+    Auto = "auto",
+    HD = "hd",
+    FullHD = "fullHd",
+    UHD4K = "uhd4k"
+}

package/dist/dts/camera/ZoomGesture.d.ts

@@ -0,0 +1,8 @@
+export interface ZoomGesture {
+}
+export interface ZoomGestureJSON {
+    type: string;
+}
+export declare class PrivateZoomGestureDeserializer {
+    static fromJSON(json: ZoomGestureJSON | null): ZoomGesture | null;
+}

package/dist/dts/camera/ZoomSwitchControl.d.ts

@@ -0,0 +1,15 @@
+import { DefaultSerializeable } from "../serializable";
+import { Control } from "../view";
+export declare class ZoomSwitchControl extends DefaultSerializeable implements Control {
+    private type;
+    private icon;
+    private view;
+    get zoomedOutImage(): string | null;
+    set zoomedOutImage(zoomedOutImage: string | null);
+    get zoomedInImage(): string | null;
+    set zoomedInImage(zoomedInImage: string | null);
+    get zoomedInPressedImage(): string | null;
+    set zoomedInPressedImage(zoomedInPressedImage: string | null);
+    get zoomedOutPressedImage(): string | null;
+    set zoomedOutPressedImage(zoomedOutPressedImage: string | null);
+}

package/dist/dts/camera/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./FocusGesture";
+export * from "./TapToFocus";
+export * from "./PrivateFocusGestureDeserializer";
+export * from "./ZoomGesture";
+export * from "./CameraController";
+export * from "./Camera";
+export * from "./ZoomSwitchControl";
+export * from "./TorchSwitchControl";
+export * from "./CameraPosition";
+export * from "./VideoResolution";
+export * from "./TorchState";
+export * from "./FocusRange";
+export * from "./FocusGestureStrategy";
+export * from "./LogoStyle";
+export * from "./SwipeToZoom";
+export * from "./CameraSettings";

package/dist/dts/common/Anchor.d.ts

@@ -0,0 +1,11 @@
+export declare enum Anchor {
+    TopLeft = "topLeft",
+    TopCenter = "topCenter",
+    TopRight = "topRight",
+    CenterLeft = "centerLeft",
+    Center = "center",
+    CenterRight = "centerRight",
+    BottomLeft = "bottomLeft",
+    BottomCenter = "bottomCenter",
+    BottomRight = "bottomRight"
+}

package/dist/dts/common/Brush.d.ts

@@ -0,0 +1,28 @@
+import { DefaultSerializeable } from "../serializable";
+import { Color } from "./Color";
+export interface PrivateBrush {
+    readonly copy: Brush;
+    defaults: any;
+    toJSON(): BrushJSON;
+}
+export interface BrushJSON {
+    fill: {
+        color: Color;
+    };
+    stroke: {
+        color: Color;
+        width: number;
+    };
+}
+export declare class Brush extends DefaultSerializeable {
+    private static defaults;
+    private fill;
+    private stroke;
+    static get transparent(): Brush;
+    get fillColor(): Color;
+    get strokeColor(): Color;
+    get strokeWidth(): number;
+    private get copy();
+    constructor();
+    constructor(fillColor: Color, strokeColor: Color, strokeWidth: number);
+}

package/dist/dts/common/Color.d.ts

@@ -0,0 +1,26 @@
+import { StringSerializeable } from "../serializable";
+export type ColorJSON = string;
+export interface PrivateColor {
+    fromJSON(json: ColorJSON): Color;
+}
+export declare class Color implements StringSerializeable {
+    private hexadecimalString;
+    get redComponent(): string;
+    get greenComponent(): string;
+    get blueComponent(): string;
+    get alphaComponent(): string;
+    get red(): number;
+    get green(): number;
+    get blue(): number;
+    get alpha(): number;
+    static fromHex(hex: string): Color;
+    static fromRGBA(red: number, green: number, blue: number, alpha?: number): Color;
+    private static hexToNumber;
+    private static fromJSON;
+    private static numberToHex;
+    private static normalizeHex;
+    private static normalizeAlpha;
+    private constructor();
+    withAlpha(alpha: number): Color;
+    toJSON(): string;
+}

package/dist/dts/common/Direction.d.ts

@@ -0,0 +1,9 @@
+export declare enum Direction {
+    None = "none",
+    Horizontal = "horizontal",
+    LeftToRight = "leftToRight",
+    RightToLeft = "rightToLeft",
+    Vertical = "vertical",
+    TopToBottom = "topToBottom",
+    BottomToTop = "bottomToTop"
+}

package/dist/dts/common/MarginsWithUnit.d.ts

@@ -0,0 +1,25 @@
+import { DefaultSerializeable } from "../serializable";
+import { NumberWithUnit, NumberWithUnitJSON } from "./NumberWithUnit";
+export interface MarginsWithUnitJSON {
+    left: NumberWithUnitJSON;
+    right: NumberWithUnitJSON;
+    top: NumberWithUnitJSON;
+    bottom: NumberWithUnitJSON;
+}
+export interface PrivateMarginsWithUnit {
+    readonly zero: MarginsWithUnit;
+    fromJSON(json: MarginsWithUnitJSON): MarginsWithUnit;
+}
+export declare class MarginsWithUnit extends DefaultSerializeable {
+    private _left;
+    private _right;
+    private _top;
+    private _bottom;
+    get left(): NumberWithUnit;
+    get right(): NumberWithUnit;
+    get top(): NumberWithUnit;
+    get bottom(): NumberWithUnit;
+    private static fromJSON;
+    private static get zero();
+    constructor(left: NumberWithUnit, right: NumberWithUnit, top: NumberWithUnit, bottom: NumberWithUnit);
+}

package/dist/dts/common/MeasureUnit.d.ts

@@ -0,0 +1,5 @@
+export declare enum MeasureUnit {
+    DIP = "dip",
+    Pixel = "pixel",
+    Fraction = "fraction"
+}

package/dist/dts/common/NumberWithUnit.d.ts

@@ -0,0 +1,17 @@
+import { DefaultSerializeable } from "../serializable";
+import { MeasureUnit } from "./MeasureUnit";
+export interface NumberWithUnitJSON {
+    value: number;
+    unit: string;
+}
+export interface PrivateNumberWithUnit {
+    fromJSON(json: NumberWithUnitJSON): NumberWithUnit;
+}
+export declare class NumberWithUnit extends DefaultSerializeable {
+    private _value;
+    private _unit;
+    get value(): number;
+    get unit(): MeasureUnit;
+    private static fromJSON;
+    constructor(value: number, unit: MeasureUnit);
+}

package/dist/dts/common/Orientation.d.ts

@@ -0,0 +1,7 @@
+export declare enum Orientation {
+    Unknown = "unknown",
+    Portrait = "portrait",
+    PortraitUpsideDown = "portraitUpsideDown",
+    LandscapeRight = "landscapeRight",
+    LandscapeLeft = "landscapeLeft"
+}

package/dist/dts/common/Payload.d.ts

@@ -0,0 +1,11 @@
+import { SizeJSON } from "./Size";
+export interface DidChangeSizeEventPayload {
+    size: SizeJSON;
+    orientation: string;
+}
+export interface DidChangeStatusEventPayload {
+    status: string;
+}
+export interface DidChangeStateEventPayload {
+    state: string;
+}

package/dist/dts/common/Point.d.ts

@@ -0,0 +1,16 @@
+import { DefaultSerializeable } from "../serializable";
+export interface PointJSON {
+    x: number;
+    y: number;
+}
+export interface PrivatePoint {
+    fromJSON(json: PointJSON): Point;
+}
+export declare class Point extends DefaultSerializeable {
+    private _x;
+    private _y;
+    get x(): number;
+    get y(): number;
+    private static fromJSON;
+    constructor(x: number, y: number);
+}

package/dist/dts/common/PointWithUnit.d.ts

@@ -0,0 +1,19 @@
+import { DefaultSerializeable } from "../serializable";
+import { NumberWithUnit, NumberWithUnitJSON } from "./NumberWithUnit";
+export interface PointWithUnitJSON {
+    x: NumberWithUnitJSON;
+    y: NumberWithUnitJSON;
+}
+export interface PrivatePointWithUnit {
+    readonly zero: PointWithUnit;
+    fromJSON(json: PointWithUnitJSON): PointWithUnit;
+}
+export declare class PointWithUnit extends DefaultSerializeable {
+    private _x;
+    private _y;
+    get x(): NumberWithUnit;
+    get y(): NumberWithUnit;
+    private static fromJSON;
+    private static get zero();
+    constructor(x: NumberWithUnit, y: NumberWithUnit);
+}

package/dist/dts/common/Quadrilateral.d.ts

@@ -0,0 +1,23 @@
+import { DefaultSerializeable } from "../serializable";
+import { Point, PointJSON } from "./Point";
+export interface QuadrilateralJSON {
+    topLeft: PointJSON;
+    topRight: PointJSON;
+    bottomRight: PointJSON;
+    bottomLeft: PointJSON;
+}
+export interface PrivateQuadrilateral {
+    fromJSON(json: QuadrilateralJSON): Quadrilateral;
+}
+export declare class Quadrilateral extends DefaultSerializeable {
+    private _topLeft;
+    private _topRight;
+    private _bottomRight;
+    private _bottomLeft;
+    get topLeft(): Point;
+    get topRight(): Point;
+    get bottomRight(): Point;
+    get bottomLeft(): Point;
+    private static fromJSON;
+    constructor(topLeft: Point, topRight: Point, bottomRight: Point, bottomLeft: Point);
+}

package/dist/dts/common/Rect.d.ts

@@ -0,0 +1,10 @@
+import { DefaultSerializeable } from "../serializable";
+import { Point } from "./Point";
+import { Size } from "./Size";
+export declare class Rect extends DefaultSerializeable {
+    private _origin;
+    private _size;
+    get origin(): Point;
+    get size(): Size;
+    constructor(origin: Point, size: Size);
+}

package/dist/dts/common/RectWithUnit.d.ts

@@ -0,0 +1,10 @@
+import { DefaultSerializeable } from "../serializable";
+import { PointWithUnit } from "./PointWithUnit";
+import { SizeWithUnit } from "./SizeWithUnit";
+export declare class RectWithUnit extends DefaultSerializeable {
+    private _origin;
+    private _size;
+    get origin(): PointWithUnit;
+    get size(): SizeWithUnit;
+    constructor(origin: PointWithUnit, size: SizeWithUnit);
+}

package/dist/dts/common/Size.d.ts

@@ -0,0 +1,16 @@
+import { DefaultSerializeable } from "../serializable";
+export interface SizeJSON {
+    width: number;
+    height: number;
+}
+export interface PrivateSize {
+    fromJSON(json: SizeJSON): Size;
+}
+export declare class Size extends DefaultSerializeable {
+    private _width;
+    private _height;
+    get width(): number;
+    get height(): number;
+    private static fromJSON;
+    constructor(width: number, height: number);
+}

package/dist/dts/common/SizeWithAspect.d.ts

@@ -0,0 +1,9 @@
+import { DefaultSerializeable } from "../serializable";
+import { NumberWithUnit } from "./NumberWithUnit";
+export declare class SizeWithAspect extends DefaultSerializeable {
+    private _size;
+    private _aspect;
+    get size(): NumberWithUnit;
+    get aspect(): number;
+    constructor(size: NumberWithUnit, aspect: number);
+}

package/dist/dts/common/SizeWithUnit.d.ts

@@ -0,0 +1,9 @@
+import { DefaultSerializeable } from "../serializable";
+import { NumberWithUnit } from "./NumberWithUnit";
+export declare class SizeWithUnit extends DefaultSerializeable {
+    private _width;
+    private _height;
+    get width(): NumberWithUnit;
+    get height(): NumberWithUnit;
+    constructor(width: NumberWithUnit, height: NumberWithUnit);
+}

package/dist/dts/common/SizeWithUnitAndAspect.d.ts

@@ -0,0 +1,31 @@
+import { Serializeable } from "../serializable";
+import { SizeWithUnit } from "./SizeWithUnit";
+import { SizeWithAspect } from "./SizeWithAspect";
+import { SizingMode } from "./SizingMode";
+import { NumberWithUnitJSON } from "./NumberWithUnit";
+export interface SizeWithUnitAndAspectJSON {
+    width?: NumberWithUnitJSON;
+    height?: NumberWithUnitJSON;
+    shorterDimension?: NumberWithUnitJSON;
+    aspect?: number;
+}
+export interface PrivateSizeWithUnitAndAspect {
+    fromJSON(json: SizeWithUnitAndAspectJSON): SizeWithUnitAndAspect;
+}
+export declare class SizeWithUnitAndAspect implements Serializeable {
+    private _widthAndHeight;
+    private _widthAndAspectRatio;
+    private _heightAndAspectRatio;
+    private _shorterDimensionAndAspectRatio;
+    get widthAndHeight(): SizeWithUnit | null;
+    get widthAndAspectRatio(): SizeWithAspect | null;
+    get heightAndAspectRatio(): SizeWithAspect | null;
+    get shorterDimensionAndAspectRatio(): SizeWithAspect | null;
+    get sizingMode(): SizingMode;
+    private static sizeWithWidthAndHeight;
+    private static sizeWithWidthAndAspectRatio;
+    private static sizeWithHeightAndAspectRatio;
+    private static sizeWithShorterDimensionAndAspectRatio;
+    private static fromJSON;
+    toJSON(): object;
+}

package/dist/dts/common/SizingMode.d.ts

@@ -0,0 +1,6 @@
+export declare enum SizingMode {
+    WidthAndHeight = "widthAndHeight",
+    WidthAndAspectRatio = "widthAndAspectRatio",
+    HeightAndAspectRatio = "heightAndAspectRatio",
+    ShorterDimensionAndAspectRatio = "shorterDimensionAndAspectRatio"
+}

package/dist/dts/common/index.d.ts

@@ -0,0 +1,42 @@
+export { Point } from "./Point";
+export { Quadrilateral } from "./Quadrilateral";
+export { NumberWithUnit } from "./NumberWithUnit";
+export { PointWithUnit } from "./PointWithUnit";
+export { Rect } from "./Rect";
+export { RectWithUnit } from "./RectWithUnit";
+export { Size } from "./Size";
+export { SizeWithAspect } from "./SizeWithAspect";
+export { SizeWithUnit } from "./SizeWithUnit";
+export { SizeWithUnitAndAspect } from "./SizeWithUnitAndAspect";
+export { MarginsWithUnit } from "./MarginsWithUnit";
+export { Color } from "./Color";
+export { Brush } from "./Brush";
+export { Anchor } from "./Anchor";
+export { MeasureUnit } from "./MeasureUnit";
+export { SizingMode } from "./SizingMode";
+export { Orientation } from "./Orientation";
+export { Direction } from "./Direction";
+export * from "./Payload";
+export * from "./Point";
+export * from "./Quadrilateral";
+export * from "./NumberWithUnit";
+export * from "./PointWithUnit";
+export * from "./Rect";
+export * from "./RectWithUnit";
+export * from "./Size";
+export * from "./SizeWithAspect";
+export * from "./SizeWithUnit";
+export * from "./SizeWithUnitAndAspect";
+export * from "./MarginsWithUnit";
+export * from "./Color";
+export * from "./Brush";
+export * from "./Anchor";
+export * from "./MeasureUnit";
+export * from "./SizingMode";
+export * from "./Orientation";
+export * from "./Direction";
+export * from "./Anchor";
+export * from "./MeasureUnit";
+export * from "./SizingMode";
+export * from "./Orientation";
+export * from "./Direction";