@pitcher/js-api 1.25.0 → 1.25.1

package/lib/apps/canvas-builder/components/ui/CustomDataTable/CustomDataTable.vue.d.ts

@@ -0,0 +1,27 @@
+import { ComponentTypes, ComponentNode, CustomDataTableProps } from '../../../types/canvas';
+import { CanvasRetrieve } from '../../../../../../types/openapi';
+type __VLS_Props = {
+    id: string;
+    data: CustomDataTableProps;
+    children?: ComponentNode[];
+    parentType?: ComponentTypes;
+    usedInSectionId?: CanvasRetrieve['id'];
+    when_used_in_section?: ComponentNode['when_used_in_section'];
+    visible?: ComponentNode['visible'];
+    tracking_id?: string;
+    style?: Record<string, any>;
+    theme_meta?: ComponentNode['theme_meta'];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    style: (s: Record<string, any>, id?: string | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onStyle?: ((s: Record<string, any>, id?: string | undefined) => any) | undefined;
+}>, {
+    children: ComponentNode[];
+    when_used_in_section: {
+        is_editable: boolean;
+        is_removable: boolean;
+    };
+    usedInSectionId: CanvasRetrieve["id"];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/lib/apps/canvas-builder/components/ui/DynamicDataTable/DynamicDataTable.utils.d.ts

@@ -0,0 +1,16 @@
+import { DynamicDataTableProps, DynamicDatatableProperty } from '../../../types/canvas';
+/**
+ * Calculate the background color for a table row based on striping configuration
+ * @param idx - The row index (0-based)
+ * @param data - The dynamic data table props containing striping configuration
+ * @param themeVars - The theme variables containing color values
+ * @returns The background color string for the row
+ */
+export declare function getRowBackgroundColor(idx: number, data: DynamicDataTableProps | undefined, themeVars: Record<string, any>): string;
+/**
+ * Format a cell value based on the property's format configuration
+ * @param value - The raw value to format
+ * @param property - The property configuration including format settings
+ * @returns The formatted string representation of the value
+ */
+export declare function formatCellValue(value: any, property: DynamicDatatableProperty): string;

package/lib/apps/canvas-builder/components/ui/Embeddable/Embeddable.raw.vue.d.ts

@@ -17,6 +17,7 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
     };
     usedInSectionId: CanvasRetrieve["id"];
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    embeddableContainer: HTMLDivElement;
     embeddableIframe: HTMLIFrameElement;
 }, any>;
 export default _default;

package/lib/apps/canvas-builder/components/ui/Embeddable/Embeddable.settings.vue.d.ts

