@univerjs/engine-formula 0.4.1 → 0.4.2

package/lib/types/basics/database.d.ts

@@ -0,0 +1,31 @@
+import { BaseValueObject, ErrorValueObject } from '../engine/value-object/base-value-object';
+type DatabaseValueType = string | number | null;
+export declare function checkDatabase(database: BaseValueObject): {
+    isError: boolean;
+    errorObject: ErrorValueObject;
+    databaseValues: DatabaseValueType[][];
+} | {
+    isError: boolean;
+    errorObject: null;
+    databaseValues: DatabaseValueType[][];
+};
+export declare function checkField(field: BaseValueObject, database: DatabaseValueType[][]): {
+    isError: boolean;
+    errorObject: ErrorValueObject;
+    fieldIndex: number;
+} | {
+    isError: boolean;
+    errorObject: null;
+    fieldIndex: number;
+};
+export declare function checkCriteria(criteria: BaseValueObject): {
+    isError: boolean;
+    errorObject: ErrorValueObject;
+    criteriaValues: DatabaseValueType[][];
+} | {
+    isError: boolean;
+    errorObject: null;
+    criteriaValues: DatabaseValueType[][];
+};
+export declare function isCriteriaMatch(criteria: DatabaseValueType[][], database: DatabaseValueType[][], databaseRowIndex: number): boolean;
+export {};

package/lib/types/basics/inverted-index-cache.d.ts

@@ -1,18 +1,4 @@
-/**
- * Copyright 2023-present DreamNum Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+import { NumericTuple } from '@flatten-js/interval-tree';
 export declare class InvertedIndexCache {
     /**
      * {
@@ -30,11 +16,14 @@ export declare class InvertedIndexCache {
     private _continueBuildingCache;
     set(unitId: string, sheetId: string, column: number, value: string | number | boolean | null, row: number): void;
     getCellValuePositions(unitId: string, sheetId: string, column: number): Map<string | number | boolean | null, Set<number>> | undefined;
-    getCellPositions(unitId: string, sheetId: string, column: number, value: string | number | boolean): Set<number> | undefined;
-    getCellPosition(unitId: string, sheetId: string, column: number, value: string | number | boolean, startRow: number, endRow: number): number | undefined;
+    getCellPositions(unitId: string, sheetId: string, column: number, value: string | number | boolean, rowsInCache: NumericTuple[]): number[] | undefined;
     setContinueBuildingCache(unitId: string, sheetId: string, column: number, startRow: number, endRow: number): void;
     shouldContinueBuildingCache(unitId: string, sheetId: string, column: number, row: number): boolean;
-    canUseCache(unitId: string, sheetId: string, column: number, rangeStartRow: number, rangeEndRow: number): boolean;
+    canUseCache(unitId: string, sheetId: string, column: number, rangeStartRow: number, rangeEndRow: number): {
+        rowsInCache: NumericTuple[];
+        rowsNotInCache: NumericTuple[];
+    };
     clear(): void;
+    private _handleNewInterval;
 }
 export declare const CELL_INVERTED_INDEX_CACHE: InvertedIndexCache;

package/lib/types/basics/math.d.ts

@@ -19,3 +19,15 @@ export declare function calculateGcd(a: number, b: number): number;
 export declare function calculateLcm(a: number, b: number): number;
 export declare function calculateMdeterm(matrix: number[][]): number;
 export declare function calculateMinverse(matrix: number[][]): number[][] | null;
+export declare const romanToArabicMap: Map<string, number>;
+export declare const arabicToRomanMap: Map<number, string>;
+/**
+ * form: A number specifying the type of roman numeral you want.
+ * The roman numeral style ranges from Classic to Simplified, becoming more concise as the value of form increases
+ * 0 Classic
+ * 1 More concise
+ * 2 More concise
+ * 3 More concise
+ * 4 Simplified
+ */
+export declare const romanFormArray: number[][];

package/lib/types/commands/mutations/set-formula-calculation.mutation.d.ts

