@odoo/o-spreadsheet 19.5.0-alpha.9 → 20.1.0-alpha.0

package/dist/types/components/standalone_grid_canvas/standalone_grid_canvas.d.ts

@@ -1,10 +1,15 @@
 import { Component } from "../../owl3_compatibility_layer";
 import { RendererStore } from "../../stores/renderer_store";
+import { PropsOf } from "../../types/props_of";
 import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
 import { Store } from "../../types/store_engine";
+import { CarouselDataViewPrint } from "./carousel_data_view_print";
 import { FigureRendererStore } from "./figure_renderer_store";
 export declare class StandaloneGridCanvas extends Component<SpreadsheetChildEnv> {
     static template: string;
+    static components: {
+        CarouselDataViewPrint: typeof CarouselDataViewPrint;
+    };
     protected props: import("@odoo/owl").Props<{
         sheetId: import("../..").UID;
         zone: import("../..").Zone;
@@ -19,10 +24,399 @@ export declare class StandaloneGridCanvas extends Component<SpreadsheetChildEnv>
             activeRows: Set<number>;
             activePosition: import("../..").CellPosition | undefined;
         };
+        canvas: {
+            height: number;
+            width: number;
+            captureStream: (frameRequestRate?: number) => MediaStream;
+            getContext: {
+                (contextId: "2d", options?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
+                (contextId: "bitmaprenderer", options?: ImageBitmapRenderingContextSettings): ImageBitmapRenderingContext | null;
+                (contextId: "webgl", options?: WebGLContextAttributes): WebGLRenderingContext | null;
+                (contextId: "webgl2", options?: WebGLContextAttributes): WebGL2RenderingContext | null;
+                (contextId: string, options?: any): RenderingContext | null;
+            };
+            toBlob: (callback: BlobCallback, type?: string, quality?: number) => void;
+            toDataURL: (type?: string, quality?: number) => string;
+            transferControlToOffscreen: () => OffscreenCanvas;
+            addEventListener: {
+                <K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLCanvasElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            accessKey: string;
+            readonly accessKeyLabel: string;
+            autocapitalize: string;
+            autocorrect: boolean;
+            dir: string;
+            draggable: boolean;
+            hidden: boolean | "until-found";
+            inert: boolean;
+            innerText: string;
+            lang: string;
+            readonly offsetHeight: number;
+            readonly offsetLeft: number;
+            readonly offsetParent: Element | null;
+            readonly offsetTop: number;
+            readonly offsetWidth: number;
+            outerText: string;
+            popover: string | null;
+            spellcheck: boolean;
+            title: string;
+            translate: boolean;
+            writingSuggestions: string;
+            attachInternals: () => ElementInternals;
+            click: () => void;
+            hidePopover: () => void;
+            showPopover: (options?: ShowPopoverOptions) => void;
+            togglePopover: (options?: TogglePopoverOptions | boolean) => boolean;
+            readonly attributes: NamedNodeMap;
+            classList: DOMTokenList;
+            className: string;
+            readonly clientHeight: number;
+            readonly clientLeft: number;
+            readonly clientTop: number;
+            readonly clientWidth: number;
+            readonly currentCSSZoom: number;
+            readonly customElementRegistry: CustomElementRegistry | null;
+            id: string;
+            innerHTML: string;
+            readonly localName: string;
+            readonly namespaceURI: string | null;
+            onfullscreenchange: ((this: Element, ev: Event) => any) | null;
+            onfullscreenerror: ((this: Element, ev: Event) => any) | null;
+            outerHTML: string;
+            readonly ownerDocument: Document;
+            part: DOMTokenList;
+            readonly prefix: string | null;
+            readonly scrollHeight: number;
+            scrollLeft: number;
+            scrollTop: number;
+            readonly scrollWidth: number;
+            readonly shadowRoot: ShadowRoot | null;
+            slot: string;
+            readonly tagName: string;
+            attachShadow: (init: ShadowRootInit) => ShadowRoot;
+            checkVisibility: (options?: CheckVisibilityOptions) => boolean;
+            closest: {
+                <K extends keyof HTMLElementTagNameMap>(selector: K): HTMLElementTagNameMap[K] | null;
+                <K extends keyof SVGElementTagNameMap>(selector: K): SVGElementTagNameMap[K] | null;
+                <K extends keyof MathMLElementTagNameMap>(selector: K): MathMLElementTagNameMap[K] | null;
+                <E extends Element = Element>(selectors: string): E | null;
+            };
+            computedStyleMap: () => StylePropertyMapReadOnly;
+            getAttribute: (qualifiedName: string) => string | null;
+            getAttributeNS: (namespace: string | null, localName: string) => string | null;
+            getAttributeNames: () => string[];
+            getAttributeNode: (qualifiedName: string) => Attr | null;
+            getAttributeNodeNS: (namespace: string | null, localName: string) => Attr | null;
+            getBoundingClientRect: () => DOMRect;
+            getClientRects: () => DOMRectList;
+            getElementsByClassName: (classNames: string) => HTMLCollectionOf<Element>;
+            getElementsByTagName: {
+                <K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
+                <K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
+                <K extends keyof MathMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<MathMLElementTagNameMap[K]>;
+                <K extends keyof HTMLElementDeprecatedTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementDeprecatedTagNameMap[K]>;
+                (qualifiedName: string): HTMLCollectionOf<Element>;
+            };
+            getElementsByTagNameNS: {
+                (namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
+                (namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
+                (namespaceURI: "http://www.w3.org/1998/Math/MathML", localName: string): HTMLCollectionOf<MathMLElement>;
+                (namespace: string | null, localName: string): HTMLCollectionOf<Element>;
+            };
+            getHTML: (options?: GetHTMLOptions) => string;
+            hasAttribute: (qualifiedName: string) => boolean;
+            hasAttributeNS: (namespace: string | null, localName: string) => boolean;
+            hasAttributes: () => boolean;
+            hasPointerCapture: (pointerId: number) => boolean;
+            insertAdjacentElement: (where: InsertPosition, element: Element) => Element | null;
+            insertAdjacentHTML: (position: InsertPosition, string: string) => void;
+            insertAdjacentText: (where: InsertPosition, data: string) => void;
+            matches: {
+                <K extends keyof HTMLElementTagNameMap>(selectors: K): this is HTMLElementTagNameMap[K];
+                <K extends keyof SVGElementTagNameMap>(selectors: K): this is SVGElementTagNameMap[K];
+                <K extends keyof MathMLElementTagNameMap>(selectors: K): this is MathMLElementTagNameMap[K];
+                (selectors: string): boolean;
+            };
+            releasePointerCapture: (pointerId: number) => void;
+            removeAttribute: (qualifiedName: string) => void;
+            removeAttributeNS: (namespace: string | null, localName: string) => void;
+            removeAttributeNode: (attr: Attr) => Attr;
+            requestFullscreen: (options?: FullscreenOptions) => Promise<void>;
+            requestPointerLock: (options?: PointerLockOptions) => Promise<void>;
+            scroll: {
+                (options?: ScrollToOptions): void;
+                (x: number, y: number): void;
+            };
+            scrollBy: {
+                (options?: ScrollToOptions): void;
+                (x: number, y: number): void;
+            };
+            scrollIntoView: (arg?: boolean | ScrollIntoViewOptions) => void;
+            scrollTo: {
+                (options?: ScrollToOptions): void;
+                (x: number, y: number): void;
+            };
+            setAttribute: (qualifiedName: string, value: string) => void;
+            setAttributeNS: (namespace: string | null, qualifiedName: string, value: string) => void;
+            setAttributeNode: (attr: Attr) => Attr | null;
+            setAttributeNodeNS: (attr: Attr) => Attr | null;
+            setHTMLUnsafe: (html: string) => void;
+            setPointerCapture: (pointerId: number) => void;
+            toggleAttribute: (qualifiedName: string, force?: boolean) => boolean;
+            webkitMatchesSelector: (selectors: string) => boolean;
+            textContent: string;
+            readonly baseURI: string;
+            readonly childNodes: NodeListOf<ChildNode>;
+            readonly firstChild: ChildNode | null;
+            readonly isConnected: boolean;
+            readonly lastChild: ChildNode | null;
+            readonly nextSibling: ChildNode | null;
+            readonly nodeName: string;
+            readonly nodeType: number;
+            nodeValue: string | null;
+            readonly parentElement: HTMLElement | null;
+            readonly parentNode: ParentNode | null;
+            readonly previousSibling: ChildNode | null;
+            appendChild: <T extends Node>(node: T) => T;
+            cloneNode: (subtree?: boolean) => Node;
+            compareDocumentPosition: (other: Node) => number;
+            contains: (other: Node | null) => boolean;
+            getRootNode: (options?: GetRootNodeOptions) => Node;
+            hasChildNodes: () => boolean;
+            insertBefore: <T extends Node>(node: T, child: Node | null) => T;
+            isDefaultNamespace: (namespace: string | null) => boolean;
+            isEqualNode: (otherNode: Node | null) => boolean;
+            isSameNode: (otherNode: Node | null) => boolean;
+            lookupNamespaceURI: (prefix: string | null) => string | null;
+            lookupPrefix: (namespace: string | null) => string | null;
+            normalize: () => void;
+            removeChild: <T extends Node>(child: T) => T;
+            replaceChild: <T extends Node>(node: Node, child: T) => T;
+            readonly ELEMENT_NODE: 1;
+            readonly ATTRIBUTE_NODE: 2;
+            readonly TEXT_NODE: 3;
+            readonly CDATA_SECTION_NODE: 4;
+            readonly ENTITY_REFERENCE_NODE: 5;
+            readonly ENTITY_NODE: 6;
+            readonly PROCESSING_INSTRUCTION_NODE: 7;
+            readonly COMMENT_NODE: 8;
+            readonly DOCUMENT_NODE: 9;
+            readonly DOCUMENT_TYPE_NODE: 10;
+            readonly DOCUMENT_FRAGMENT_NODE: 11;
+            readonly NOTATION_NODE: 12;
+            readonly DOCUMENT_POSITION_DISCONNECTED: 1;
+            readonly DOCUMENT_POSITION_PRECEDING: 2;
+            readonly DOCUMENT_POSITION_FOLLOWING: 4;
+            readonly DOCUMENT_POSITION_CONTAINS: 8;
+            readonly DOCUMENT_POSITION_CONTAINED_BY: 16;
+            readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32;
+            dispatchEvent: (event: Event) => boolean;
+            ariaActiveDescendantElement: Element | null;
+            ariaAtomic: string | null;
+            ariaAutoComplete: string | null;
+            ariaBrailleLabel: string | null;
+            ariaBrailleRoleDescription: string | null;
+            ariaBusy: string | null;
+            ariaChecked: string | null;
+            ariaColCount: string | null;
+            ariaColIndex: string | null;
+            ariaColIndexText: string | null;
+            ariaColSpan: string | null;
+            ariaControlsElements: ReadonlyArray<Element> | null;
+            ariaCurrent: string | null;
+            ariaDescribedByElements: ReadonlyArray<Element> | null;
+            ariaDescription: string | null;
+            ariaDetailsElements: ReadonlyArray<Element> | null;
+            ariaDisabled: string | null;
+            ariaErrorMessageElements: ReadonlyArray<Element> | null;
+            ariaExpanded: string | null;
+            ariaFlowToElements: ReadonlyArray<Element> | null;
+            ariaHasPopup: string | null;
+            ariaHidden: string | null;
+            ariaInvalid: string | null;
+            ariaKeyShortcuts: string | null;
+            ariaLabel: string | null;
+            ariaLabelledByElements: ReadonlyArray<Element> | null;
+            ariaLevel: string | null;
+            ariaLive: string | null;
+            ariaModal: string | null;
+            ariaMultiLine: string | null;
+            ariaMultiSelectable: string | null;
+            ariaOrientation: string | null;
+            ariaOwnsElements: ReadonlyArray<Element> | null;
+            ariaPlaceholder: string | null;
+            ariaPosInSet: string | null;
+            ariaPressed: string | null;
+            ariaReadOnly: string | null;
+            ariaRelevant: string | null;
+            ariaRequired: string | null;
+            ariaRoleDescription: string | null;
+            ariaRowCount: string | null;
+            ariaRowIndex: string | null;
+            ariaRowIndexText: string | null;
+            ariaRowSpan: string | null;
+            ariaSelected: string | null;
+            ariaSetSize: string | null;
+            ariaSort: string | null;
+            ariaValueMax: string | null;
+            ariaValueMin: string | null;
+            ariaValueNow: string | null;
+            ariaValueText: string | null;
+            role: string | null;
+            animate: (keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions) => Animation;
+            getAnimations: (options?: GetAnimationsOptions) => Animation[];
+            after: (...nodes: (Node | string)[]) => void;
+            before: (...nodes: (Node | string)[]) => void;
+            remove: () => void;
+            replaceWith: (...nodes: (Node | string)[]) => void;
+            readonly nextElementSibling: Element | null;
+            readonly previousElementSibling: Element | null;
+            readonly childElementCount: number;
+            readonly children: HTMLCollection;
+            readonly firstElementChild: Element | null;
+            readonly lastElementChild: Element | null;
+            append: (...nodes: (Node | string)[]) => void;
+            moveBefore: (node: Node, child: Node | null) => void;
+            prepend: (...nodes: (Node | string)[]) => void;
+            querySelector: {
+                <K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
+                <K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
+                <K extends keyof MathMLElementTagNameMap>(selectors: K): MathMLElementTagNameMap[K] | null;
+                <K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): HTMLElementDeprecatedTagNameMap[K] | null;
+                <E extends Element = Element>(selectors: string): E | null;
+            };
+            querySelectorAll: {
+                <K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
+                <K extends keyof SVGElementTagNameMap>(selectors: K): NodeListOf<SVGElementTagNameMap[K]>;
+                <K extends keyof MathMLElementTagNameMap>(selectors: K): NodeListOf<MathMLElementTagNameMap[K]>;
+                <K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): NodeListOf<HTMLElementDeprecatedTagNameMap[K]>;
+                <E extends Element = Element>(selectors: string): NodeListOf<E>;
+            };
+            replaceChildren: (...nodes: (Node | string)[]) => void;
+            readonly assignedSlot: HTMLSlotElement | null;
+            readonly attributeStyleMap: StylePropertyMap;
+            style: CSSStyleDeclaration;
+            contentEditable: string;
+            enterKeyHint: string;
+            inputMode: string;
+            readonly isContentEditable: boolean;
+            onabort: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
+            onanimationcancel: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+            onanimationend: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+            onanimationiteration: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+            onanimationstart: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+            onauxclick: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onbeforeinput: ((this: GlobalEventHandlers, ev: InputEvent) => any) | null;
+            onbeforematch: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onbeforetoggle: ((this: GlobalEventHandlers, ev: ToggleEvent) => any) | null;
+            onblur: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
+            oncancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            oncanplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            oncanplaythrough: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onclick: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onclose: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            oncommand: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            oncontextlost: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            oncontextmenu: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            oncontextrestored: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            oncopy: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+            oncuechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            oncut: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+            ondblclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            ondrag: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+            ondragend: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+            ondragenter: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+            ondragleave: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+            ondragover: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+            ondragstart: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+            ondrop: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+            ondurationchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onemptied: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onended: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onerror: OnErrorEventHandler;
+            onfocus: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
+            onformdata: ((this: GlobalEventHandlers, ev: FormDataEvent) => any) | null;
+            ongotpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            oninput: ((this: GlobalEventHandlers, ev: InputEvent) => any) | null;
+            oninvalid: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onkeydown: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+            onkeypress: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+            onkeyup: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+            onload: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onloadeddata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onloadedmetadata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onloadstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onlostpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onmousedown: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            onmouseenter: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            onmouseleave: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            onmousemove: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            onmouseout: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            onmouseover: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            onmouseup: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+            onpaste: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+            onpause: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onplaying: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onpointercancel: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onpointerdown: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onpointerenter: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onpointerleave: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onpointermove: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onpointerout: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onpointerover: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onpointerrawupdate: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onpointerup: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+            onprogress: ((this: GlobalEventHandlers, ev: ProgressEvent) => any) | null;
+            onratechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onreset: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onresize: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
+            onscroll: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onscrollend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onsecuritypolicyviolation: ((this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any) | null;
+            onseeked: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onseeking: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onselect: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onselectionchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onselectstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onslotchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onstalled: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onsubmit: ((this: GlobalEventHandlers, ev: SubmitEvent) => any) | null;
+            onsuspend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            ontimeupdate: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            ontoggle: ((this: GlobalEventHandlers, ev: ToggleEvent) => any) | null;
+            ontouchcancel?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+            ontouchend?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+            ontouchmove?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+            ontouchstart?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+            ontransitioncancel: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+            ontransitionend: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+            ontransitionrun: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+            ontransitionstart: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+            onvolumechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onwaiting: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onwebkitanimationend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onwebkitanimationiteration: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onwebkitanimationstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onwebkittransitionend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+            onwheel: ((this: GlobalEventHandlers, ev: WheelEvent) => any) | null;
+            autofocus: boolean;
+            readonly dataset: DOMStringMap;
+            nonce: string;
+            tabIndex: number;
+            blur: () => void;
+            focus: (options?: FocusOptions) => void;
+        };
     }>;
-    private canvasRef;
     rendererStore: Store<RendererStore>;
     figureRendererStore: Store<FigureRendererStore>;
     setup(): void;
     private loadImages;
+    get carouselDataViews(): PropsOf<CarouselDataViewPrint>[];
 }

package/dist/types/components/standalone_viewport/standalone_viewport.d.ts

@@ -1,6 +1,7 @@
 import { Component } from "../../owl3_compatibility_layer";
 import { RendererStore } from "../../stores/renderer_store";
 import { ViewportsStore } from "../../stores/viewports_store";
+import { ZoomStore } from "../../stores/zoom_store";
 import { HeaderIndex } from "../../types/misc";
 import { Rect } from "../../types/rendering";
 import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
@@ -28,7 +29,10 @@ export declare class StandaloneViewport extends Component<SpreadsheetChildEnv> {
     protected props: import("@odoo/owl").PropsWithDefaults<{
         range: import("../..").Range;
         canResizeColumns: boolean;
-        zoomLevel: number;
+        size: {
+            width: import("../..").Pixel;
+            height: import("../..").Pixel;
+        };
         onResizeColumns?: ((columnWeights: number[] | undefined) => void) | undefined;
         columnWeights?: number[] | undefined;
     }, "canResizeColumns">;
@@ -39,11 +43,11 @@ export declare class StandaloneViewport extends Component<SpreadsheetChildEnv> {
     onMouseWheel: (ev: WheelEvent) => void;
     rendererStore: Store<RendererStore>;
     viewStore: Store<ViewportsStore>;
+    zoomStore: Store<ZoomStore>;
     cellPopoverStore: Store<CellPopoverStore>;
     setup(): void;
-    get containerWidth(): number;
-    get containerHeight(): number;
-    get hasVerticalScrollBar(): boolean | 0;
+    get contentWidth(): number;
+    get hasVerticalScrollBar(): boolean;
     get scrollBarContainerStyle(): string;
     onCellDoubleClicked(col: HeaderIndex, row: HeaderIndex, ev: MouseEvent): void;
     get gridOverlayDimensions(): string;

package/dist/types/components/standalone_viewport/standalone_viewport_store.d.ts

@@ -1,6 +1,6 @@
 import { SpreadsheetStore } from "../../stores/spreadsheet_store";
 import { Command } from "../../types/commands";
-import { HeaderDimensions, HeaderIndex, UID } from "../../types/misc";
+import { CellPosition, HeaderDimensions, HeaderIndex, UID } from "../../types/misc";
 import { Range } from "../../types/range";
 import { GridRenderingContext } from "../../types/rendering";
 import { Get } from "../../types/store_engine";
@@ -25,4 +25,5 @@ export declare class StandaloneViewportStore extends SpreadsheetStore {
     get columnWeights(): number[];
     private computeColDimensions;
     private normalizeWeights;
+    getHighlightedPositions(position: CellPosition): CellPosition[];
 }

package/dist/types/components/tables/hovered_table_store.d.ts

@@ -1,11 +1,10 @@
-import { PositionMap } from "../../helpers/cells/position_map";
 import { SpreadsheetStore } from "../../stores/spreadsheet_store";
-import { CellPosition, Color } from "../../types/misc";
+import { CellPosition } from "../../types/misc";
+import { Get } from "../../types/store_engine";
 export declare class HoveredTableStore extends SpreadsheetStore {
-    mutators: readonly ["clear", "hover"];
+    mutators: readonly ["hover"];
+    storeGetters: readonly ["getCellHoverOverlayColor"];
     position: CellPosition | undefined;
-    overlayColors: PositionMap<Color>;
-    hover(position: CellPosition | undefined): "noStateChange" | undefined;
-    clear(): void;
-    private computeOverlay;
+    constructor(get: Get);
+    getHighlightedPositions(hoveredPosition: CellPosition): CellPosition[];
 }

package/dist/types/components/tables/table_resizer/table_resizer.d.ts

@@ -17,6 +17,7 @@ export declare class TableResizer extends Component<SpreadsheetChildEnv> {
         }, onPointerMove: (col: HeaderIndex, row: HeaderIndex, ev: MouseEvent) => void, onPointerUp: () => void, startScrollDirection?: import("../../helpers/drag_and_drop_grid_hook").DnDDirection) => void;
     };
     private viewStore;
+    private zoomStore;
     setup(): void;
     get containerStyle(): string;
     onMouseDown(ev: PointerEvent): void;

package/dist/types/components/tables/table_styles_popover/table_styles_popover.d.ts

@@ -36,7 +36,6 @@ export declare class TableStylesPopover extends Component<SpreadsheetChildEnv> {
             zIndex?: number | undefined;
             class?: string | undefined;
             anchorRect: import("../../..").Rect;
-            containerRect?: {} | undefined;
             positioning?: "top-right" | "bottom-left" | undefined;
             verticalOffset?: number | undefined;
             onMouseWheel?: (() => void) | undefined;

package/dist/types/components/top_bar/color_editor/color_editor.d.ts

@@ -9,7 +9,7 @@ export declare class TopBarColorEditor extends Component<SpreadsheetChildEnv> {
     static template: string;
     protected props: import("@odoo/owl").Props<{
         class: string;
-        style: "textColor" | "fillColor";
+        style: "fillColor" | "textColor";
         icon: string;
         title: string;
     }>;

package/dist/types/components/top_bar/zoom_editor/zoom_editor.d.ts

@@ -11,7 +11,7 @@ export declare class ToolBarZoom extends Component<SpreadsheetChildEnv> {
         class: string;
     }>;
     topBarToolStore: ToolBarDropdownStore;
-    private viewStore;
+    private zoomStore;
     valueList: number[];
     setup(): void;
     get currentFontSize(): number;

package/dist/types/constants.d.ts

@@ -12,6 +12,7 @@ export declare const FROZEN_PANE_BORDER_COLOR = "#DADFE8";
 export declare const COMPOSER_ASSISTANT_COLOR = "light-dark(#9B359B, #B972A6)";
 export declare const COLOR_TRANSPARENT = "#00000000";
 export declare const TABLE_HOVER_BACKGROUND_COLOR = "#017E8414";
+export declare const DEFAULT_CHART_BACKGROUND_COLOR = "#FFFFFF";
 export declare const CHART_WATERFALL_POSITIVE_COLOR = "#4EA7F2";
 export declare const CHART_WATERFALL_NEGATIVE_COLOR = "#EA6175";
 export declare const CHART_WATERFALL_SUBTOTAL_COLOR = "#AAAAAA";
@@ -64,6 +65,9 @@ export declare const MENU_SEPARATOR_BORDER_WIDTH = 1;
 export declare const MENU_SEPARATOR_PADDING = 5;
 export declare const MENU_SEPARATOR_HEIGHT: number;
 export declare const ZOOM_VALUES: number[];
+export declare const MIN_ZOOM = 0.5;
+export declare const MAX_ZOOM = 2;
+export declare const DEFAULT_ZOOM = 1;
 export declare const DEFAULT_STYLE: {
     align: "default";
     verticalAlign: "bottom";
@@ -96,7 +100,7 @@ export declare const DEFAULT_NUMBER_STYLE: {
 export declare const DEFAULT_VERTICAL_ALIGN: "bottom";
 export declare const DEFAULT_WRAPPING_MODE: "overflow";
 export declare const DEFAULT_TEXT_HIGHLIGHT_PERCENT = 0.25;
-export declare const DEFAULT_FONT_WEIGHT = "400";
+export declare const DEFAULT_FONT_WEIGHT = 400;
 export declare const DEFAULT_FONT_SIZE: number;
 export declare const HEADER_FONT_SIZE = 11;
 export declare const DEFAULT_FONT = "'Roboto', arial, 'Liberation Sans'";
@@ -106,9 +110,10 @@ export declare const MAX_HISTORY_STEPS = 99;
 export declare const DEFAULT_REVISION_ID = "START_REVISION";
 export declare const DEFAULT_FIGURE_HEIGHT = 335;
 export declare const DEFAULT_FIGURE_WIDTH = 536;
+export declare const DEFAULT_SCORECARD_HEIGHT = 101;
+export declare const DEFAULT_SCORECARD_WIDTH = 213;
 export declare const FIGURE_BORDER_WIDTH = 1;
 export declare const ACTIVE_BORDER_WIDTH = 2;
-export declare const MIN_FIG_SIZE = 80;
 export declare const MAX_CHAR_LABEL = 20;
 export declare const FIGURE_ID_SPLITTER = "??";
 export declare const DEFAULT_GAUGE_LOWER_COLOR = "#EA6175";
@@ -122,6 +127,7 @@ export declare const DEFAULT_SCORECARD_BASELINE_FONT_SIZE = 16;
 export declare const LINE_FILL_TRANSPARENCY = 0.4;
 export declare const LINE_DATA_POINT_RADIUS = 3;
 export declare const DEFAULT_WINDOW_SIZE = 2;
+export declare const MAX_CHART_PREVIEW_DATA_POINTS = 20;
 export declare const MESSAGE_VERSION = 1;
 export declare const FORBIDDEN_SHEETNAME_CHARS: readonly ["'", "*", "?", "/", "\\", "[", "]"];
 export declare const FORBIDDEN_SHEETNAME_CHARS_IN_EXCEL_REGEX: RegExp;
@@ -158,6 +164,14 @@ export declare const DEFAULT_CAROUSEL_TITLE_STYLE: {
     fontSize: number;
     color: string;
 };
+export declare const CAROUSEL_LAYOUT: {
+    readonly paddingX: 24;
+    readonly paddingY: 8;
+    readonly headerPaddingTop: 4;
+    readonly separatorWidth: 1;
+    readonly headerLineHeight: 1.5;
+    readonly minHeaderHeight: 25;
+};
 export declare const DEFAULT_TOKEN_COLOR: Color;
 export declare const tokenColors: {
     readonly OPERATOR: "#3da4ab";
@@ -171,3 +185,4 @@ export declare const tokenColors: {
     readonly ORPHAN_RIGHT_PAREN: "#ff0000";
 };
 export declare const DRAG_THRESHOLD = 5;
+export declare const PRINT_DPR = 3;

package/dist/types/formulas/compiler.d.ts

@@ -1,5 +1,5 @@
-import { CoreGetters } from "../types/core_getters";
 import { ComputeFunction } from "../types/functions";
+import { CoreGetters } from "../types/getters";
 import { ApplyRangeChange, ApplyRenameNamedRange, FormulaToExecute, LiteralValues, NamedRange, UID } from "../types/misc";
 import { Range, RangeStringOptions } from "../types/range";
 import { AST } from "./parser";

package/dist/types/functions/function_registry.d.ts

@@ -5,3 +5,6 @@ export declare class FunctionRegistry extends Registry<FunctionDescription> {
     replace(name: string, addDescr: AddFunctionDescription): this;
 }
 export declare const functionRegistry: FunctionRegistry;
+/** Formulas using one of these functions are never squished: they are always exported
+ * as a full formula string, and they don't become the base formula of the next cells. */
+export declare const NonSquishableFunctionRegistry: Registry<string>;

package/dist/types/functions/helper_lookup.d.ts

@@ -1,5 +1,5 @@
-import { CoreGetters } from "../types/core_getters";
 import { EvalContext } from "../types/functions";
+import { CoreGetters } from "../types/getters";
 import { FunctionResultObject, Maybe, UID } from "../types/misc";
 import { PivotCoreMeasure } from "../types/pivot";
 /**

package/dist/types/functions/helpers.d.ts

@@ -17,6 +17,10 @@ export declare function strictToNumber(data: FunctionResultObject | CellValue |
 export declare function toInteger(value: FunctionResultObject | CellValue | undefined, locale: Locale): number;
 export declare function strictToInteger(value: FunctionResultObject | CellValue | undefined, locale: Locale): number;
 export declare function toString(data: FunctionResultObject | CellValue | undefined): string;
+/**
+ * Only converts the decimal separator, ignore number format such as % or dates
+ */
+export declare function toLocaleString(data: FunctionResultObject | CellValue | undefined, locale: Locale): string;
 /**
  * Normalize range by setting all the string in the range to lowercase and replacing
  * accent letters with plain letters

package/dist/types/functions/module_operators.d.ts

@@ -8,7 +8,7 @@ export declare const ADD: {
 export declare const CONCAT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => {
+    compute: (this: import("..").EvalContext, value1: Maybe<FunctionResultObject>, value2: Maybe<FunctionResultObject>) => {
         value: string;
     };
     isExported: true;