@@ -307,14 +307,16 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
     }>, {
         validate: () => Promise<{
             config: Record<string, any>;
-            success: boolean;
+            success: true;
             errors?: undefined;
+            firstErrorFieldName?: undefined;
         } | {
             config: Record<string, any>;
             errors: unknown;
-            success: boolean;
+            firstErrorFieldName: string | undefined;
+            success: false;
         }>;
-    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
         change: (config: Record<string, any>) => any;
     }, import('vue').PublicProps, {
         loading: boolean;
@@ -629,12 +631,14 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
     }>, {
         validate: () => Promise<{
             config: Record<string, any>;
-            success: boolean;
+            success: true;
             errors?: undefined;
+            firstErrorFieldName?: undefined;
         } | {
             config: Record<string, any>;
             errors: unknown;
-            success: boolean;
+            firstErrorFieldName: string | undefined;
+            success: false;
         }>;
     }, {}, {}, {}, {
         loading: boolean;

package/lib/apps/canvas-builder/components/ui/Html/CAiHtmlActions.vue.d.ts

@@ -0,0 +1,23 @@
+import { StyleValue } from 'vue';
+interface Props {
+    modelValue: string;
+    themeOverrides?: {
+        active: StyleValue;
+        default: StyleValue;
+    };
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    startLoading: () => any;
+    endLoading: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onStartLoading?: (() => any) | undefined;
+    onEndLoading?: (() => any) | undefined;
+}>, {
+    themeOverrides: {
+        active: StyleValue;
+        default: StyleValue;
+    };
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/apps/canvas-builder/components/ui/Html/Html.vue.d.ts

@@ -1,4 +1,4 @@
-import { HtmlProps, ComponentNode } from '../../../types/canvas';
+import { HtmlProps, ComponentNode, ComponentTypes } from '../../../types/canvas';
 import { CanvasRetrieve } from '../../../../../../types/openapi';
 type __VLS_Props = {
     id: string;
@@ -7,6 +7,7 @@ type __VLS_Props = {
     usedInSectionId?: CanvasRetrieve['id'];
     visible?: ComponentNode['visible'];
     tracking_id?: string;
+    parentType?: ComponentTypes;
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     when_used_in_section: {
@@ -14,5 +15,7 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
         is_removable: boolean;
     };
     usedInSectionId: CanvasRetrieve["id"];
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    contentElement: HTMLDivElement;
+}, any>;
 export default _default;

package/lib/apps/canvas-builder/components/ui/IFrame/IFrame.raw.vue.d.ts

@@ -16,6 +16,7 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
     };
     usedInSectionId: string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    iframeContainer: HTMLDivElement;
     iframe: HTMLIFrameElement;
 }, any>;
 export default _default;

package/lib/apps/canvas-builder/components/ui/Root/Root.settings.vue.d.ts

@@ -15,14 +15,16 @@ declare const _default: import('vue').DefineComponent<{}, {
     }>, {
         validate: () => Promise<{
             config: Record<string, any>;
-            success: boolean;
+            success: true;
             errors?: undefined;
+            firstErrorFieldName?: undefined;
         } | {
             config: Record<string, any>;
             errors: unknown;
-            success: boolean;
+            firstErrorFieldName: string | undefined;
+            success: false;
         }>;
-    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
         change: (config: Record<string, any>) => any;
     }, import('vue').PublicProps, {
         loading: boolean;
@@ -337,12 +339,14 @@ declare const _default: import('vue').DefineComponent<{}, {
     }>, {
         validate: () => Promise<{
             config: Record<string, any>;
-            success: boolean;
+            success: true;
             errors?: undefined;
+            firstErrorFieldName?: undefined;
         } | {
             config: Record<string, any>;
             errors: unknown;
-            success: boolean;
+            firstErrorFieldName: string | undefined;
+            success: false;
         }>;
     }, {}, {}, {}, {
         loading: boolean;

package/lib/apps/canvas-builder/components/ui/Scribble/Scribble.original.vue.d.ts

@@ -1,5 +1,5 @@
 import { CSSProperties } from 'vue';
-import { ComponentNode, ScribbleProps } from '../../../types/canvas';
+import { ComponentNode, ScribbleProps, ComponentNodeThemeMeta } from '../../../types/canvas';
 import { CanvasRetrieve } from '../../../../../../types/openapi';
 type __VLS_Props = {
     id: string;
@@ -10,6 +10,7 @@ type __VLS_Props = {
     visible?: ComponentNode['visible'];
     tracking_id?: string;
     style?: CSSProperties;
+    theme_meta?: ComponentNodeThemeMeta;
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     style: (s: CSSProperties, id?: string | undefined) => any;

package/lib/apps/canvas-builder/components/ui/Scribble/Scribble.responsive.vue.d.ts

@@ -1,5 +1,5 @@
 import { CSSProperties } from 'vue';
-import { ComponentNode, ScribbleProps } from '../../../types/canvas';
+import { ComponentNode, ScribbleProps, ComponentNodeThemeMeta } from '../../../types/canvas';
 import { CanvasRetrieve } from '../../../../../../types/openapi';
 type __VLS_Props = {
     id: string;
@@ -10,6 +10,7 @@ type __VLS_Props = {
     visible?: ComponentNode['visible'];
     tracking_id?: string;
     style?: CSSProperties;
+    theme_meta?: ComponentNodeThemeMeta;
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     style: (s: CSSProperties, id?: string | undefined) => any;

package/lib/apps/canvas-builder/components/ui/Scribble/Scribble.vue.d.ts

@@ -1,5 +1,5 @@
 import { CSSProperties } from 'vue';
-import { ComponentNode, ScribbleProps } from '../../../types/canvas';
+import { ComponentNode, ScribbleProps, ComponentNodeThemeMeta } from '../../../types/canvas';
 import { CanvasRetrieve } from '../../../../../../types/openapi';
 type __VLS_Props = {
     id: string;
@@ -10,6 +10,7 @@ type __VLS_Props = {
     visible?: ComponentNode['visible'];
     tracking_id?: string;
     style?: CSSProperties;
+    theme_meta?: ComponentNodeThemeMeta;
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     style: (s: CSSProperties, id?: string | undefined) => any;

package/lib/apps/canvas-builder/components/ui/Scribble/scribble.helpers.d.ts

@@ -1,5 +1,14 @@
+import { ComponentNode } from '../../../types/canvas';
 export declare const ACTUAL_CANVAS_WIDTH: number;
 export declare function calculateProportionalDimensions(originalWidth: number, originalHeight: number, targetWidth?: number): {
     width: number;
     height: number;
 };
+export declare function getComponentPositionStyle(component: ComponentNode): {
+    position: any;
+    left: any;
+    top: any;
+    width: any;
+    height: any;
+    zIndex: any;
+};

package/lib/apps/canvas-builder/components/ui/SectionList/SectionItemModal.vue.d.ts

@@ -0,0 +1,39 @@
+import { CanvasRetrieve } from '../../../../../../types/openapi';
+export type Emit = {
+    close: [save?: boolean];
+};
+type __VLS_Props = {
+    zIndex?: number;
+    attachTo?: string | HTMLElement;
+    section: CanvasRetrieve['sections'][number];
+    index: number;
+    saveCanvas: () => Promise<void>;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            index: number;
+            section: import('../../../../../../types/openapi').CanvasSection;
+        }): any;
+    };
+    refs: {
+        rootRef: HTMLElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (save?: boolean | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: ((save?: boolean | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    rootRef: HTMLElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/apps/canvas-builder/components/ui/SectionList/SectionList.raw.vue.d.ts

@@ -9,6 +9,7 @@ type __VLS_Props = {
     style?: CSSProperties;
     shouldEditWithApp?: boolean;
     hasSectionSelectorApp?: boolean;
+    printModeIdx?: number;
 };
 declare function onSectionSelectorToggle(): void;
 declare function onSectionsSelect(items: {
@@ -23,5 +24,7 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onJustAdded?: ((id: string) => any) | undefined;
     onBrowseWithAppClicked?: (() => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    sectionListRef: HTMLDivElement;
+}, any>;
 export default _default;

package/lib/apps/canvas-builder/components/ui/SectionList/SectionList.vue.d.ts

@@ -7,6 +7,7 @@ type __VLS_Props = {
     visible?: ComponentNode['visible'];
     allow_admins_to_overwrite?: boolean;
     style?: CSSProperties;
+    printModeIdx?: number;
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     style: (s: CSSProperties) => any;
@@ -21,6 +22,7 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
         style?: CSSProperties;
         shouldEditWithApp?: boolean;
         hasSectionSelectorApp?: boolean;
+        printModeIdx?: number;
     }> & Readonly<{
         onJustAdded?: ((id: string) => any) | undefined;
         onBrowseWithAppClicked?: (() => any) | undefined;
@@ -32,7 +34,9 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
     }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
         justAdded: (id: string) => any;
         browseWithAppClicked: () => any;
-    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        sectionListRef: HTMLDivElement;
+    }, any, import('vue').ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
@@ -47,6 +51,7 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
         style?: CSSProperties;
         shouldEditWithApp?: boolean;
         hasSectionSelectorApp?: boolean;
+        printModeIdx?: number;
     }> & Readonly<{
         onJustAdded?: ((id: string) => any) | undefined;
         onBrowseWithAppClicked?: (() => any) | undefined;

package/lib/apps/canvas-builder/components/ui/SectionList/SectionListCompact.vue.d.ts

@@ -0,0 +1,18 @@
+import { CanvasRetrieve } from '../../../../../../types/openapi';
+type __VLS_Props = {
+    name?: string;
+    style?: Record<string, any>;
+    sections: Array<{
+        section: CanvasRetrieve['sections'][number];
+        index: number;
+    }>;
+    hasSectionSelectorApp?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "open-section": (section: import('../../../../../../types/openapi').CanvasSection, index: number) => any;
+    "select-sections": () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onOpen-section"?: ((section: import('../../../../../../types/openapi').CanvasSection, index: number) => any) | undefined;
+    "onSelect-sections"?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/apps/canvas-builder/components/ui/SectionList/SectionListItem.vue.d.ts

@@ -0,0 +1,27 @@
+import { CanvasRetrieve } from '../../../../../../types/openapi';
+import { CSSProperties } from 'vue';
+import { ComponentNode } from '../../../types/canvas.ts';
+type __VLS_Props = {
+    section: CanvasRetrieve['sections'][number];
+    index: number;
+    id: string;
+    sectionContentById: Record<string, {
+        content: CanvasRetrieve['content'];
+    }>;
+    getSectionThemeStyle: (section: CanvasRetrieve['sections'][number] & {
+        theme?: CanvasRetrieve['theme'];
+    }, style?: CSSProperties) => Record<string, string>;
+    getComponentStyle: (c: ComponentNode, section: CanvasRetrieve['sections'][number], cIdx?: number, sectionContent?: ComponentNode[]) => {
+        marginBottom?: undefined;
+    } | {
+        marginBottom: any;
+    };
+    componentMap: Record<string, any>;
+    getComponentBindings: (c: ComponentNode) => ComponentNode;
+    onElementVisibility: (isVisible: boolean, c: ComponentNode) => void;
+    isSectionLoaded: (section: CanvasRetrieve['sections'][number], sectionIdx?: number) => boolean;
+    onSectionVisibility: (isVisible: boolean, section: CanvasRetrieve['sections'][number], sectionIdx?: number) => void;
+    style?: CSSProperties;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/lib/apps/canvas-builder/components/ui/SectionList/SectionSearch.vue.d.ts

@@ -0,0 +1,11 @@
+type Props = {
+    autofocus?: boolean;
+    search?: string;
+    placeholder?: string;
+};
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:search": (term: string) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:search"?: ((term: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/apps/canvas-builder/components/ui/SectionList/SectionSelectorToolbar.vue.d.ts

@@ -13,27 +13,27 @@ type __VLS_Props = {
     selectedItemIds?: CanvasRetrieve['id'][];
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "clear-selection": () => any;
+    "items-added": (itemIds: string[], position?: "bottom" | "top" | undefined) => any;
+    "items-removed": (itemIds: string[]) => any;
     "toggle-select-all": () => any;
     "page-first": () => any;
     "page-last": () => any;
     "page-next": () => any;
     "page-previous": () => any;
-    "clear-selection": () => any;
-    "items-added": (itemIds: string[], position?: "bottom" | "top" | undefined) => any;
-    "items-removed": (itemIds: string[]) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onClear-selection"?: (() => any) | undefined;
+    "onItems-added"?: ((itemIds: string[], position?: "bottom" | "top" | undefined) => any) | undefined;
+    "onItems-removed"?: ((itemIds: string[]) => any) | undefined;
     "onToggle-select-all"?: (() => any) | undefined;
     "onPage-first"?: (() => any) | undefined;
     "onPage-last"?: (() => any) | undefined;
     "onPage-next"?: (() => any) | undefined;
     "onPage-previous"?: (() => any) | undefined;
-    "onClear-selection"?: (() => any) | undefined;
-    "onItems-added"?: ((itemIds: string[], position?: "bottom" | "top" | undefined) => any) | undefined;
-    "onItems-removed"?: ((itemIds: string[]) => any) | undefined;
 }>, {
     loading: boolean;
+    addedItemIds: CanvasRetrieve["id"][];
     selectedItemIds: CanvasRetrieve["id"][];
     disablePagination: boolean;
-    addedItemIds: CanvasRetrieve["id"][];
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

package/lib/apps/canvas-builder/components/ui/SectionList/SectionSelectorWithDragAndDrop.vue.d.ts

@@ -1,3 +1,4 @@
+import { nextTick } from 'vue';
 import { SectionListProps } from '../../../types/canvas';
 import { CanvasRetrieve, Canvas } from '../../../../../../types/openapi';
 type __VLS_Props = {
@@ -17,6 +18,159 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
     selectionStrategy: "app" | "single" | "free" | "at-least-one";
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     toolbarWrapper: HTMLDivElement;
+    smartFoldersRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        storageKey: string;
+        mode: "management" | "selector";
+        selectedSectionIds?: CanvasRetrieve["id"][];
+        addedSectionIds?: CanvasRetrieve["id"][];
+    }> & Readonly<{
+        "onClear-selection"?: (() => any) | undefined;
+        "onOpen-section"?: ((section: CanvasRetrieve) => any) | undefined;
+        "onEdit-section"?: ((section: CanvasRetrieve) => any) | undefined;
+        "onSection-select"?: ((section: CanvasRetrieve) => any) | undefined;
+        "onSection-add"?: ((section: CanvasRetrieve) => any) | undefined;
+        "onSection-remove"?: ((section: CanvasRetrieve) => any) | undefined;
+        "onSections-bulk-add"?: ((sections: CanvasRetrieve[], position?: "bottom" | "top" | undefined, targetIndex?: number | undefined) => any) | undefined;
+        "onSections-bulk-remove"?: ((sections: CanvasRetrieve[]) => any) | undefined;
+    }>, {
+        showConfigurationModal: () => void;
+        addSelectedSections: (position?: "top" | "bottom") => void;
+        removeSelectedSections: () => void;
+        getSelectedSections: () => CanvasRetrieve[];
+        calculateContentHeight: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "clear-selection": () => any;
+        "open-section": (section: CanvasRetrieve) => any;
+        "edit-section": (section: CanvasRetrieve) => any;
+        "section-select": (section: CanvasRetrieve) => any;
+        "section-add": (section: CanvasRetrieve) => any;
+        "section-remove": (section: CanvasRetrieve) => any;
+        "sections-bulk-add": (sections: CanvasRetrieve[], position?: "bottom" | "top" | undefined, targetIndex?: number | undefined) => any;
+        "sections-bulk-remove": (sections: CanvasRetrieve[]) => any;
+    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        containerRef: HTMLDivElement;
+        toolbarRef: HTMLDivElement;
+        listRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly data: import('../../../../../components/CList/CList.vue').ListDataItem[];
+                readonly selectedIds?: (number | string)[] | undefined;
+                readonly maxRowHeight: number;
+                readonly height?: number | undefined;
+                readonly movable?: boolean | undefined;
+                readonly onMove?: ((...args: any[]) => any) | undefined;
+                readonly "onItem:click"?: ((...args: any[]) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                virtualizerContainerRef: HTMLDivElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "move", ...args: any[]) => void) & ((event: "item:click", ...args: any[]) => void);
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<{
+                data: import('../../../../../components/CList/CList.vue').ListDataItem[];
+                selectedIds?: (number | string)[];
+                maxRowHeight: number;
+                height?: number;
+                movable?: boolean;
+            }> & Readonly<{
+                onMove?: ((...args: any[]) => any) | undefined;
+                "onItem:click"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                updateContextMenuItem: (item: import('../../../../../components/CList/CList.vue').ListDataItem, isOpen: boolean, e?: MouseEvent) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                move: (...args: any[]) => void;
+                "item:click": (...args: any[]) => void;
+            }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{}> & Omit<Readonly<{
+            data: import('../../../../../components/CList/CList.vue').ListDataItem[];
+            selectedIds?: (number | string)[];
+            maxRowHeight: number;
+            height?: number;
+            movable?: boolean;
+        }> & Readonly<{
+            onMove?: ((...args: any[]) => any) | undefined;
+            "onItem:click"?: ((...args: any[]) => any) | undefined;
+        }>, "updateContextMenuItem"> & import('vue').ShallowUnwrapRef<{
+            updateContextMenuItem: (item: import('../../../../../components/CList/CList.vue').ListDataItem, isOpen: boolean, e?: MouseEvent) => void;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                item?(_: {
+                    index: number;
+                    isContextMenuOpen: boolean;
+                    isDraggedOver: boolean;
+                    isSelected: boolean;
+                    item: {
+                        [key: string]: any;
+                        id: number | string;
+                    };
+                }): any;
+                'item:context-menu'?(_: {
+                    item: {
+                        [key: string]: any;
+                        id: number | string;
+                    };
+                }): any;
+            };
+        }) | null;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        storageKey: string;
+        mode: "management" | "selector";
+        selectedSectionIds?: CanvasRetrieve["id"][];
+        addedSectionIds?: CanvasRetrieve["id"][];
+    }> & Readonly<{
+        "onClear-selection"?: (() => any) | undefined;
+        "onOpen-section"?: ((section: CanvasRetrieve) => any) | undefined;
+        "onEdit-section"?: ((section: CanvasRetrieve) => any) | undefined;
+        "onSection-select"?: ((section: CanvasRetrieve) => any) | undefined;
+        "onSection-add"?: ((section: CanvasRetrieve) => any) | undefined;
+        "onSection-remove"?: ((section: CanvasRetrieve) => any) | undefined;
+        "onSections-bulk-add"?: ((sections: CanvasRetrieve[], position?: "bottom" | "top" | undefined, targetIndex?: number | undefined) => any) | undefined;
+        "onSections-bulk-remove"?: ((sections: CanvasRetrieve[]) => any) | undefined;
+    }>, {
+        showConfigurationModal: () => void;
+        addSelectedSections: (position?: "top" | "bottom") => void;
+        removeSelectedSections: () => void;
+        getSelectedSections: () => CanvasRetrieve[];
+        calculateContentHeight: () => void;
+    }, {}, {}, {}, {}> | null;
     sectionSelectorSelectedRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
         modelValue: Canvas[];
     }> & Readonly<{

package/lib/apps/canvas-builder/composables/useAnnotation.d.ts

@@ -0,0 +1,29 @@
+import { MarkerArea } from '@markerjs/markerjs3';
+import type * as Markerjs3 from '@markerjs/markerjs3';
+export default function useAnnotation(): {
+    isVisibleMenu: import('vue').Ref<boolean, boolean>;
+    markerTools: import('vue').ComputedRef<{
+        [key: string]: {
+            marker: typeof Markerjs3.MarkerBase | "selection" | "eraseSelected" | "eraseAll" | null;
+            icon: string;
+            translationKey: string;
+            action?: () => void;
+            dividerBefore?: boolean;
+        };
+    }>;
+    activeToolIcon: import('vue').ComputedRef<string>;
+    activeTool: import('vue').Ref<string | typeof Markerjs3.MarkerBase | null, string | typeof Markerjs3.MarkerBase | null>;
+    isReady: import('vue').Ref<boolean, boolean>;
+    handleAnnotationSelect: (action: string) => void;
+    setActiveMarker: (marker: null | MarkerArea) => void;
+    activeMarker: import('vue').Ref<Markerjs3.MarkerArea | null, Markerjs3.MarkerArea | null>;
+    showMenu: (value: boolean) => boolean;
+    toggleMenu: () => boolean;
+    storage: Map<string, any>;
+    resetAnnotations: (notify?: boolean) => void;
+    triggerToolUpdate: () => void;
+    clearStorage: () => void;
+    applyShadowRootStyles: (shadowRoot: ShadowRoot) => void;
+    createNewImage: (width: number, height: number) => string;
+    isDrawingActive: import('vue').ComputedRef<boolean>;
+};