@@ -4,7 +4,6 @@ import { IFormulaDirtyData } from '../../services/current-data.service';
 import { FormulaExecutedStateType, IExecutionInProgressParams } from '../../services/runtime.service';
 export interface ISetFormulaCalculationStartMutation extends IFormulaDirtyData {
     options: Nullable<IExecutionOptions>;
-    forceCalculation: boolean;
 }
 /**
  * TODO: @DR-Univer

package/lib/types/controller/calculate.controller.d.ts

@@ -10,6 +10,5 @@ export declare class CalculateController extends Disposable {
     private _commandExecutedListener;
     private _calculate;
     private _initialExecuteFormulaListener;
-    private _initialExecuteFormulaProcessListener;
     private _applyResult;
 }

package/lib/types/controller/config.schema.d.ts

@@ -1,10 +1,14 @@
 import { Ctor } from '@univerjs/core';
-import { BaseFunction } from '../functions/base-function';
 import { IFunctionNames } from '../basics/function';
+import { BaseFunction } from '../functions/base-function';
 export declare const PLUGIN_CONFIG_KEY = "engine-formula.config";
 export declare const configSymbol: unique symbol;
 export interface IUniverEngineFormulaConfig {
     notExecuteFormula?: boolean;
     function?: Array<[Ctor<BaseFunction>, IFunctionNames]>;
+    /**
+     * The formula calculation quantity interval for waiting for the main thread message in the worker. Each time the formula calculates the `intervalCount` quantity, it will receive a main thread message to support stopping the calculation. Default is 500
+     */
+    intervalCount?: number;
 }
 export declare const defaultPluginConfig: IUniverEngineFormulaConfig;

package/lib/types/engine/analysis/__tests__/dependency.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/engine/ast-node/base-ast-node.d.ts

