@yoobic/yobi 8.3.1-2 → 8.3.1-20

package/dist/types/components/form/image-cropper-dialog/pintura/pintura.d.ts

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-type ProgressCallback = (event: ProgressEvent) => void;
+export type ProgressCallback = (event: ProgressEvent) => void;
 
-type Percentage = string;
+export type Percentage = string;
 
-interface PinturaMetadata {
+export interface PinturaMetadata {
     [key: string]: any;
 }
 
@@ -22,7 +22,7 @@ interface PinturaMetadata {
  * @link Utility to generate a color matrix: https://fecolormatrix.com
  * @link More information on color matrices: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/feColorMatrix
  */
-type ColorMatrix = [
+export type  ColorMatrix = [
     number, number, number, number, number,
     number, number, number, number, number, 
     number, number, number, number, number, 
@@ -41,19 +41,19 @@ type ColorMatrix = [
  * ```
  * @link More information on convolution matrices: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/feConvolveMatrix
  */
-type ConvolutionMatrix = [
+export type  ConvolutionMatrix = [
     number, number, number, 
     number, number, number, 
     number, number, number
 ];
 
-type Color = number[];
+export type Color = number[];
 
-type TextAlign = 'left' | 'center' | 'right';
+export type TextAlign = 'left' | 'center' | 'right';
 
-type TextLayout = 'auto-width' | 'auto-height' | 'fixed-size';
+export type TextLayout = 'auto-width' | 'auto-height' | 'fixed-size';
 
-type SizeCategory =
+export type SizeCategory =
     | 'extraSmall'
     | 'small'
     | 'mediumSmall'
@@ -62,7 +62,7 @@ type SizeCategory =
     | 'large'
     | 'extraLarge';
 
-type LineEndStyle =
+export type LineEndStyle =
     | 'bar'
     | 'arrow'
     | 'arrowSolid'
@@ -71,7 +71,7 @@ type LineEndStyle =
     | 'square'
     | 'squareSolid';
 
-interface ColorPalette {
+export interface ColorPalette {
     transparent?: Color;
     white?: Color;
     silver?: Color;
@@ -91,43 +91,43 @@ interface ColorPalette {
     purple?: Color;
 }
 
-type SizeCategories = Record<SizeCategory, Percentage | number>;
+export type SizeCategories = Record<SizeCategory, Percentage | number>;
 
-interface LocaleCollection {
+export interface LocaleCollection {
     [shapeProperty: string]: string;
 }
 
-type LocaleString = string | ((locale: LocaleCollection) => string);
+export type LocaleString = string | ((locale: LocaleCollection) => string);
 
-interface Vector {
+export interface Vector {
     x: number;
     y: number;
 }
 
-interface Size {
+export interface Size {
     width: number;
     height: number;
 }
 
-interface Rect {
+export interface Rect {
     x: number;
     y: number;
     width: number;
     height: number;
 }
 
-interface ShapeToolOptions {
+export interface ShapeToolOptions {
     position?: string;
 }
 
-interface ShapeRectangle {
+export interface ShapeRectangle {
     x?: number | Percentage;
     y?: number | Percentage;
     width?: number | Percentage;
     height?: number | Percentage;
 }
 
-interface Shape {
+export interface Shape {
     x?: number | Percentage;
     y?: number | Percentage;
     width?: number | Percentage;
@@ -201,10 +201,10 @@ interface Shape {
     readonly _isFormatted?: boolean;
 }
 
-type SvelteComponent = any;
-type SvelteComponentProps = any;
+export type SvelteComponent = any;
+export type SvelteComponentProps = any;
 
-type ShapeControl = [
+export type ShapeControl = [
     // Component to use
     SvelteComponent,
 
@@ -218,14 +218,14 @@ type ShapeControl = [
     }
 ];
 
-type ShapeColorOption = [Color, string] | [Color, string, any];
-type ShapeSizeOption = [number | Percentage, string] | [number | Percentage, string, any];
+export type ShapeColorOption = [Color, string] | [Color, string, any];
+export type ShapeSizeOption = [number | Percentage, string] | [number | Percentage, string, any];
 
-type ShapeLineEndOption = [LineEndStyle, string] | [LineEndStyle, string, any];
-type ShapeFontFamilyOption = [string, string] | [string, string, any];
-type ShapeFontStyleOption = [string, string] | [string, string, any];
+export type ShapeLineEndOption = [LineEndStyle, string] | [LineEndStyle, string, any];
+export type ShapeFontFamilyOption = [string, string] | [string, string, any];
+export type ShapeFontStyleOption = [string, string] | [string, string, any];
 
-interface ShapeControlOptions {
+export interface ShapeControlOptions {
     colorOptions?: false | ShapeColorOption[];
     lineEndStyleOptions?: false | ShapeLineEndOption[];
     fontFamilyOptions?: false | ShapeFontFamilyOption[];
@@ -236,16 +236,16 @@ interface ShapeControlOptions {
     lineHeightOptions?: false | ShapeSizeOption[] | number[];
 }
 
-interface ShapeControlConfiguration {
+export interface ShapeControlConfiguration {
     // A mapping of a shapeProperty to a Component
     [shapeProperty: string]: ShapeControl;
 }
 
-type StickerSrc = string; // emoji or URL
+export type StickerSource = string; // emoji or URL
 
-interface StickerTemplate {
-    thumb?: StickerSrc;
-    src?: StickerSrc;
+export interface StickerTemplate {
+    thumb?: StickerSource;
+    src?: StickerSource;
     width?: number;
     height?: number;
     alt?: string;
@@ -257,36 +257,36 @@ interface StickerTemplate {
     ) => { update?: (sticker: StickerTemplate) => void; destroy?: () => void };
 }
 
-type Sticker = StickerSrc | StickerTemplate;
+export type Sticker = StickerSource | StickerTemplate;
 
-interface StickerGroupOptions {
+export interface StickerGroupOptions {
     icon?: string;
     hideLabel?: boolean;
     disabled?: boolean;
 }
 
-type StickerGroup = [string, Sticker[]] | [string, Sticker[], StickerGroupOptions];
+export type StickerGroup = [string, Sticker[]] | [string, Sticker[], StickerGroupOptions];
 
-type ImageSource = File | Blob | string | HTMLImageElement | HTMLCanvasElement;
+export type ImageSource = File | Blob | string | HTMLImageElement | HTMLCanvasElement;
 
-interface Store {
+export interface Store {
     subscribe: (value: (value: any) => void) => () => void;
     set?: (value: any) => void;
     update?: (fn: (value: any) => any) => void;
 }
 
-interface StoreCollection {
+export interface StoreCollection {
     [shapeProperty: string]: Store;
 }
 
-type Filter = () => ColorMatrix;
+export type Filter = () => ColorMatrix;
 
-interface Frame {
+export interface Frame {
     shape: any;
     thumb: string; // HTML or SVG
 }
 
-interface Effect {
+export interface Effect {
     base: number;
     min: number;
     max: number;
@@ -296,7 +296,7 @@ interface Effect {
     setValue: (store: Store, value: number) => void;
 }
 
-interface EditorHistory {
+export interface PinturaEditorHistoryAPI {
     undo: () => number;
     redo: () => number;
     revert: () => void;
@@ -308,35 +308,38 @@ interface EditorHistory {
     readonly index: number;
 }
 
-interface EditorMethods {
+export interface PinturaEditorMethods {
     on: (event: string, cb: (detail?: any) => void) => void;
     loadImage: (
         src: ImageSource,
-        options: ImageOptions
+        options?: PinturaEditorOptions
     ) => Promise<PinturaDefaultImageReaderResult>;
     editImage: (
         src: ImageSource,
-        options: ImageOptions
+        options?: PinturaEditorOptions
+    ) => Promise<PinturaDefaultImageWriterResult>;
+    processImage: (
+        src?: ImageSource,
+        options?: PinturaEditorOptions
     ) => Promise<PinturaDefaultImageWriterResult>;
-    processImage: () => Promise<PinturaDefaultImageWriterResult>;
     abortLoadImage: () => void;
     abortProcessImage: () => void;
     updateImage: (src: ImageSource) => Promise<PinturaDefaultImageReaderResult>;
     updateImagePreview: (src: ImageSource) => void;
-    readonly history: EditorHistory;
     close: () => void;
     destroy: () => void;
+    readonly history: PinturaEditorHistoryAPI;
 }
 
-type CropOption = [number | undefined, string];
+export type CropOption = [number | undefined, string];
 
-type SizeOption = [[number, number], string];
+export type SizeOption = [[number, number], string];
 
-type CropPresetOption = CropOption | SizeOption;
+export type CropPresetOption = CropOption | SizeOption;
 
-type OptionGroup = [string, any[]] | [string, any[], any];
+export type OptionGroup = [string, any[]] | [string, any[], any];
 
-interface CropPluginOptions {
+export interface CropPluginOptions {
     cropAutoCenterImageSelectionTimeout?: undefined | number;
     cropWillRenderImageSelectionGuides?:
         | undefined
@@ -353,7 +356,12 @@ interface CropPluginOptions {
     cropEnableImageSelection?: boolean;
     cropEnableInfoIndicator?: boolean;
     cropEnableLimitWheelInputToCropSelection?: boolean;
+
+    /**
+     * Range in radians, defaults to Math.PI / 4
+     */
     cropEnableRotationInput?: boolean;
+    cropRotationRange?: number;
     cropEnableSelectPreset?: boolean;
     cropEnableZoomInput?: boolean;
     cropEnableZoomMatchImageAspectRatio?: boolean;
@@ -363,54 +371,112 @@ interface CropPluginOptions {
     cropSelectPresetOptions?: OptionGroup[] | CropPresetOption[];
     cropEnableRotateMatchImageAspectRatio?: 'never' | 'custom' | 'always';
     cropWillRenderTools?: (nodes: PinturaNode[], env: any, redraw: () => void) => PinturaNode[];
+    cropInteractionFocus?: 'image' | 'selection';
+    cropMinimizeToolbar?: 'never' | 'auto' | 'always';
 }
 
-interface ShapeToolButtonOptions {
+export interface ShapeToolButtonOptions {
     icon?: string;
 }
 
-type ShapeTool = [string, LocaleString] | [string, LocaleString, ShapeToolButtonOptions];
+export type ShapeTool = [string, LocaleString] | [string, LocaleString, ShapeToolButtonOptions];
 
-interface MarkupEditorProperties {
+export interface PinturaMarkupEditorProperties {
     markupEditorToolbar?: [string, LocaleString, any][];
     markupEditorToolStyles?: MarkupEditorToolStyleDefaults;
+    markupEditorToolRetainStyles?: boolean;
     markupEditorShapeStyleControls?: MarkupEditorShapeStyleControlDefaults;
     markupEditorToolSelectRadius?: number;
+
+    /**
+     * Set to `'modal'` to show a text input popup, set to `'inline'` to enable inline text editing.
+     */
     markupEditorTextInputMode?: 'modal' | 'inline';
+
+    /**
+     * Enable to automatically add a shape when a tool is selected
+     */
     enableSelectToolToAddShape?: boolean;
+
+    /**
+     * Enable to tap canvas to add text box instead of dragging
+     */
     enableTapToAddText?: boolean;
+
+    /**
+     * Enable to toggle zooming the canvas
+     */
     enableZoom?: boolean;
-    enablePan?: boolean;
+
+    /**
+     * Enable to show zoom controls
+     */
     enableZoomControls?: boolean;
+
+    /**
+     * Enable to toggle panning the canvas, pan with two fingers or by holding spacebar
+     */
+    enablePan?: boolean;
+
+    /**
+     * Enable to show the move/arrow, used to select and manipulate shapes
+     */
+    enableMoveTool?: boolean;
+
+    /**
+     * Enable to show the hand/view tool, used to pan the canvas
+     */
+    enableViewTool?: boolean;
+
+    /**
+     * Wether to automatically select move tool when enabled, set to `true` to select for all tools, set to `false` to don't select, set to array of tool names to enable for specific tools only.
+     */
+    enableAutoSelectMoveTool?: boolean | string[];
+
+    /**
+     * Set to `'pan'` to enable pan mode programatically, set to `'auto'` to revert back to normal interaction mode.
+     */
+    markupEditorInteractionMode?: 'auto' | 'pan';
+
+    /**
+     * Set current zoom level or set undefined to fit to view, set null to let editor handle zoom level
+     */
+    markupEditorZoomLevel?: number | undefined | null;
     markupEditorZoomLevels?: number[];
     markupEditorZoomAdjustStep?: number;
     markupEditorZoomAdjustFactor?: number;
+    markupEditorZoomAdjustWheelFactor?: number;
+
     markupEditorWillStartInteraction?: (point: Vector, image: Rect) => boolean;
 }
 
-interface AnnotatePluginOptions extends MarkupEditorProperties {
+export interface AnnotatePluginOptions extends PinturaMarkupEditorProperties {
     annotateActiveTool?: string;
     annotateEnableButtonFlipVertical?: boolean;
     annotatePresets?: Sticker[] | StickerGroup[];
+    annotateEnableDropImagePreset?: boolean;
+    annotateEnableSelectImagePreset?: boolean;
 }
 
-interface DecoratePluginOptions extends MarkupEditorProperties {
+export interface DecoratePluginOptions extends PinturaMarkupEditorProperties {
     decorateActiveTool?: string;
     decorateEnableButtonFlipVertical?: boolean;
     decoratePresets?: Sticker[] | StickerGroup[];
+    decorateEnableDropImagePreset?: boolean;
+    decorateEnableSelectImagePreset?: boolean;
 }
 
-interface FilterPluginOptions {
+export interface FilterPluginOptions {
     filterFunctions?: { [key: string]: Filter };
     filterOptions?: any;
 }
 
-interface FinetunePluginOptions {
+export interface FinetunePluginOptions {
     finetuneControlConfiguration?: { [key: string]: Effect };
     finetuneOptions?: [string | undefined, LocaleString];
 }
 
-interface ResizePluginOptions {
+export interface ResizePluginOptions {
     resizeMaxSize?: Size;
     resizeMinSize?: Size;
     resizeSizePresetOptions?: OptionGroup[] | SizeOption[];
@@ -419,7 +485,7 @@ interface ResizePluginOptions {
     resizeWillRenderFooter?: (nodes: PinturaNode[], env: any, redraw: () => void) => PinturaNode[];
 }
 
-interface FramePluginOptions {
+export interface FramePluginOptions {
     frameStyles?: {
         [key: string]: {
             shape: {
@@ -432,13 +498,41 @@ interface FramePluginOptions {
     frameOptions?: [string | undefined, LocaleString];
 }
 
-interface StickerPluginOptions {
+export interface StickerPluginOptions {
     stickers?: Sticker[] | StickerGroup[];
     stickerStickToImage?: boolean;
+    stickerEnableDropImagePreset?: boolean;
+    stickerEnableSelectImagePreset?: boolean;
+    stickerEnableButtonFlipVertical?: boolean;
+    stickerWillRenderShapePresetToolbar?: (
+        nodes: PinturaNode[],
+        addPreset: (sticker: Sticker) => void,
+        env: any,
+        redraw: () => void
+    ) => PinturaNode[];
+
+    /**
+     * @deprecated Use `stickerEnableSelectImagePreset` instead
+     */
+    stickerEnableSelectImage?: boolean;
+
+    /**
+     * @deprecated Use `stickerEnableButtonFlipVerticalt instead
+     */
     stickersEnableButtonFlipVertical?: boolean;
+
+    /**
+     * @deprecated Use `stickerWillRenderShapePresetToolbar` instead
+     */
+    stickersWillRenderShapePresetToolbar?: (
+        nodes: PinturaNode[],
+        addPreset: (sticker: Sticker) => void,
+        env: any,
+        redraw: () => void
+    ) => PinturaNode[];
 }
 
-interface PinturaImageState {
+export interface PinturaImageState {
     backgroundColor?: Color;
     colorMatrix?: ColorMatrix;
     convolutionMatrix?: ConvolutionMatrix;
@@ -460,7 +554,7 @@ interface PinturaImageState {
     metadata?: PinturaMetadata;
 }
 
-interface ImageOptions extends PinturaImageState {
+export interface PinturaImageOptions extends PinturaImageState {
     readonly size: Size;
     readonly aspectRatio: number;
     readonly cropSize: Size;
@@ -472,7 +566,7 @@ interface ImageOptions extends PinturaImageState {
     state?: any;
 }
 
-interface EditorImageOptionsReadonly {
+export interface PinturaEditorImageOptionsReadonly {
     readonly imageSize: Size;
     readonly imageAspectRatio: number;
     readonly imageCropSize: Size;
@@ -483,7 +577,7 @@ interface EditorImageOptionsReadonly {
     readonly imageRotationRange: [number, number];
 }
 
-interface EditorImageOptions {
+export interface PinturaEditorImageOptions {
     imageBackgroundColor?: Color;
     imageColorMatrix?: ColorMatrix;
     imageConvolutionMatrix?: ConvolutionMatrix;
@@ -512,29 +606,35 @@ interface EditorImageOptions {
     imageState?: any;
 }
 
-interface EditorOptionsReadonly {
+export interface PinturaEditorOptionsReadonly {
     readonly element?: HTMLElement;
     readonly stores?: any[];
     readonly images?: any;
 }
 
-interface PinturaNodeOptions {
+export interface PinturaNodeOptions {
     [key: string]: any;
 }
 
-type PinturaComponent = 'Button' | 'Dropdown';
+export type PinturaComponent = 'Button' | 'Dropdown';
 
-type PinturaNodeType = string | SvelteComponent | PinturaComponent;
+export type PinturaNodeType = string | SvelteComponent | PinturaComponent;
 
-type PinturaNode =
+// ignore for TypeScript 3.x
+export type PinturaNode =
     | [PinturaNodeType, string]
     | [PinturaNodeType, string, PinturaNodeOptions]
     | [PinturaNodeType, string, PinturaNode[]]
     | [PinturaNodeType, string, PinturaNodeOptions, PinturaNode[]];
 
-type PinturaEditorStatus = string | [string] | [string, number] | [string, false] | undefined;
+export type PinturaEditorStatus =
+    | string
+    | [string]
+    | [string, number]
+    | [string, false]
+    | undefined;
 
-interface EditorOptions {
+export interface PinturaEditorBaseOptions {
     id?: string;
     class?: string;
     animations?: boolean;
@@ -547,10 +647,15 @@ interface EditorOptions {
     layoutDirectionPreference?: 'auto' | 'horizontal' | 'vertical';
     layoutVerticalUtilsPreference?: 'left' | 'right';
     layoutHorizontalUtilsPreference?: 'bottom' | 'top';
+    layoutVerticalControlGroupsPreference?: 'bottom' | 'top';
+    layoutVerticalControlTabsPreference?: 'bottom' | 'top';
+    layoutVerticalToolbarPreference?: 'bottom' | 'top';
     imageSourceToImageData?: (src: any) => Promise<ImageData>;
     previewImageData?: ImageBitmap | ImageData | HTMLCanvasElement;
     previewImageDataMaxSize?: Size;
     previewUpscale?: boolean;
+    previewPad?: boolean;
+    previewMaskOpacity?: number;
     shapePreprocessor?: any;
     enableButtonClose?: boolean;
     enableButtonExport?: boolean;
@@ -562,7 +667,11 @@ interface EditorOptions {
     enableDropImage?: boolean;
     enablePasteImage?: boolean;
     handleEvent?: (type: string, detail: any) => void;
-    willRequestResource?: (url: string) => boolean;
+
+    willRequest?: (
+        url: string,
+        requestInfo: { resourceType: string }
+    ) => void | false | RequestInit;
     willClose?: () => Promise<boolean>;
     willRevert?: () => Promise<boolean>;
     willProcessImage?: () => Promise<boolean>;
@@ -571,8 +680,51 @@ interface EditorOptions {
             decorationShapes: Shape[];
             annotationShapes: Shape[];
             interfaceShapes: Shape[];
+            frameShapes: Shape;
         },
-        state: any
+        state: {
+            annotationShapesDirty: boolean;
+            backgroundColor: number[];
+            blendShapesDirty: boolean;
+            decorationShapesDirty: boolean;
+            foregroundColor: number[];
+            frameShapesDirty: boolean;
+            images: {
+                backgroundColor: number[];
+                colorMatrix: number[];
+                convolutionMatrix: number[];
+                data: ImageBitmap | ImageData;
+                gamma: number;
+                opacity: number;
+                origin: Vector;
+                resize: number;
+                rotation: { x: number; y: number; z: number };
+                scale: number;
+                size: Size;
+                translation: Vector;
+                vignette: number;
+            };
+            isInteracting: boolean;
+            isInteractingFraction: number;
+            lineColor: number[];
+            opacity: number;
+            rootRect: Rect;
+            rotation: { x: number; y: number; z: number };
+            scale: number;
+            selectionRect: Rect;
+            size: Size;
+            stageRect: Rect;
+            utilVisibility: {
+                annotate: number;
+                crop: number;
+                decorate: number;
+                filter: number;
+                finetune: number;
+                frame: number;
+                redact: number;
+                resize: number;
+            };
+        }
     ) => {
         decorationShapes: Shape[];
         annotationShapes: Shape[];
@@ -592,11 +744,16 @@ interface EditorOptions {
         env: any,
         redraw: () => void
     ) => PinturaNode[];
+
+    /**
+     * @deprecated Use `willRequest` instead
+     */
+    willRequestResource?: (url: string) => boolean;
 }
 
-interface PinturaEditorOptions
-    extends EditorOptions,
-        EditorImageOptions,
+export interface PinturaEditorOptions
+    extends PinturaEditorBaseOptions,
+        PinturaEditorImageOptions,
         AnnotatePluginOptions,
         CropPluginOptions,
         DecoratePluginOptions,
@@ -604,15 +761,15 @@ interface PinturaEditorOptions
         FinetunePluginOptions,
         StickerPluginOptions {
     locale: any;
-    imageReader: any[];
-    imageWriter?: any[];
+    imageReader: any;
+    imageWriter?: any;
     imageOrienter?: any;
     imageScrambler?: any;
 }
 
-interface PinturaEditorDefaultOptions
-    extends EditorOptions,
-        EditorImageOptions,
+export interface PinturaEditorDefaultOptions
+    extends PinturaEditorBaseOptions,
+        PinturaEditorImageOptions,
         AnnotatePluginOptions,
         CropPluginOptions,
         DecoratePluginOptions,
@@ -620,25 +777,25 @@ interface PinturaEditorDefaultOptions
         FinetunePluginOptions,
         StickerPluginOptions {
     locale?: any;
-    imageReader?: any[];
-    imageWriter?: any[];
+    imageReader?: any;
+    imageWriter?: any;
     imageOrienter?: any;
 }
 
-interface PinturaEditorHeadlessOptions extends EditorImageOptions {
-    imageReader?: any[];
-    imageWriter?: any[];
+export interface PinturaEditorHeadlessOptions extends PinturaEditorImageOptions {
+    imageReader?: any;
+    imageWriter?: any;
     imageScrambler?: any;
     shapePreprocessor?: any;
 }
 
-interface PinturaEditor
-    extends EditorMethods,
+export interface PinturaEditor
+    extends PinturaEditorMethods,
         PinturaEditorOptions,
-        EditorOptionsReadonly,
-        EditorImageOptionsReadonly {}
+        PinturaEditorOptionsReadonly,
+        PinturaEditorImageOptionsReadonly {}
 
-interface PinturaEditorModalOptions {
+export interface PinturaEditorModalOptions {
     preventZoomViewport?: boolean;
     preventScrollBodyIfNeeded?: boolean;
     preventFooterOverlapIfNeeded?: boolean;
@@ -647,12 +804,12 @@ interface PinturaEditorModalOptions {
     readonly modal?: HTMLElement;
 }
 
-interface PinturaEditorModal extends PinturaEditor, PinturaEditorModalOptions {
+export interface PinturaEditorModal extends PinturaEditor, PinturaEditorModalOptions {
     show: () => void;
     hide: () => void;
 }
 
-interface PinturaReadState {
+export interface PinturaReadState {
     index: number;
     task: string;
     taskLengthComputable: boolean;
@@ -661,7 +818,7 @@ interface PinturaReadState {
     error?: unknown;
 }
 
-interface PinturaWriteState {
+export interface PinturaWriteState {
     index: number;
     task: string;
     taskLengthComputable: boolean;
@@ -671,35 +828,35 @@ interface PinturaWriteState {
 }
 
 // Default image reader and writer
-interface PinturaDefaultImageReaderResult {
+export interface PinturaDefaultImageReaderResult {
     readonly src: ImageSource;
     readonly dest: File;
     readonly size: Size;
 }
 
-interface PinturaDefaultImageWriterResult {
+export interface PinturaDefaultImageWriterResult {
     readonly src: ImageSource;
     readonly dest: File;
     readonly imageState: any;
     readonly store: any;
 }
 
-interface PinturaTargetSize {
+export interface PinturaTargetSize {
     width?: number;
     height?: number;
     fit?: 'contain' | 'cover' | 'force';
     upscale?: boolean;
 }
 
-interface PinturaDefaultImageReaderOptions {
+export interface PinturaDefaultImageReaderOptions {
     orientImage?: boolean;
     outputProps?: string[];
     preprocessImageFile?: (file: File, options: any, onprogress: ProgressCallback) => Promise<File>;
 }
 
-type PinturaStoreField = [string, string] | [string, Blob | File, string];
+export type PinturaStoreField = [string, string] | [string, Blob | File, string];
 
-interface PinturaDefaultImageWriterOptions {
+export interface PinturaDefaultImageWriterOptions {
     canvasMemoryLimit?: number;
     orientImage?: boolean;
     copyImageHead?: boolean;
@@ -741,13 +898,14 @@ interface PinturaDefaultImageWriterOptions {
     ) => Promise<ImageData>;
 }
 
-interface PinturaDefaultImageScramblerOptions {
-    blurAmount: number;
-    scrambleAmount: number;
-    // enableSmoothing: boolean;
+export interface PinturaDefaultImageScramblerOptions {
+    blurAmount?: number;
+    scrambleAmount?: number;
+    enableSmoothing?: boolean;
+    backgroundColor?: number[];
 }
 
-interface PinturaImageOrienter {
+export interface PinturaImageOrienter {
     read: (file: Blob | File, onprogress?: ProgressCallback) => Promise<number>;
     apply: (imageData: ImageData, orientation: number) => ImageData;
 }
@@ -872,7 +1030,7 @@ export const naturalAspectRatioToNumber: (
     aspectRatio: string | number | undefined
 ) => number | false | undefined;
 export const colorStringToColorArray: (Color: string) => Color;
-export const legacyDataToImageState: (data: any) => ImageOptions;
+export const legacyDataToImageState: (data: any) => PinturaImageOptions;
 export const dispatchEditorEvents: (
     editor: PinturaEditor,
     element: HTMLElement,
@@ -881,13 +1039,21 @@ export const dispatchEditorEvents: (
 export const blobToFile: (blob: Blob) => File;
 export const isSupported: () => boolean;
 
+// shape helpers
+export const shapeGetLevel: (
+    shapeState: { flipX: undefined | boolean; flipY: undefined | boolean; rotation: number },
+    imageState: { flipX: boolean; flipY: boolean; rotation: number }
+) => { flipX: boolean; flipY: boolean; rotation: number };
+export const shapeGetLength: (shape: Shape) => undefined | number;
+export const shapeGetCenter: (shape: Shape) => Vector;
+
 // locale
 export const locale_en_gb: LocaleCollection;
 
 //
 // markup editor
 //
-interface MarkupEditorToolStyleDefaults {
+export interface MarkupEditorToolStyleDefaults {
     sharpie: [Shape, ShapeToolOptions];
     line: [Shape, ShapeToolOptions];
     arrow: [Shape, ShapeToolOptions];
@@ -897,7 +1063,7 @@ interface MarkupEditorToolStyleDefaults {
     [custom: string]: [Shape, ShapeToolOptions];
 }
 
-interface MarkupEditorShapeStyleControlDefaults {
+export interface MarkupEditorShapeStyleControlDefaults {
     backgroundColor: undefined | ShapeControl;
     strokeColor: undefined | ShapeControl;
     strokeWidth: undefined | ShapeControl;
@@ -905,13 +1071,14 @@ interface MarkupEditorShapeStyleControlDefaults {
     lineEnd: undefined | ShapeControl;
     color: undefined | ShapeControl;
     fontFamily: undefined | ShapeControl;
-    fontStyleFontWeight: undefined | ShapeControl;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    fontStyle_fontWeight: undefined | ShapeControl;
     fontSize: undefined | ShapeControl;
     textAlign: undefined | ShapeControl;
     lineHeight: undefined | ShapeControl;
 }
 
-type ToolbarItem =
+export type ToolbarItem =
     | string
     | [string, { disabled?: boolean; icon: string }]
     | [string, LocaleString, { disabled?: boolean; icon: string }];
@@ -924,7 +1091,6 @@ export const createMarkupEditorToolbar: (tools?: ToolbarItem[]) => [string, Loca
 /**
  * Create default shape styles for each tool, optionally add custom shape styles
  */
-
 export const createMarkupEditorToolStyles: (toolStyles?: {
     [key: string]: [Shape, ShapeToolOptions];
 }) => MarkupEditorToolStyleDefaults;
@@ -1007,7 +1173,7 @@ export const markup_editor_locale_en_gb: LocaleCollection;
 //
 // plugins
 //
-interface PinturaUtilPlugin {
+export interface PinturaUtilPlugin {
     util: [string, any];
 }