@odoo/o-spreadsheet 18.0.55 → 18.0.68

package/dist/types/helpers/figures/charts/pyramid_chart.d.ts

@@ -0,0 +1,32 @@
+import { AddColumnsRowsCommand, ApplyRangeChange, Color, CommandResult, CoreGetters, Getters, Range, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { AxesDesign, ChartCreationContext, DataSet, DatasetDesign, ExcelChartDefinition } from "../../../types/chart/chart";
+import { LegendPosition } from "../../../types/chart/common_chart";
+import { PyramidChartDefinition, PyramidChartRuntime } from "../../../types/chart/pyramid_chart";
+import { Validator } from "../../../types/validator";
+import { AbstractChart } from "./abstract_chart";
+export declare class PyramidChart extends AbstractChart {
+    readonly dataSets: DataSet[];
+    readonly labelRange?: Range | undefined;
+    readonly background?: Color;
+    readonly legendPosition: LegendPosition;
+    readonly aggregated?: boolean;
+    readonly type = "pyramid";
+    readonly dataSetsHaveTitle: boolean;
+    readonly dataSetDesign?: DatasetDesign[];
+    readonly axesDesign?: AxesDesign;
+    readonly horizontal = true;
+    readonly stacked = true;
+    readonly showValues?: boolean;
+    constructor(definition: PyramidChartDefinition, sheetId: UID, getters: CoreGetters);
+    static transformDefinition(definition: PyramidChartDefinition, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): PyramidChartDefinition;
+    static validateChartDefinition(validator: Validator, definition: PyramidChartDefinition): CommandResult | CommandResult[];
+    static getDefinitionFromContextCreation(context: ChartCreationContext): PyramidChartDefinition;
+    getContextCreation(): ChartCreationContext;
+    copyForSheetId(sheetId: UID): PyramidChart;
+    copyInSheetId(sheetId: UID): PyramidChart;
+    getDefinition(): PyramidChartDefinition;
+    private getDefinitionWithSpecificDataSets;
+    getDefinitionForExcel(): ExcelChartDefinition | undefined;
+    updateRanges(applyChange: ApplyRangeChange): PyramidChart;
+}
+export declare function createPyramidChartRuntime(chart: PyramidChart, getters: Getters): PyramidChartRuntime;

package/dist/types/helpers/figures/charts/scatter_chart.d.ts

@@ -0,0 +1,31 @@
+import { AddColumnsRowsCommand, ApplyRangeChange, Color, CommandResult, CoreGetters, Getters, Range, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { AxesDesign, ChartCreationContext, DataSet, DatasetDesign, ExcelChartDefinition } from "../../../types/chart/chart";
+import { LegendPosition } from "../../../types/chart/common_chart";
+import { ScatterChartDefinition, ScatterChartRuntime } from "../../../types/chart/scatter_chart";
+import { Validator } from "../../../types/validator";
+import { AbstractChart } from "./abstract_chart";
+export declare class ScatterChart extends AbstractChart {
+    readonly dataSets: DataSet[];
+    readonly labelRange?: Range | undefined;
+    readonly background?: Color;
+    readonly legendPosition: LegendPosition;
+    readonly labelsAsText: boolean;
+    readonly aggregated?: boolean;
+    readonly type = "scatter";
+    readonly dataSetsHaveTitle: boolean;
+    readonly dataSetDesign?: DatasetDesign[];
+    readonly axesDesign?: AxesDesign;
+    readonly showValues?: boolean;
+    constructor(definition: ScatterChartDefinition, sheetId: UID, getters: CoreGetters);
+    static validateChartDefinition(validator: Validator, definition: ScatterChartDefinition): CommandResult | CommandResult[];
+    static transformDefinition(definition: ScatterChartDefinition, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): ScatterChartDefinition;
+    static getDefinitionFromContextCreation(context: ChartCreationContext): ScatterChartDefinition;
+    getDefinition(): ScatterChartDefinition;
+    private getDefinitionWithSpecificDataSets;
+    getContextCreation(): ChartCreationContext;
+    updateRanges(applyChange: ApplyRangeChange): ScatterChart;
+    getDefinitionForExcel(): ExcelChartDefinition | undefined;
+    copyForSheetId(sheetId: UID): ScatterChart;
+    copyInSheetId(sheetId: UID): ScatterChart;
+}
+export declare function createScatterChartRuntime(chart: ScatterChart, getters: Getters): ScatterChartRuntime;

package/dist/types/helpers/figures/charts/scorecard_chart.d.ts

@@ -0,0 +1,32 @@
+import { AddColumnsRowsCommand, ApplyRangeChange, Color, CommandResult, CoreGetters, Getters, Range, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { ChartCreationContext } from "../../../types/chart/chart";
+import { BaselineMode, ScorecardChartDefinition, ScorecardChartRuntime } from "../../../types/chart/scorecard_chart";
+import { Validator } from "../../../types/validator";
+import { AbstractChart } from "./abstract_chart";
+import { ScorecardChartConfig } from "./scorecard_chart_config_builder";
+export declare class ScorecardChart extends AbstractChart {
+    readonly keyValue?: Range;
+    readonly baseline?: Range;
+    readonly baselineMode: BaselineMode;
+    readonly baselineDescr?: string;
+    readonly progressBar: boolean;
+    readonly background?: Color;
+    readonly baselineColorUp: Color;
+    readonly baselineColorDown: Color;
+    readonly fontColor?: Color;
+    readonly humanize?: boolean;
+    readonly type = "scorecard";
+    constructor(definition: ScorecardChartDefinition, sheetId: UID, getters: CoreGetters);
+    static validateChartDefinition(validator: Validator, definition: ScorecardChartDefinition): CommandResult | CommandResult[];
+    static getDefinitionFromContextCreation(context: ChartCreationContext): ScorecardChartDefinition;
+    static transformDefinition(definition: ScorecardChartDefinition, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): ScorecardChartDefinition;
+    copyForSheetId(sheetId: UID): ScorecardChart;
+    copyInSheetId(sheetId: UID): ScorecardChart;
+    getDefinition(): ScorecardChartDefinition;
+    getContextCreation(): ChartCreationContext;
+    private getDefinitionWithSpecificRanges;
+    getDefinitionForExcel(): undefined;
+    updateRanges(applyChange: ApplyRangeChange): ScorecardChart;
+}
+export declare function drawScoreChart(structure: ScorecardChartConfig, canvas: HTMLCanvasElement): void;
+export declare function createScorecardChartRuntime(chart: ScorecardChart, getters: Getters): ScorecardChartRuntime;

package/dist/types/helpers/figures/charts/scorecard_chart_config_builder.d.ts

@@ -0,0 +1,44 @@
+import { Color } from "chart.js";
+import { DOMDimension, Pixel, PixelPosition } from "../../../types";
+import { BaselineArrowDirection, ScorecardChartRuntime } from "../../../types/chart";
+type ScorecardChartElement = {
+    text: string;
+    style: {
+        font: string;
+        color: Color;
+        strikethrough?: boolean;
+        underline?: boolean;
+    };
+    position: PixelPosition;
+};
+export type ScorecardChartConfig = {
+    canvas: {
+        width: number;
+        height: number;
+        backgroundColor: Color;
+    };
+    title?: ScorecardChartElement;
+    baselineArrow?: {
+        direction: BaselineArrowDirection;
+        style: {
+            size: Pixel;
+            color: Color;
+        };
+        position: PixelPosition;
+    };
+    baseline?: ScorecardChartElement;
+    baselineDescr?: ScorecardChartElement[];
+    key?: ScorecardChartElement;
+    progressBar?: {
+        position: PixelPosition;
+        dimension: DOMDimension;
+        style: {
+            color: Color;
+            backgroundColor: Color;
+        };
+        value: number;
+    };
+};
+export declare function formatBaselineDescr(baselineDescr: string | undefined, baseline: string | undefined): string;
+export declare function getScorecardConfiguration({ width, height }: DOMDimension, runtime: ScorecardChartRuntime): ScorecardChartConfig;
+export {};

package/dist/types/helpers/figures/charts/waterfall_chart.d.ts

@@ -0,0 +1,37 @@
+import { AddColumnsRowsCommand, ApplyRangeChange, Color, CommandResult, CoreGetters, Getters, Range, RemoveColumnsRowsCommand, UID } from "../../../types";
+import { AxesDesign, ChartCreationContext, CustomizedDataSet, DataSet, ExcelChartDefinition } from "../../../types/chart/chart";
+import { LegendPosition, VerticalAxisPosition } from "../../../types/chart/common_chart";
+import { WaterfallChartDefinition, WaterfallChartRuntime } from "../../../types/chart/waterfall_chart";
+import { Validator } from "../../../types/validator";
+import { AbstractChart } from "./abstract_chart";
+export declare class WaterfallChart extends AbstractChart {
+    readonly dataSets: DataSet[];
+    readonly labelRange?: Range | undefined;
+    readonly background?: Color;
+    readonly verticalAxisPosition: VerticalAxisPosition;
+    readonly legendPosition: LegendPosition;
+    readonly aggregated?: boolean;
+    readonly type = "waterfall";
+    readonly dataSetsHaveTitle: boolean;
+    readonly showSubTotals: boolean;
+    readonly firstValueAsSubtotal?: boolean;
+    readonly showConnectorLines: boolean;
+    readonly positiveValuesColor?: Color;
+    readonly negativeValuesColor?: Color;
+    readonly subTotalValuesColor?: Color;
+    readonly dataSetDesign: CustomizedDataSet[];
+    readonly axesDesign?: AxesDesign;
+    readonly showValues?: boolean;
+    constructor(definition: WaterfallChartDefinition, sheetId: UID, getters: CoreGetters);
+    static transformDefinition(definition: WaterfallChartDefinition, executed: AddColumnsRowsCommand | RemoveColumnsRowsCommand): WaterfallChartDefinition;
+    static validateChartDefinition(validator: Validator, definition: WaterfallChartDefinition): CommandResult | CommandResult[];
+    static getDefinitionFromContextCreation(context: ChartCreationContext): WaterfallChartDefinition;
+    getContextCreation(): ChartCreationContext;
+    copyForSheetId(sheetId: UID): WaterfallChart;
+    copyInSheetId(sheetId: UID): WaterfallChart;
+    getDefinition(): WaterfallChartDefinition;
+    private getDefinitionWithSpecificDataSets;
+    getDefinitionForExcel(): ExcelChartDefinition | undefined;
+    updateRanges(applyChange: ApplyRangeChange): WaterfallChart;
+}
+export declare function createWaterfallChartRuntime(chart: WaterfallChart, getters: Getters): WaterfallChartRuntime;

package/dist/types/helpers/figures/figure/figure.d.ts

@@ -0,0 +1,6 @@
+import { FigureSize, Getters } from "../../../types";
+export declare function centerFigurePosition(getters: Getters, size: FigureSize): {
+    x: number;
+    y: number;
+};
+export declare function getMaxFigureSize(getters: Getters, figureSize: FigureSize): FigureSize;

package/dist/types/helpers/figures/images/image_provider.d.ts

@@ -0,0 +1,10 @@
+import { FigureSize } from "../../../types";
+import { FileStore, ImageProviderInterface } from "../../../types/files";
+import { type Image } from "../../../types/image";
+export declare class ImageProvider implements ImageProviderInterface {
+    private fileStore;
+    constructor(fileStore: FileStore);
+    requestImage(): Promise<Image>;
+    private getImageFromUser;
+    getImageOriginalSize(path: string): Promise<FigureSize>;
+}

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

@@ -0,0 +1,45 @@
+import { CellValue, Currency, Format, FormattedValue, FunctionResultObject, Locale, LocaleFormat, Maybe } from "../../types";
+export declare const MONTHS: Readonly<Record<number, string>>;
+export declare const DAYS: Readonly<Record<number, string>>;
+interface FormatWidth {
+    availableWidth: number;
+    measureText: (text: string) => number;
+}
+/**
+ * Formats a cell value with its format.
+ */
+export declare function formatValue(value: CellValue, { format, locale, formatWidth }: LocaleFormat & {
+    formatWidth?: FormatWidth;
+}): FormattedValue;
+/** Convert a number into a string, without scientific notation */
+export declare function numberToString(number: number, decimalSeparator: string): string;
+/**
+ * Check if the given format is a time, date or date time format. Only check the first part of a multi-part format.
+ */
+export declare const isDateTimeFormat: (format: Format) => boolean;
+/**
+ * Get a regex matching decimal number based on the locale's thousand separator
+ *
+ * eg. if the locale's thousand separator is a comma, this will return a regex /[0-9]+,[0-9]/
+ */
+export declare const getDecimalNumberRegex: (locale: Locale) => RegExp;
+/**
+ * Create a default format for a number.
+ *
+ * If possible this will try round the number to have less than DEFAULT_FORMAT_NUMBER_OF_DIGITS characters
+ * in the number. This is obviously only possible for number with a big decimal part. For number with a lot
+ * of digits in the integer part, keep the number as it is.
+ */
+export declare function createDefaultFormat(value: number): Format;
+export declare function detectDateFormat(content: string, locale: Locale): Format | undefined;
+/** use this function only if the content corresponds to a number (means that isNumber(content) return true */
+export declare function detectNumberFormat(content: string): Format | undefined;
+export declare function createCurrencyFormat(currency: Partial<Currency>): Format;
+export declare function createAccountingFormat(currency: Partial<Currency>): Format;
+export declare function roundFormat(format: Format): Format;
+export declare function humanizeNumber({ value, format }: FunctionResultObject, locale: Locale): string;
+export declare function formatLargeNumber(arg: Maybe<FunctionResultObject>, unit: Maybe<FunctionResultObject>, locale: Locale): string;
+export declare function changeDecimalPlaces(format: Format, step: number): Format;
+export declare function isExcelCompatible(format: Format): boolean;
+export declare function isTextFormat(format: Format | undefined): boolean;
+export {};

package/dist/types/helpers/format/format_parser.d.ts

@@ -0,0 +1,38 @@
+import { Format } from "../../types";
+import { CharToken, DatePartToken, DigitToken, PercentToken, RepeatCharToken, StringToken, TextPlaceholderToken, ThousandsSeparatorToken } from "./format_tokenizer";
+/**
+ *  Constant used to indicate the maximum of digits that is possible to display
+ *  in a cell with standard size.
+ */
+export declare const MAX_DECIMAL_PLACES = 20;
+export interface MultiPartInternalFormat {
+    positive: NumberInternalFormat | DateInternalFormat | TextInternalFormat;
+    negative?: NumberInternalFormat | DateInternalFormat;
+    zero?: NumberInternalFormat | DateInternalFormat;
+    text?: TextInternalFormat;
+}
+export interface DateInternalFormat {
+    type: "date";
+    tokens: (DatePartToken | StringToken | CharToken | RepeatCharToken)[];
+}
+export interface NumberInternalFormat {
+    type: "number";
+    readonly integerPart: (DigitToken | StringToken | CharToken | PercentToken | ThousandsSeparatorToken | RepeatCharToken)[];
+    readonly percentSymbols: number;
+    readonly thousandsSeparator: boolean;
+    /** A thousand separator after the last digit in the format means that we divide the number by a thousand */
+    readonly magnitude: number;
+    /**
+     * optional because we need to differentiate a number
+     * with a dot but no decimals with a number without any decimals.
+     * i.e. '5.'  !=== '5' !=== '5.0'
+     */
+    readonly decimalPart?: (DigitToken | StringToken | CharToken | PercentToken | ThousandsSeparatorToken | RepeatCharToken)[];
+}
+export interface TextInternalFormat {
+    type: "text";
+    tokens: (StringToken | CharToken | TextPlaceholderToken | RepeatCharToken)[];
+}
+export type InternalFormat = NumberInternalFormat | DateInternalFormat | TextInternalFormat;
+export declare function parseFormat(formatString: Format): MultiPartInternalFormat;
+export declare function convertInternalFormatToFormat(internalFormat: MultiPartInternalFormat): Format;

package/dist/types/helpers/format/format_tokenizer.d.ts

@@ -0,0 +1,39 @@
+export interface DigitToken {
+    type: "DIGIT";
+    value: "0" | "#";
+}
+export interface DecimalPointToken {
+    type: "DECIMAL_POINT";
+    value: ".";
+}
+export interface StringToken {
+    type: "STRING";
+    value: string;
+}
+export interface CharToken {
+    type: "CHAR";
+    value: string;
+}
+export interface PercentToken {
+    type: "PERCENT";
+    value: "%";
+}
+export interface ThousandsSeparatorToken {
+    type: "THOUSANDS_SEPARATOR";
+    value: ",";
+}
+export interface TextPlaceholderToken {
+    type: "TEXT_PLACEHOLDER";
+    value: "@";
+}
+export interface DatePartToken {
+    type: "DATE_PART";
+    value: string;
+}
+export interface RepeatCharToken {
+    type: "REPEATED_CHAR";
+    value: string;
+}
+export type FormatToken = DigitToken | DecimalPointToken | StringToken | CharToken | PercentToken | ThousandsSeparatorToken | TextPlaceholderToken | DatePartToken | RepeatCharToken;
+export declare function tokenizeFormat(str: string): FormatToken[][];
+export declare const alwaysEscapedCharsInFormat: Set<string>;

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

@@ -0,0 +1,17 @@
+export * from "./color";
+export * from "./coordinates";
+export * from "./data_normalization";
+export * from "./data_validation_helpers";
+export * from "./dates";
+export * from "./edge_scrolling";
+export * from "./format/format";
+export * from "./misc";
+export * from "./numbers";
+export * from "./range";
+export * from "./recompute_zones";
+export * from "./references";
+export * from "./search";
+export * from "./sheet";
+export * from "./text_helper";
+export * from "./uuid";
+export * from "./zones";

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

@@ -0,0 +1,82 @@
+import { DOMCoordinates, DOMDimension, Getters, HeaderIndex, Pixel, Position, Rect, UID, Zone } from "../types";
+export declare class InternalViewport {
+    private getters;
+    private sheetId;
+    private boundaries;
+    top: HeaderIndex;
+    bottom: HeaderIndex;
+    left: HeaderIndex;
+    right: HeaderIndex;
+    offsetX: Pixel;
+    offsetY: Pixel;
+    offsetScrollbarX: Pixel;
+    offsetScrollbarY: Pixel;
+    canScrollVertically: boolean;
+    canScrollHorizontally: boolean;
+    viewportWidth: Pixel;
+    viewportHeight: Pixel;
+    offsetCorrectionX: Pixel;
+    offsetCorrectionY: Pixel;
+    constructor(getters: Getters, sheetId: UID, boundaries: Zone, sizeInGrid: DOMDimension, options: {
+        canScrollVertically: boolean;
+        canScrollHorizontally: boolean;
+    }, offsets: DOMCoordinates);
+    /** Returns the maximum size (in Pixels) of the viewport relative to its allocated client size
+     * When the viewport grid size is smaller than its client width (resp. height), it will return
+     * the client width (resp. height).
+     */
+    getMaxSize(): DOMDimension;
+    /**
+     * Return the index of a column given an offset x, based on the pane left
+     * visible cell.
+     * It returns -1 if no column is found.
+     */
+    getColIndex(x: Pixel): HeaderIndex;
+    /**
+     * Return the index of a row given an offset y, based on the pane top
+     * visible cell.
+     * It returns -1 if no row is found.
+     */
+    getRowIndex(y: Pixel): HeaderIndex;
+    /**
+     * This function will make sure that the provided cell position (or current selected position) is part of
+     * the pane that is actually displayed on the client. We therefore adjust the offset of the pane
+     * until it contains the cell completely.
+     */
+    adjustPosition(position: Position): void;
+    private adjustPositionX;
+    private adjustPositionY;
+    willNewOffsetScrollViewport(offsetX: Pixel, offsetY: Pixel): boolean;
+    setViewportOffset(offsetX: Pixel, offsetY: Pixel): void;
+    adjustViewportZone(): void;
+    /**
+     *
+     * Computes the visible coordinates & dimensions of a given zone inside the viewport
+     *
+     */
+    getVisibleRect(zone: Zone): Rect | undefined;
+    /**
+     *
+     * @returns Computes the absolute coordinates & dimensions of a given zone inside the viewport
+     *
+     */
+    getFullRect(zone: Zone): Rect | undefined;
+    isVisible(col: HeaderIndex, row: HeaderIndex): boolean;
+    private searchHeaderIndex;
+    private setViewportOffsetX;
+    private setViewportOffsetY;
+    /** Corrects the viewport's horizontal offset based on the current structure
+     *  To make sure that at least one column is visible inside the viewport.
+     */
+    private adjustViewportOffsetX;
+    /** Corrects the viewport's vertical offset based on the current structure
+     *  To make sure that at least one row is visible inside the viewport.
+     */
+    private adjustViewportOffsetY;
+    /** Updates the pane zone and snapped offset based on its horizontal
+     * offset (will find Left) and its width (will find Right) */
+    private adjustViewportZoneX;
+    /** Updates the pane zone and snapped offset based on its vertical
+     * offset (will find Top) and its width (will find Bottom) */
+    private adjustViewportZoneY;
+}

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

@@ -0,0 +1,2 @@
+import { CoreCommand } from "../types";
+export declare function inverseCommand(cmd: CoreCommand): CoreCommand[];

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

@@ -0,0 +1,23 @@
+import { Registry } from "../registries/registry";
+import { CellValue, Getters, Link, SpreadsheetChildEnv } from "../types";
+/**
+ * Add the `https` prefix to the url if it's missing
+ */
+export declare function withHttps(url: string): string;
+export interface LinkSpec {
+    readonly match: (url: string) => boolean;
+    readonly createLink: (url: string, label: string) => Link;
+    /**
+     * String used to display the URL in components.
+     * Particularly useful for special links (sheet, etc.)
+     * - a simple web link displays the raw url
+     * - a link to a sheet displays the sheet name
+     */
+    readonly urlRepresentation: (url: string, getters: Getters) => string;
+    readonly open: (url: string, env: SpreadsheetChildEnv) => void;
+    readonly sequence: number;
+}
+export declare const urlRegistry: Registry<LinkSpec>;
+export declare function urlRepresentation(link: Link, getters: Getters): string;
+export declare function openLink(link: Link, env: SpreadsheetChildEnv): void;
+export declare function detectLink(value: CellValue | null): Link | undefined;

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

@@ -0,0 +1,58 @@
+import { ConditionalFormatRule, DataValidationRule, Locale } from "../types";
+export declare function isValidLocale(locale: any): locale is Locale;
+/**
+ * Change a content string from the given locale to its canonical form (en_US locale). Don't convert date string.
+ *
+ * @example
+ * canonicalizeNumberContent("=SUM(1,5; 02/12/2012)", FR_LOCALE) // "=SUM(1.5, 02/12/2012)"
+ * canonicalizeNumberContent("125,9", FR_LOCALE) // "125.9"
+ * canonicalizeNumberContent("02/12/2012", FR_LOCALE) // "02/12/2012"
+ */
+export declare function canonicalizeNumberContent(content: string, locale: Locale): string;
+/**
+ * Change a content string from the given locale to its canonical form (en_US locale). Also convert date string.
+ * This is destructive and won't preserve the original format.
+ *
+ * @example
+ * canonicalizeContent("=SUM(1,5; 5)", FR_LOCALE) // "=SUM(1.5, 5)"
+ * canonicalizeContent("125,9", FR_LOCALE) // "125.9"
+ * canonicalizeContent("02/12/2012", FR_LOCALE) // "12/02/2012"
+ * canonicalizeContent("02-12-2012", FR_LOCALE) // "12/02/2012"
+ */
+export declare function canonicalizeContent(content: string, locale: Locale): string;
+/**
+ * Change a content string from its canonical form (en_US locale) to the given locale. Don't convert date string.
+ * This is destructive and won't preserve the original format.
+ *
+ * @example
+ * localizeNumberContent("=SUM(1.5, 5)", FR_LOCALE) // "=SUM(1,5; 5)"
+ * localizeNumberContent("125.9", FR_LOCALE) // "125,9"
+ * localizeNumberContent("02/12/2012", FR_LOCALE) // "12/02/2012"
+ * localizeNumberContent("02-12-2012", FR_LOCALE) // "12/02/2012"
+ */
+export declare function localizeNumberContent(content: string, locale: Locale): string;
+/**
+ * Change a content string from its canonical form (en_US locale) to the given locale. Also convert date string.
+ *
+ * @example
+ * localizeContent("=SUM(1.5, 5)", FR_LOCALE) // "=SUM(1,5; 5)"
+ * localizeContent("125.9", FR_LOCALE) // "125,9"
+ * localizeContent("12/02/2012", FR_LOCALE) // "02/12/2012"
+ */
+export declare function localizeContent(content: string, locale: Locale): string;
+/** Change a number string to its canonical form (en_US locale) */
+export declare function canonicalizeNumberValue(content: string, locale: Locale): string;
+/** Change a formula from the canonical form to the given locale */
+export declare function localizeFormula(formula: string, locale: Locale): string;
+/**
+ * Change a literal string from the given locale to its canonical form (en_US locale). Don't convert date string.
+ *
+ * @example
+ * canonicalizeNumberLiteral("125,9", FR_LOCALE) // "125.9"
+ * canonicalizeNumberLiteral("02/12/2012", FR_LOCALE) // "02/12/2012"
+ */
+export declare function canonicalizeNumberLiteral(content: string, locale: Locale): string;
+export declare function canonicalizeCFRule(cf: ConditionalFormatRule, locale: Locale): ConditionalFormatRule;
+export declare function localizeCFRule(cf: ConditionalFormatRule, locale: Locale): ConditionalFormatRule;
+export declare function localizeDataValidationRule(rule: DataValidationRule, locale: Locale): DataValidationRule;
+export declare function getDateTimeFormat(locale: Locale): string;