@@ -7,7 +7,7 @@ import { NodeType } from './node-type';
 interface IAstNodeNodeJson {
     token: string;
     children?: IAstNodeNodeJson[];
-    nodeType: string;
+    nodeType: number;
 }
 export type LambdaPrivacyVarType = Map<string, Nullable<BaseAstNode>>;
 export declare class BaseAstNode {

package/lib/types/engine/ast-node/function-node.d.ts

@@ -34,6 +34,8 @@ export declare class FunctionNode extends BaseAstNode {
     private _setDefinedNamesForFunction;
     private _setRefInfo;
     private _setRefData;
+    private _setLocale;
+    private _setSheetsInfo;
 }
 export declare class ErrorFunctionNode extends BaseAstNode {
     constructor(token?: string);

package/lib/types/engine/ast-node/node-type.d.ts

@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 export declare enum NodeType {
-    REFERENCE = "ReferenceNode",
-    VALUE = "ValueNode",
-    OPERATOR = "OperatorNode",
-    FUNCTION = "FunctionNode",
-    LAMBDA = "LambdaNode",
-    LAMBDA_PARAMETER = "LambdaNodeParameter",
-    ERROR = "ErrorNode",
-    BASE = "Base",
-    ROOT = "Root",
-    UNION = "UnionNode",
-    PREFIX = "PrefixNode",
-    SUFFIX = "SuffixNode",
-    NULL = "NullNode"
+    REFERENCE = 1,
+    VALUE = 2,
+    OPERATOR = 3,
+    FUNCTION = 4,
+    LAMBDA = 5,
+    LAMBDA_PARAMETER = 6,
+    ERROR = 7,
+    BASE = 8,
+    ROOT = 9,
+    UNION = 10,
+    PREFIX = 11,
+    SUFFIX = 12,
+    NULL = 13
 }
 export declare const NODE_ORDER_MAP: Map<NodeType, number>;

package/lib/types/engine/dependency/dependency-tree.d.ts

@@ -13,10 +13,10 @@ export declare enum FDtreeStateType {
  * is used to determine the order of formula calculations.
  */
 export declare class FormulaDependencyTree {
-    treeId: string;
+    treeId: number;
     nodeData: Nullable<IExecuteAstNodeData>;
-    children: Set<FormulaDependencyTree>;
-    parents: Set<FormulaDependencyTree>;
+    children: Set<number>;
+    parents: Set<number>;
     formula: string;
     row: number;
     column: number;
@@ -28,14 +28,22 @@ export declare class FormulaDependencyTree {
     formulaId: Nullable<string>;
     featureId: Nullable<string>;
     isCache: boolean;
-    constructor(treeId?: string);
+    constructor(treeId: number);
+    toJson(): {
+        formula: string;
+        row: number;
+        column: number;
+        subUnitId: string;
+        unitId: string;
+        formulaId: Nullable<string>;
+        featureId: Nullable<string>;
+    };
     getDirtyData: Nullable<(dirtyData: IFormulaDirtyData, runtimeData: IAllRuntimeData) => {
         runtimeCellData: IRuntimeUnitDataType;
         dirtyRanges: IFeatureDirtyRangeType;
     }>;
     private _state;
     dispose(): void;
-    disposeWithChildren(): void;
     resetState(): void;
     setAdded(): void;
     isAdded(): boolean;
@@ -50,7 +58,7 @@ export declare class FormulaDependencyTree {
      * @param range
      */
     pushRangeList(ranges: IUnitRange[]): void;
-    hasChildren(tree: FormulaDependencyTree): boolean;
+    hasChildren(treeId: number): boolean;
     toRTreeItem(): IRTreeItem;
     /**
      * Determine whether it is dependent on other trees.

package/lib/types/engine/reference-object/base-reference-object.d.ts

@@ -39,6 +39,11 @@ export declare class BaseReferenceObject extends ObjectClassType {
         endRow: number;
         startColumn: number;
         endColumn: number;
+        rangeType?: import('@univerjs/core').RANGE_TYPE;
+        startAbsoluteRefType?: import('@univerjs/core').AbsoluteRefType;
+        endAbsoluteRefType?: import('@univerjs/core').AbsoluteRefType;
+        unitId?: string;
+        sheetId?: string;
     };
     isReferenceObject(): boolean;
     iterator(callback: (valueObject: Nullable<BaseValueObject>, rowIndex: number, columnIndex: number) => Nullable<boolean>): Nullable<boolean>;
@@ -115,6 +120,11 @@ export declare class BaseReferenceObject extends ObjectClassType {
             endRow: number;
             startColumn: number;
             endColumn: number;
+            rangeType?: import('@univerjs/core').RANGE_TYPE;
+            startAbsoluteRefType?: import('@univerjs/core').AbsoluteRefType;
+            endAbsoluteRefType?: import('@univerjs/core').AbsoluteRefType;
+            unitId?: string;
+            sheetId?: string;
         };
         sheetId: string;
         unitId: string;

package/lib/types/engine/utils/char-kit.d.ts

@@ -14,12 +14,10 @@
  * limitations under the License.
  */
 /**
- * Korean in Excel does not count as two characters. Here we calculate all Chinese, Japanese and Korean characters as two characters.
+ * excel logic is cofusing, so we use google sheet logic
  *
- * ā -> 1
- * ー -> 2
- *
- * @param str
- * @returns
+ * @param text
+ * @returns number
  */
-export declare function charLenByte(str: string): number;
+export declare function charLenByte(text: string): number;
+export declare function getCharLenByteInText(text: string, charIndex: number, direction?: 'ltr' | 'rtl'): number;

package/lib/types/engine/utils/numfmt-kit.d.ts

@@ -1,4 +1,4 @@
-import { ICellData, Nullable, Styles } from '@univerjs/core';
+import { ICellData, Nullable, Styles, LocaleType } from '@univerjs/core';
 import { operatorToken } from '../../basics/token';
 /**
  * Handling number formats in styles
@@ -61,3 +61,15 @@ export declare function clearNumberFormatTypeCache(): void;
  * @param nextPattern
  */
 export declare function comparePatternPriority(previousPattern: string, nextPattern: string, operator: operatorToken): string;
+export declare function getCurrencyFormat(locale: LocaleType, numberDigits?: number): string;
+export declare function applyCurrencyFormat(locale: LocaleType, number: number, numberDigits?: number): string;
+export declare function stringIsNumberPattern(input: string): {
+    isNumberPattern: boolean;
+    value: number;
+    pattern: string;
+} | {
+    isNumberPattern: boolean;
+    value?: undefined;
+    pattern?: undefined;
+};
+export declare function clearStringToNumberPatternCache(): void;

package/lib/types/engine/utils/reference-cache.d.ts

@@ -0,0 +1,3 @@
+import { IUnitRangeName } from '@univerjs/core';
+export declare function deserializeRangeWithSheetWithCache(refString: string): IUnitRangeName;
+export declare function clearReferenceToRangeCache(): void;

package/lib/types/engine/utils/reference.d.ts

@@ -43,8 +43,6 @@ export declare function handleRefStringInfo(refString: string): {
     unitId: string;
 };
 export declare function deserializeRangeWithSheet(refString: string): IUnitRangeName;
-export declare function deserializeRangeWithSheetWithCache(refString: string): IUnitRangeName;
-export declare function clearReferenceToRangeCache(): void;
 export declare function isReferenceStringWithEffectiveColumn(refString: string): boolean;
 export declare function replaceRefPrefixString(token: string): string;
 /**

package/lib/types/engine/value-object/array-value-object.d.ts

@@ -219,6 +219,7 @@ export declare class ArrayValueObject extends BaseValueObject {
     private _transposeArray;
     private _batchOperator;
     private _batchOperatorValue;
+    private __batchOperatorRowValue;
     private _batchOperatorArray;
     private _checkArrayCalculateType;
     private _formatValue;

package/lib/types/functions/base-function.d.ts

@@ -1,4 +1,4 @@
-import { IRange, Nullable } from '@univerjs/core';
+import { IRange, LocaleType, Nullable } from '@univerjs/core';
 import { IFunctionNames } from '../basics/function';
 import { BaseReferenceObject, FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';
 import { ArrayBinarySearchType, ArrayOrderSearchType } from '../engine/utils/compare';
@@ -13,6 +13,9 @@ export declare class BaseFunction {
     private _row;
     private _column;
     private _definedNames;
+    private _locale;
+    private _sheetOrder;
+    private _sheetNameMap;
     /**
      * Whether the function needs to expand the parameters
      */
@@ -21,6 +24,14 @@ export declare class BaseFunction {
      * Whether the function needs to pass in reference object
      */
     needsReferenceObject: boolean;
+    /**
+     * Whether the function needs handle locale
+     */
+    needsLocale: boolean;
+    /**
+     * Whether the function needs sheets info
+     */
+    needsSheetsInfo: boolean;
     /**
      * Minimum number of parameters
      */
@@ -44,6 +55,20 @@ export declare class BaseFunction {
      */
     getDefinedName(name: string): import('..').IDefinedNamesServiceParam | null;
     setDefinedNames(definedNames: IDefinedNameMapItem): void;
+    getLocale(): LocaleType;
+    setLocale(locale: LocaleType): void;
+    getSheetsInfo(): {
+        sheetOrder: string[];
+        sheetNameMap: {
+            [sheetId: string]: string;
+        };
+    };
+    setSheetsInfo({ sheetOrder, sheetNameMap, }: {
+        sheetOrder: string[];
+        sheetNameMap: {
+            [sheetId: string]: string;
+        };
+    }): void;
     isAsync(): boolean;
     isAddress(): boolean;
     isCustom(): boolean;

package/lib/types/functions/database/daverage/__tests__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/database/daverage/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { BaseFunction } from '../../base-function';
+export declare class Daverage extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(database: BaseValueObject, field: BaseValueObject, criteria: BaseValueObject): ErrorValueObject | NumberValueObject;
+}

package/lib/types/functions/database/dcount/__tests__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/database/dcount/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { BaseFunction } from '../../base-function';
+export declare class Dcount extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(database: BaseValueObject, field: BaseValueObject, criteria: BaseValueObject): ErrorValueObject | NumberValueObject;
+}

package/lib/types/functions/database/dcounta/__tests__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/database/dcounta/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { BaseFunction } from '../../base-function';
+export declare class Dcounta extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(database: BaseValueObject, field: BaseValueObject, criteria: BaseValueObject): ErrorValueObject | NumberValueObject;
+}

package/lib/types/functions/database/dget/__tests__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/database/dget/index.d.ts

@@ -0,0 +1,7 @@
+import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+export declare class Dget extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(database: BaseValueObject, field: BaseValueObject, criteria: BaseValueObject): BaseValueObject;
+}

package/lib/types/functions/database/dmax/__tests__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/database/dmax/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { BaseFunction } from '../../base-function';
+export declare class Dmax extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(database: BaseValueObject, field: BaseValueObject, criteria: BaseValueObject): ErrorValueObject | NumberValueObject;
+}

package/lib/types/functions/database/dmin/__tests__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/database/dmin/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { BaseFunction } from '../../base-function';
+export declare class Dmin extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(database: BaseValueObject, field: BaseValueObject, criteria: BaseValueObject): ErrorValueObject | NumberValueObject;
+}

package/lib/types/functions/database/dproduct/__tests__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/database/dproduct/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { BaseFunction } from '../../base-function';
+export declare class Dproduct extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(database: BaseValueObject, field: BaseValueObject, criteria: BaseValueObject): ErrorValueObject | NumberValueObject;
+}

package/lib/types/functions/database/dstdev/__tests__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/database/dstdev/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { BaseFunction } from '../../base-function';
+export declare class Dstdev extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(database: BaseValueObject, field: BaseValueObject, criteria: BaseValueObject): ErrorValueObject | NumberValueObject;
+}

package/lib/types/functions/database/dstdevp/__tests__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/lib/types/functions/database/dstdevp/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
+import { BaseFunction } from '../../base-function';
+export declare class Dstdevp extends BaseFunction {
+    minParams: number;
+    maxParams: number;
+    calculate(database: BaseValueObject, field: BaseValueObject, criteria: BaseValueObject): ErrorValueObject | NumberValueObject;
+}

package/lib/types/functions/database/dsum/__tests__/index.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};