@qrvey/utils 1.12.0-2 → 1.12.0-21

package/dist/cjs/globalization/labels/formula_builder/I18N_FORMULA_BUILDER.js

@@ -0,0 +1,801 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18N_FORMULA_BUILDER = void 0;
+const I18N_FORMULA_BUILDER_FUNCTION_AND_1 = require("./I18N_FORMULA_BUILDER_FUNCTION_AND");
+const I18N_FORMULA_BUILDER_FUNCTION_MAX_1 = require("./I18N_FORMULA_BUILDER_FUNCTION_MAX");
+/**
+ * @deprecated since version 1.12.0; Qrvey version 8.3. Those default poroperties will be replaced by Qrvey Globalization JSON
+ */
+exports.I18N_FORMULA_BUILDER = {
+    list_modal: {
+        create_button: "Create Formula",
+        create_button_tooltip: "Add some records to create formulas",
+        empty_message: "No Formulas Yet",
+        information_text_link: "Learn how to",
+        information_text_text: "create and work with formulas",
+        title_header: "Formulas",
+        column_editor_type: "Editor Type",
+    },
+    list_table: {
+        duplicate_copy: "Copy",
+        duplicate_toast: "Formula Duplicated Successfully",
+        formula: "Formula",
+        menu_delete: "Delete",
+        menu_duplicate: "Duplicate",
+        menu_edit: "Edit",
+        name: "Formula Name",
+    },
+    delete_dialog: {
+        apply_button: "Delete",
+        cancel_button: "Cancel",
+        description: "Deleting this formula will remove all instances of this calculation in your analytics.",
+        title: "Delete Formula",
+        toast_description: "Formula Deleted Successfully",
+    },
+    create_modal: {
+        title_header_create: "Create Formula",
+        title_header_edit: "Edit Formula",
+        title_header_table: "Create Table Formula",
+        name: "Formula Name",
+        placeholder_name: "Type Formula Name",
+        invalid_name: "cannot be used in the formula name.",
+        detail_title: "Formula",
+        detail_suggestion: "Allows mathematical operations including",
+        detail_suggestion_operators: "+, -, *, /, ()",
+        detail_suggestion_locate: "Dates and numbers must be entered in en-US format.",
+        syntax_success: "Formula syntax is correct.",
+        syntax_error: "Formula syntax error, please check your formula and retry.",
+        syntax_warning: "Formula syntax correct, but some null values generate error",
+        test: "Test",
+        clear: "Clear",
+        insert_function: "Insert Functions",
+        insert_column: "Insert Columns",
+        search_function: "Search",
+        search_column: "Search",
+        box_function_empty: "No Function Selected",
+        add_formula: "Add to Formula",
+        cancel_button: "Cancel",
+        apply_button: "Save",
+        no_columns_available: "No Columns Available",
+        create_toast: "Formula Created Successfully.",
+        update_toast: "Formula Updated Successfully",
+        required_name_toast: "Formula Name is required.",
+        parameters: "Parameters",
+        example: "Example",
+        dont_show_again: "Do not show this again",
+        formula_name_error_character: "The formula name cannot be a special character.",
+        formula_name_error_operator: "Formula name cannot be an operator.",
+        formula_name_error_reserved_word: "The formula name cannot be a reserved word: null, true or false.",
+        formula_type: "Formula Mode",
+        formula_custom_script_mode: "Data Engine Syntax (legacy)",
+        formula_mode: {
+            title: "Standardized Syntax",
+            info: 'Allows mathematical and logical operators including +, -, *, /, (), =, >, <, >=, <=, <>. Numbers must be entered in en-US format. Date time values should be entered with format: "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS"',
+            tab_formula: "Formula",
+            tab_testing: "Testing",
+            tab_testing_tooltip: "This formula contains errors or is not finished.",
+            tab_testing_tooltip_empty: "No formula to test.",
+            show_columns: "Show Columns and Functions",
+            hide_columns: "Hide Columns and Functions",
+            tooltip_error_name_formula: "A name and a valid formula are mandatory to save.",
+            tooltip_error_name: "A name is mandatory to save.",
+            tooltip_error_formula: "A valid formula is mandatory to save.",
+            switch_editor: "Switch Editor",
+            switch_editor_description: "Switching formula editors will cause all your progress to be lost. Would you like to continue?",
+            switch_editor_button_continue: "Continue",
+            input: "Input",
+            output: "Output",
+            output_case: "Test Case",
+            output_result: "Result",
+            output_invalid_column: "Invalid column name.",
+            randomize_data: "Randomize data",
+            randomize_data_tooltip: "Refresh the testing data with random data from the dataset.",
+            console_output_title: "Console Output",
+            console_output_button: "See Console Output",
+            test_formula: "Test Formula",
+            functions: {
+                abs: {
+                    description: "Returns the absolute value of a number.",
+                    function_placeholder: "ABS(number)",
+                    param_number_name: "number",
+                    param_number_description: "The argument whose absolute value is to be determined. It must be a number a numeric column.",
+                },
+                datedif: {
+                    description: "Calculates the difference between two dates based on the date part requested.",
+                    function_placeholder: 'DATEDIF(date_value1, date_value2, "date_part")',
+                    param_date_value1_name: "date_value1",
+                    param_date_value1_description: 'The first date value. It can be a column or a datetime value entered with a format of either "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS".',
+                    param_date_value2_name: "date_value2",
+                    param_date_value2_description: 'The second date value. It can be a column or a datetime value entered with a format of either "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS". This date should always be equal or greater than date_value1.',
+                    param_date_part_name: "date_part",
+                    param_date_part_description: 'Date part allows: "Y" the number of complete years in the period, "M" the number of complete months in the period, "D" the number of days in the period.',
+                },
+                day: {
+                    description: "Returns the day of a date. The day is given as an integer ranging from 1 to 31.",
+                    function_placeholder: "DAY(date_value1)",
+                    param_date_value1_name: "date_value1",
+                    param_date_value1_description: 'It can be a column or a datetime value entered with a format of either "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS".',
+                },
+                hour: {
+                    description: "Returns the hour of a datetime value. The hour is given as an integer ranging from 0 to 23 or from 0 to 12 depending on the defined format.",
+                    function_placeholder: "HOUR(date_value1,[time_format])",
+                    param_date_value1_name: "date_value1",
+                    param_date_value1_description: 'It can be a column or a datetime value entered with a format of either "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS", datetime values without time will be assumed as 00:00:00.',
+                    param_time_format_name: "time_format (optional)",
+                    param_time_format_description: "if set to “24h“ it will return a number from 0 to 23, if set to “12h“ it will return a number from 1 to 12. If not set it will always return the hour in  24h format.",
+                },
+                minute: {
+                    description: "Returns the minute of a datetime value. The minute is given as an integer ranging from 0 to 59.",
+                    function_placeholder: "MINUTE(date_value1)",
+                    param_date_value1_name: "date_value1",
+                    param_date_value1_description: 'It can be a column or a datetime value entered with a format of either "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS", datetime values without time will be assumed as 00:00:00.',
+                },
+                second: {
+                    description: "Returns the second of a datetime value. The second is given as an integer ranging from 0 to 59.",
+                    function_placeholder: "SECOND(date_value1)",
+                    param_date_value1_name: "date_value1",
+                    param_date_value1_description: 'It can be a column or a datetime value entered with a format of either "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS", datetime values without time will be assumed as 00:00:00.',
+                },
+                year: {
+                    description: "Returns the year of a date. The year is given as an integer ranging from 1900 to 9999.Parameters",
+                    function_placeholder: "YEAR(date_value1)",
+                    param_date_value1_name: "date_value1",
+                    param_date_value1_description: 'It can be a column or a datetime value entered with a format of either "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS".',
+                },
+                month: {
+                    description: "Returns the month of a date. The month is given as an integer ranging from 1 (January) to 12 (December).",
+                    function_placeholder: "MONTH(date_value1)",
+                    param_date_value1_name: "date_value1",
+                    param_date_value1_description: 'It can be a column or a datetime value entered with a format of either "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS".',
+                },
+                if: {
+                    description: "Performs a logical test and returns a value based on the result.",
+                    function_placeholder: "IF(logicalTest,valueIfTrue,valueIfFalse)",
+                    param_logicalTest_name: "logicalTest (required)",
+                    param_logicalTest_description: "Logical test between two values, it should include logical operators such as =, >, <, >=, <= or <>. This argument can also be anything that returns a boolean value.",
+                    param_valueIfTrue_name: "valueIfTrue (required)",
+                    param_valueIfTrue_description: "Value that the function will return in case the result of the logicalTest is equal to true. It can be a number, datetime value, boolean or string.",
+                    param_valueIfFalse_name: "valueIfFalse (required)",
+                    param_valueIfFalse_description: "Value that the function will return in case the result of the logicalTest is equal to false. It can be a number, datetime value, boolean or string. If not defined, the function will return false by default.",
+                },
+                ifs: {
+                    description: "Allows different logical tests and returns the values set for the first condition equal to true.",
+                    function_placeholder: "IFS(logicalTest1,valueIfTrue1,logicalTest2,valueIfTrue2,...)",
+                    param_logicalTest1_name: "logicalTest1 (required)",
+                    param_logicalTest1_description: "logical test between two values, it should include logical operators such as =, >, <, >=, <= or <>. This argument can also be anything that returns a boolean value.",
+                    param_valueIfTrue1_name: "valueIfTrue1 (required)",
+                    param_valueIfTrue1_description: "Value that the function will return in case the result of the logicalTest1 is equal to true. It can be a number, datetime value, boolean or string.",
+                    param_logicalTest2_name: "logicalTest2...n (optional)",
+                    param_logicalTest2_description: "Logical test between two values, it should include logical operators such as =, >, <, >=, <= or <>. This argument can also be anything that returns a boolean value. This test will only be evaluated if the previous test was equal to false.",
+                    param_valueIfTrue2_name: "valueIfTrue2...n (optional)",
+                    param_valueIfTrue2_description: "Value that the function will return in case the result of the logicalTest2...n is equal to true. It can be a number, datetime value, boolean or string.",
+                },
+                mid: {
+                    description: "Returns a specific number of characters from a text string. The resulting substring begins at the specified beginIndex and extends the number of characters specified on numChars.",
+                    function_placeholder: "MID(string1, beginIndex, numChars)",
+                    param_string1_name: "string1",
+                    param_string1_description: "Text string containing the characters you want to extract.",
+                    param_beginIndex_name: "beginIndex",
+                    param_beginIndex_description: "The beginning index containing the first character you want to extract.",
+                    param_numChars_name: "numChars",
+                    param_numChars_description: "The number of characters you want to extract from the text string starting from beginIndex.",
+                },
+                isnull: {
+                    description: "Replaces null values with the specified replacement value.",
+                    function_placeholder: "ISNULL(column,replacement)",
+                    param_column_name: "column",
+                    param_column_description: "Column to check.",
+                    param_replacement_name: "replacement",
+                    param_replacement_description: "The value that will replace the null value. It must have the same data type as the column.",
+                },
+                dateadd: {
+                    description: "Adds a specific date part value to a given date.",
+                    function_placeholder: 'DATEADD(date_value1, "date_part", interval_value)',
+                    param_date_value1_name: "date_value1",
+                    param_date_value1_description: 'Date value for which you will get the weekday. It can be a column or a datetime value entered with a format of either "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS".',
+                    param_date_part_name: "date_part",
+                    param_date_part_description: 'Date part allows: "Y" for years, "M" for months, "D" for days, "H" for hours, "MI" for minutes and "S" for seconds.',
+                    param_interval_value_name: "interval_value",
+                    param_interval_value_description: "Number of units of the selected date part that you want to add to the given date.",
+                },
+                dayofweek: {
+                    description: "Returns a number or string representative of the weekday for a given date.",
+                    function_placeholder: "DAYOFWEEK(date_value1, day_name)",
+                    param_date_value1_name: "date_value1",
+                    param_date_value1_description: 'Date value to which you will add the date part value. It can be a column or a datetime value entered with a format of either "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS".',
+                    param_day_name_name: "day_name",
+                    param_day_name_description: 'If set equal to "Day" it will return the name of the day of the week, if set to "D" it will return a number from 1 to 7; if not set, it will also return a number from 1 to 7. 1=Sunday, 2=Monday, 3=Tuesday, 4=Wednesday, 5=Thursday, 6=Friday, 7=Saturday.',
+                },
+                trim: {
+                    description: "Removes all leading and trailing spaces from text.",
+                    function_placeholder: "TRIM(string1)",
+                    param_string1_name: "string1",
+                    param_string1_description: "Text to trim.",
+                },
+                concatenate: {
+                    description: "Joins two or more strings into one string.",
+                    function_placeholder: "CONCATENATE(string1,string2,...stringn)",
+                    param_string1_name: "string1 (required)",
+                    param_string1_description: "The first text to join.",
+                    param_string2_name: "string2 (required)",
+                    param_string2_description: "The second text to join.",
+                    param_stringn_name: "stringn (optional)",
+                    param_stringn_description: "Additional text items to join.",
+                },
+                left: {
+                    description: "Returns the first character or characters in a text string, based on the number of characters you specify.",
+                    function_placeholder: "LEFT(string1, num_chars)",
+                    param_string1_name: "string1 (required)",
+                    param_string1_description: "The text with characters to extract.",
+                    param_num_chars_name: "num_chars (optional)",
+                    param_num_chars_description: "Number of characters you want to extract. It has to be an integer greater than or equal to zero. If not defined, LEFT will return one character.",
+                },
+                right: {
+                    description: "Returns the last character or characters in a text string, based on the number of characters you specify.",
+                    function_placeholder: "RIGHT(string1, num_chars)",
+                    param_string1_name: "string1 (required)",
+                    param_string1_description: "The text with characters to extract.",
+                    param_num_chars_name: "num_chars (optional)",
+                    param_num_chars_description: "Number of characters you want to extract. It has to be an integer greater than or equal to zero. If not defined, RIGHT will return one character.",
+                },
+                upper: {
+                    description: "Converts all the characters in a string to uppercase.",
+                    function_placeholder: "UPPER(string1)",
+                    param_string1_name: "string1",
+                    param_string1_description: "The text you want converted to uppercase.",
+                },
+                lower: {
+                    description: "Converts all the characters in a string to lowercase.",
+                    function_placeholder: "LOWER(string1)",
+                    param_string1_name: "string1",
+                    param_string1_description: "The text you want converted to lowercase.",
+                },
+                proper: {
+                    description: "Capitalizes the first letter in a string and any other letters in the text placed next to any character other than a letter or number. Converts the rest of the letters to lowercase.",
+                    function_placeholder: "PROPER(string1)",
+                    param_string1_name: "string1",
+                    param_string1_description: "The text you want converted.",
+                },
+                and: Object.assign({}, I18N_FORMULA_BUILDER_FUNCTION_AND_1.I18N_FORMULA_BUILDER_FUNCTION_AND),
+                or: Object.assign(Object.assign({}, I18N_FORMULA_BUILDER_FUNCTION_AND_1.I18N_FORMULA_BUILDER_FUNCTION_AND), { description: "Evaluates different logical tests and returns false if all logical tests are false and true if at least one of the logical tests returns true.", function_placeholder: "OR(logicalTest1,logicalTest2,...logicalTestn)" }),
+                datesubtract: {
+                    description: "Subtracts a specific date part value to a given date.",
+                    function_placeholder: 'DATESUBTRACT(date_value1, "date_part", interval_value)',
+                    param_date_value1_name: "date_value1",
+                    param_date_value1_description: 'Date value to which you will subtract the date part value. It can be a column or a datetime value entered with a format of either "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS".',
+                    param_date_part_name: "date_part",
+                    param_date_part_description: 'Date part allows: "Y" for years, "M" for months, "D" for days, "H" for hours, "MI" for minutes and "S" for seconds.',
+                    param_interval_value_name: "interval_value",
+                    param_interval_value_description: "Number of units of the selected date part that you want to subtract to the given date.",
+                },
+                max: Object.assign({}, I18N_FORMULA_BUILDER_FUNCTION_MAX_1.I18N_FORMULA_BUILDER_FUNCTION_MAX),
+                min: Object.assign(Object.assign({}, I18N_FORMULA_BUILDER_FUNCTION_MAX_1.I18N_FORMULA_BUILDER_FUNCTION_MAX), { description: "Returns the smaller of two or more numeric or datetime values.", function_placeholder: "MIN(value1, value2, [valuen])" }),
+                include: {
+                    description: "Returns true if a string contains a specified sequence of characters.",
+                    function_placeholder: "INCLUDE(string1, string2)",
+                    param_string1_name: "string1",
+                    param_string1_description: "Text to review.",
+                    param_string2_name: "string2",
+                    param_string2_description: "Text with a sequence of characters that will be searched in string1.",
+                },
+                replace: {
+                    description: "Looks for a specific sequence of characters inside a string and replaces it with a different sequence of characters.",
+                    function_placeholder: "REPLACE(string1, target, replacement)",
+                    param_string1_name: "string1",
+                    param_string1_description: "Text to perform the replace into.",
+                    param_target_name: "target",
+                    param_target_description: "Text with a sequence of characters that will be searched in string1.",
+                    param_replacement_name: "replacement",
+                    param_replacement_description: "Text with a sequence of characters that will be replaced in string1 if the target string is found.",
+                },
+                length: {
+                    description: "Returns the length of a string.",
+                    function_placeholder: "LENGTH(string1)",
+                    param_string1_name: "string1",
+                    param_string1_description: "Text to review.",
+                },
+                sqrt: {
+                    description: "Returns the positive square root of a value.",
+                    function_placeholder: "SQRT(num1)",
+                    param_num1_name: "num1",
+                    param_num1_description: "The number of which you want the square root. It must be a positive number or a numeric column.",
+                },
+                exp: {
+                    description: "Returns Euler's number e raised to the power of a number.",
+                    function_placeholder: "EXP(num1)",
+                    param_num1_name: "num1",
+                    param_num1_description: "The exponent to raise e to.",
+                },
+                even: {
+                    description: "Returns a number rounded to the next greatest even integer. For negative numbers it returns a number rounded to the next negative even number with greater absolute value.",
+                    function_placeholder: "EVEN(num1)",
+                    param_num1_name: "num1",
+                    param_num1_description: "Numeric value.",
+                },
+                log: {
+                    description: "Returns the logarithm of a number to the base you specify.",
+                    function_placeholder: "LOG(num1, [base])",
+                    param_num1_name: "num1",
+                    param_num1_description: "Numeric value.",
+                    param_base_name: "base (optional)",
+                    param_base_description: "Base of the logarithm, if omitted, it is assumed to be 10. To calculate natural logarithm enter EXP(1).",
+                },
+                odd: {
+                    description: "Returns a number rounded to the next greatest odd integer. For negative numbers it returns a number rounded to the next negative odd number with greater absolute value.",
+                    function_placeholder: "ODD(num1)",
+                    param_num1_name: "num1",
+                    param_num1_description: "Numeric value.",
+                },
+                power: {
+                    description: "Returns the logarithm of a number to the base you specify.",
+                    function_placeholder: "POWER(num1, num2)",
+                    param_num1_name: "num1",
+                    param_num1_description: "Base.",
+                    param_num2_name: "num2",
+                    param_num2_description: "Exponent.",
+                },
+                random: {
+                    description: "Returns a positive decimal number between 0 (inclusive) and 1 (exclusive).",
+                    function_placeholder: "RANDOM()",
+                },
+                round: {
+                    description: "Rounds a number to a specified number of digits. For negative numbers it rounds to the next negative number with greater absolute value.",
+                    function_placeholder: "ROUND(num1,digits)",
+                    param_num1_name: "num1",
+                    param_num1_description: "Numeric value.",
+                    param_digits_name: "digits",
+                    param_digits_description: "Number of decimal digits, up to 10 digits.",
+                },
+                rounddown: {
+                    description: "Rounds a number down to a specified number of digits. For negative numbers it rounds to the next negative number with the least absolute value.",
+                    function_placeholder: "ROUNDDOWN(num1,digits)",
+                    param_num1_name: "num1",
+                    param_num1_description: "Numeric value.",
+                    param_digits_name: "digits",
+                    param_digits_description: "Number of decimal digits, up to 10 digits.",
+                },
+                roundup: {
+                    description: "Rounds a number up to a specified number of digits. For negative numbers it rounds to the next negative number with greater absolute value.",
+                    function_placeholder: "ROUNDUP(num1,digits)",
+                    param_num1_name: "num1",
+                    param_num1_description: "Numeric value.",
+                    param_digits_name: "digits",
+                    param_digits_description: "Number of decimal digits, up to 10 digits.",
+                },
+                millisecond: {
+                    description: "Returns the millisecond of a datetime value. The millisecond is given as an integer ranging from 0 to 999.",
+                    function_placeholder: "MILLISECOND(date_value1)",
+                    param_date_value1_name: "date_value1",
+                    param_date_value1_description: 'It can be a column or a datetime value entered with a format of either "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS", datetime values without time will be assumed as 00:00:00.',
+                },
+                text: {
+                    description: "Transforms a number into a string.",
+                    function_placeholder: "TEXT(num1)",
+                    param_num1_name: "num1",
+                    param_num1_description: "The number that you want to convert to text.",
+                },
+            },
+            editor: {
+                error_messages: {
+                    NUMBER_ARGS: "Ilegal number of arguments for function",
+                    NULL_FOUNDS: "Can not apply function with null values",
+                    FLOATING_POINT: "Invalid floating point operation to integer",
+                    MISSING_STRING: "Element has to be a String",
+                    MISSING_NUMBER: "Element has to be a Number",
+                    MISSING_DATE: "Element has to be a Date",
+                    GREATER_THAN_ZERO: "Element has to be greater than 0",
+                    MISSING_ARG: "Missing arguments",
+                    MISSING_PARENTHESIS: "Missing parenthesis",
+                    UNKNOWN_TOKEN: "Unknown token",
+                    UNKNOWN_FUNCTION: "Unknown function",
+                    UNKNOWN: "Unknown error",
+                    TOO_MANY_ARGUMENTS: "Too many arguments",
+                    DATE_DIF_UNIT_PARAM: "Argument {{i18n.function.argument.position}} has to be {{i18n.function.argument.datedif_unit}}",
+                    UNKNOWN_EXPRESSION: "Unknown expression",
+                    NOT_ALLOWED_EXPRESSION: "Expression not allowed",
+                    OUT_OF_RANGE: "Expression out of range",
+                    INVALID_CAST_NUMBER: "Invalid cast number",
+                    INVALID_BOOLEAN_ARGUMENT: "Invalid boolean argument",
+                    UNKNOWN_TOKEN_WITH_QUOTES: "Replace single quotes for double quotes in",
+                    INFERRED_PRIMITIVE: "Output values should have the same data type.",
+                    MISSING_COLUMN_EXPRESSION: "Argument should be a column.",
+                    NO_COLUMN_EXPRESSION: "Argument cannot be a column.",
+                    ARGUMENTS_DATATYPE_ERROR: "Arguments should have the same data type.",
+                    FUNCTION_ARGUMENTS_MISMATCH: "{{i18n.function.name}} function is expecting {{i18n.function.input}} and is receiving {{i18n.function.received}}",
+                    NOT_ALLOWED_OPERATION: "Expression not allowed. Allowed operators between {{i18n.function.expression.types}}: {{i18n.function.expression.operators}}",
+                    NOT_ALLOWED_OPERATION_DIFFERENT_TYPES: "Expression not allowed {{i18n.function.expression.value}}",
+                    NOT_ALLOWED_OPERATION_MISSING_OPERATOR: "Expression not allowed. Missing operator",
+                    INVALID_ALLOW_VALUE: "Argument {{i18n.function.argument.position}} has to be equal to {{i18n.function.argument.allow_value}}",
+                    MATCH_RANGE: "Argument {{i18n.function.argument.position}} has to be {{i18n.function.expression.dynamic}}",
+                    GREATER_THAN: "greater than {{i18n.function.argument.greater_than}}",
+                    LESS_THAN: "less than {{i18n.function.argument.less_than}}",
+                    GREATER_THAN_OR_EQUAL_TO: "greater or equal than {{i18n.function.argument.greater_than_or_equal_to}}",
+                    LESS_THAN_OR_EQUAL_TO: "less or equal than {{i18n.function.argument.less_than_or_equal_to}}",
+                },
+                special_words: {
+                    and: "and",
+                    between: "between",
+                    or: "or",
+                },
+            },
+        },
+    },
+    functions_type: {
+        all: "All",
+        numeric: "Numeric",
+        string: "String/Text",
+        date: "Date/Time",
+        aggregate: "Aggregates",
+        logical: "Logical",
+    },
+    function_is_null: {
+        description: "Replaces NULL with the specified replacement value.",
+        function_placeholder: "isNull(column, replacement)",
+        param_column_name: "column",
+        param_column_description: "Column to check.",
+        param_replacement_name: "replacement",
+        param_replacement_description: "Replacement value.",
+    },
+    function_abs: {
+        description: "Returns the absolute value of a value. If the argument is not negative, the argument is returned. If the argument is negative, the negation of the argument is returned.",
+        function_placeholder: "abs(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "The argument whose absolute value is to be determined.",
+    },
+    function_acos: {
+        description: "Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.",
+        function_placeholder: "acos(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "The value whose arc cosine is to be returned.",
+    },
+    function_asin: {
+        description: "Returns the arc sine of a value; the returned angle is in the range -pi/2 through pi/2.",
+        function_placeholder: "asin(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "The value whose arc sine is to be returned.",
+    },
+    function_atan: {
+        description: "Returns the arc tangent of a value; the returned angle is in the range -pi/2 through pi/2.",
+        function_placeholder: "atan(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "The value whose arc tangent is to be returned.",
+    },
+    function_atan_2: {
+        description: "Returns the angle theta from the conversion of rectangular coordinates (x, y) to polar coordinates (r, theta). This method computes the phase theta by computing an arc tangent of y/x in the range of -pi to pi.",
+        function_placeholder: "atan2(num1, num2)",
+        param_num_1_name: "num1",
+        param_num_1_description: "The ordinate coordinate.",
+        param_num_2_name: "num2",
+        param_num_2_description: "The abscissa coordinate.",
+    },
+    function_cbrt: {
+        description: "Returns the cube root of a value. For positive finite x, cbrt(-x) == -cbrt(x); that is, the cube root of a negative value is the negative of the cube root of that value's magnitude.",
+        function_placeholder: "cbrt(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "Numeric value.",
+    },
+    function_ceil: {
+        description: "Returns the smallest (closest to negative infinity) value that is greater than or equal to the argument and is equal to a mathematical integer.",
+        function_placeholder: "ceil(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "Numeric value.",
+    },
+    function_copy_sign: {
+        description: "Returns the first argument with the sign of the second argument. For this method, a NaN sign argument is always treated as if it were positive.",
+        function_placeholder: "copySign(magnitude, sign)",
+        param_magnitude_name: "magnitude",
+        param_magnitude_description: "The parameter providing the magnitude of the result.",
+        param_sign_name: "sign",
+        param_sign_description: "The parameter providing the sign of the result.",
+    },
+    function_cos: {
+        description: "Returns the trigonometric cosine of an angle.",
+        function_placeholder: "cos(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "An angle, in radians.",
+    },
+    function_cosh: {
+        description: "Returns the hyperbolic cosine of a value. The hyperbolic cosine of x is defined to be (ex + e-x)/2 where e is Euler's number.",
+        function_placeholder: "cosh(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "The number whose hyperbolic cosine is to be returned.",
+    },
+    function_exp: {
+        description: "Returns Euler's number e raised to the power of a value.",
+        function_placeholder: "exp(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "The exponent to raise e to.",
+    },
+    function_expm_1: {
+        description: "Returns e^x -1. Note that for values of x near 0, the exact sum of expm1(x) + 1 is much closer to the true result of e^x than exp(x).",
+        function_placeholder: "expm1(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "The exponent to raise e to in the computation of e^x -1.",
+    },
+    function_floor: {
+        description: "Returns the largest (closest to positive infinity) value that is less than or equal to the argument and is equal to a mathematical integer.",
+        function_placeholder: "floor(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "Numeric value",
+    },
+    function_hypot: {
+        description: "Returns sqrt(x^2 +y^2) without intermediate overflow or underflow.",
+        function_placeholder: "hypot(num1, num2)",
+        param_num_1_name: "num1",
+        param_num_1_description: "Numeric value",
+        param_num_2_name: "num2",
+        param_num_2_description: "Numeric value",
+    },
+    function_log: {
+        description: "Returns the natural logarithm (base e) of a double value.",
+        function_placeholder: "log(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "Numeric value",
+    },
+    function_log_10: {
+        description: "Returns the base 10 logarithm of a double value.",
+        function_placeholder: "log10(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "Numeric value",
+    },
+    function_log1p: {
+        description: "Returns the natural logarithm of the sum of the argument and 1. Note that for small values x, the result of log1p(x) is much closer to the true result of ln(1 + x) than the floating-point evaluation of log(1.0+x).",
+        function_placeholder: "log1p(x)",
+        param_x_name: "x",
+        param_x_description: "Numeric value",
+    },
+    function_max: {
+        description: "Returns the greater of two double values. That is, the result is the argument closer to positive infinity. If the arguments have the same value, the result is that same value. If either value is NaN, then the result is NaN. Unlike the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero. If one argument is positive zero and the other negative zero, the result is positive zero.",
+        function_placeholder: "max(num1, num2)",
+        param_num_1_name: "num1",
+        param_num_1_description: "An argument.",
+        param_num_2_name: "num2",
+        param_num_2_description: "Another argument.",
+    },
+    function_min: {
+        description: "Returns the smaller of two double values. That is, the result is the value closer to negative infinity. If the arguments have the same value, the result is that same value. If either value is NaN, then the result is NaN. Unlike the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero. If one argument is positive zero and the other is negative zero, the result is negative zero.",
+        function_placeholder: "min(num1, num2)",
+        param_num_1_name: "num1",
+        param_num_1_description: "An argument.",
+        param_num_2_name: "num2",
+        param_num_2_description: "Another argument.",
+    },
+    function_next_after: {
+        description: "Returns the floating-point number adjacent to the first argument in the direction of the second argument. If both arguments compare as equal the second argument is returned.",
+        function_placeholder: "nextAfter(start, direction)",
+        param_start_name: "start",
+        param_start_description: "Starting floating-point value.",
+        param_direction_name: "direction",
+        param_direction_description: "Value indicating which of start's neighbors or start should be returned.",
+    },
+    function_next_down: {
+        description: "Returns the floating-point value adjacent to the argument in the direction of negative infinity.",
+        function_placeholder: "nextDown(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "Starting floating-point value.",
+    },
+    function_next_up: {
+        description: "Returns the floating-point value adjacent to the argument in the direction of positive infinity.",
+        function_placeholder: "nextUp(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "Starting floating-point value.",
+    },
+    function_pow: {
+        description: "Returns the value of the first argument raised to the power of the second argument.",
+        function_placeholder: "pow(num1, num2)",
+        param_num_1_name: "num1",
+        param_num_1_description: "Base.",
+        param_num_2_name: "num2",
+        param_num_2_description: "The exponent.",
+    },
+    function_random: {
+        description: "Returns a double value with a positive sign, greater than or equal to 0.0 and less than 1.0.",
+        function_placeholder: "random()",
+    },
+    function_rint: {
+        description: "Returns the double value that is closest in value to the argument and is equal to a mathematical integer. If two double values that are mathematical integers are equally close to the value of the argument, the result is the integer value that is even.",
+        function_placeholder: "rint(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "Numeric value.",
+    },
+    function_round: {
+        description: "Returns the closest long to the argument, with ties rounding to positive infinity.",
+        function_placeholder: "round(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "A floating-point value to be rounded to a long.",
+    },
+    function_scalb: {
+        description: "Returns d × 2^scaleFactor rounded as if performed by a single correctly rounded floating-point multiply to a member of the double value set.",
+        function_placeholder: "scalb(num1, scaleFactor)",
+        param_num_1_name: "num1",
+        param_num_1_description: "Number to be scaled by a power of two.",
+        param_scale_factor_name: "num1",
+        param_scale_factor_description: "Power of 2 used to scale the first argument.",
+    },
+    function_signum: {
+        description: "Returns the signum function of the argument; zero if the argument is zero, 1.0 if the argument is greater than zero, -1.0 if the argument is less than zero.",
+        function_placeholder: "signum(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "The floating-point value whose signum is to be returned.",
+    },
+    function_sin: {
+        description: "Returns the trigonometric sine of an angle.",
+        function_placeholder: "sin(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "An angle, in radians.",
+    },
+    function_sinh: {
+        description: "Returns the hyperbolic sine of a double value. The hyperbolic sine of x is defined to be (e^x - e^(-x))/2 where e is Euler's number.",
+        function_placeholder: "sinh(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "The number whose hyperbolic sine is to be returned.",
+    },
+    function_sqrt: {
+        description: "Returns the correctly rounded positive square root of a value.",
+        function_placeholder: "sqrt(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "Numeric value.",
+    },
+    function_tan: {
+        description: "Returns the trigonometric tangent of an angle.",
+        function_placeholder: "tan(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "An angle, in radians.",
+    },
+    function_tanh: {
+        description: "Returns the hyperbolic tangent of a double value. The hyperbolic tangent of x is defined to be (e^x - e^(-x))/(e^x + e^(-x)), in other words, sinh(x)/cosh(x). Note that the absolute value of the exact tanh is always less than 1.",
+        function_placeholder: "tanh(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "The number whose hyperbolic tangent is to be returned.",
+    },
+    function_to_degrees: {
+        description: "Converts an angle measured in radians to an approximately equivalent angle measured in degrees. The conversion from radians to degrees is generally inexact; users should not expect cos(toRadians(90.0)) to exactly equal 0.0.",
+        function_placeholder: "toDegrees(angrad)",
+        param_angrad_name: "angrad",
+        param_angrad_description: "An angle, in radians.",
+    },
+    function_to_radians: {
+        description: "Converts an angle measured in degrees to an approximately equivalent angle measured in radians. The conversion from degrees to radians is generally inexact.",
+        function_placeholder: "toRadians(angdeg)",
+        param_angdeg_name: "angdeg",
+        param_angdeg_description: "An angle, in degrees",
+    },
+    function_ulp: {
+        description: "Returns the size of an ulp of the argument. An ulp, unit in the last place, of a value is the positive distance between this floating-point value and the double value next larger in magnitude. Note that for non-NaN x, ulp(-x) == ulp(x).",
+        function_placeholder: "ulp(num1)",
+        param_num_1_name: "num1",
+        param_num_1_description: "The floating-point value whose ulp is to be returned.",
+    },
+    function_include: {
+        description: "Returns true if and only if this string contains the specified sequence of char values.",
+        function_placeholder: "String.include(CharSequence)",
+        param_char_sequence_name: "CharSequence",
+        param_char_sequence_description: "The sequence to search for.",
+    },
+    function_trim: {
+        description: "Returns a string whose value is this string, with any leading and trailing whitespace removed.",
+        function_placeholder: "String.trim()",
+    },
+    function_upper: {
+        description: "Converts all of the characters in this String to upper case.",
+        function_placeholder: "String.upper()",
+    },
+    function_lower: {
+        description: "Converts all of the characters in this String to lower case.",
+        function_placeholder: "String.lower()",
+    },
+    function_substring: {
+        description: "Returns a string that is a substring of this string. The substring begins at the specified beginIndex and extends to the character at index endIndex - 1. Thus the length of the substring is endIndex-beginIndex.",
+        function_placeholder: "String.substring(beginIndex, endIndex)",
+        param_begin_index_name: "beginIndex",
+        param_begin_index_description: "The beginning index, inclusive.",
+        param_end_index_name: "endIndex",
+        param_end_index_description: "The ending index, exclusive. (optional)",
+    },
+    function_replace: {
+        description: 'Replaces each substring of this string that matches the literal target sequence with the specified literal replacement sequence. The replacement proceeds from the beginning of the string to the end, for example, replacing "aa" with "b" in the string "aaa" will result in "ba" rather than "ab".',
+        function_placeholder: "String.replace(target, replacement)",
+        param_target_name: "target",
+        param_target_description: "The sequence of char values to be replaced.",
+        param_replacement_name: "replacement",
+        param_replacement_description: "The replacement sequence of char values.",
+    },
+    function_length: {
+        description: "Returns the length of the character sequence.",
+        function_placeholder: "String.length()",
+    },
+    function_now: {
+        description: "Returns a date with the current time in the current timezone with the following format: yyyy-MM-ddTHH:mm:ss.",
+        function_placeholder: "now()",
+    },
+    function_date_parse: {
+        description: "Return a Date from a String given a format.",
+        function_placeholder: "dateParse(string_date, 'format')",
+        param_string_date_name: "string_date",
+        param_string_date_description: "Date in string format.",
+        param_format_name: "format",
+        param_format_description: "Common suggested pattern letters you can use:<br>y = year (yy or ‘yyyy’)<br>M = month (MM)<br>d = day in month (dd)<br>h = hour (0-12) (hh)<br>H = hour (0-23) (HH)<br>m = minute in hour (mm)<br>s = seconds (ss)<br>S = milliseconds (SSS)<br>z = time zone text (e.g. Pacific Standard Time...)<br>Z = time zone, time offset (e.g. -0800).<br><br>Other formats may be validated as correct.",
+    },
+    function_date_format: {
+        description: "Given a Date or a Column return a String with the Format given.",
+        function_placeholder: "dateFormat(date_value, 'format')",
+        param_date_value_name: "date_value",
+        param_date_value_description: "Date value.",
+        param_format_name: "format",
+        param_format_description: "Common suggested pattern letters you can use:<br>y = year (yy or ‘yyyy’)<br>M = month (MM)<br>d = day in month (dd)<br>h = hour (0-12) (hh)<br>H = hour (0-23) (HH)<br>m = minute in hour (mm)<br>s = seconds (ss)<br>S = milliseconds (SSS)<br>z = time zone text (e.g. Pacific Standard Time...)<br>Z = time zone, time offset (e.g. -0800).<br><br>Other formats may be validated as correct.",
+    },
+    function_date_add: {
+        description: "Given a Date or a Column, add the specific value to the specific part.",
+        function_placeholder: "dateAdd(date, 'date_part', interval_value)",
+        param_date_name: "date",
+        param_date_description: "This is the Date or Column to which you want to add.",
+        param_part_name: "date_part",
+        param_part_description: "This indicates the units of time that you want to add. For example if you want to add 2 days, then this will be DAYS. Date part allows: YEARS, MONTHS, DAYS, HOURS, MINUTES or SECONDS.",
+        param_value_name: "interval_value",
+        param_value_description: "This is the number of units of time that you want to add.",
+    },
+    function_date_subtract: {
+        description: "Given a Date or a Column, subtract the specific value to the specific part.",
+        function_placeholder: "dateSubtract(date, 'date_part', interval_value)",
+        param_date_name: "date",
+        param_date_description: "This is the Date or Column to which you want to subtract.",
+        param_part_name: "date_part",
+        param_part_description: "This indicates the units of time that you want to substract. For example if you want to substract 2 days, then this will be DAYS. Date part allows: YEARS, MONTHS, DAYS, HOURS, MINUTES or SECONDS.",
+        param_value_name: "interval_value",
+        param_value_description: "This is the number of units of time that you want to subtract.",
+    },
+    function_date_diff: {
+        description: "Calculates the difference between two dates based on the date part requested.",
+        function_placeholder: "dateDiff(date_value1, date_value2, 'date_part')",
+        param_date_value_one_name: "date_value1",
+        param_date_value_one_description: "The first date value.",
+        param_date_value_two_name: "date_value2",
+        param_date_value_two_description: "The second date value.",
+        param_date_part_requested_name: "date_part",
+        param_date_part_requested_description: "Date part allows: YEARS, MONTHS, DAYS, HOURS, MINUTES or SECONDS.",
+    },
+    function_date_is_null: {
+        description: "Returns a string that replaces NULL with the specified replacement value.",
+        function_placeholder: "dateIsNull(column, replacement)",
+        param_column_name: "column",
+        param_column_description: "Date column to check.",
+        param_replacement_name: "replacement",
+        param_replacement_description: 'Date replacement value.<br>Common Replacement Value Formats:<br>○ Using another date column "dateIsNull(Column1, Column2)"<br>○ Using another date function "dateIsNull(Column, now())"<br>○ Using specified date "dateIsNull(Column, dateParse(\'31/12/2021\', \'dd/MM/yyyy\'))"',
+    },
+    function_agg_sum: {
+        description: "A single-value metrics aggregation that sums up numeric values that are extracted from the documents",
+        function_placeholder: "agg_sum(single_value)",
+        param_single_value_name: "single_value",
+        param_single_value_description: "Single-value",
+    },
+    function_agg_avg: {
+        description: "A single-value metrics aggregation that computes the average of numeric values that are extracted from the documents",
+        function_placeholder: "agg_avg(single_value)",
+        param_single_value_name: "single_value",
+        param_single_value_description: "Single-value",
+    },
+    function_agg_min: {
+        description: "A single-value metrics aggregation that keeps track and returns the minimum value among numeric values extracted from the documents.",
+        function_placeholder: "agg_min(single_value)",
+        param_single_value_name: "single_value",
+        param_single_value_description: "Single-value",
+    },
+    function_agg_max: {
+        description: "A single-value metrics aggregation that keeps track and returns the maximum value among the numeric values extracted from the documents.",
+        function_placeholder: "agg_max(single_value)",
+        param_single_value_name: "single_value",
+        param_single_value_description: "Single-value",
+    },
+    function_agg_distinctcount: {
+        description: "A single-value metrics aggregation that calculates an approximate count of distinct values.",
+        function_placeholder: "agg_distinctcount(single_value)",
+        param_single_value_name: "single_value",
+        param_single_value_description: "Single-value",
+    },
+    function_agg_count: {
+        description: "A single-value metrics aggregation that counts the number of values that are extracted from the documents.",
+        function_placeholder: "agg_count(single_value)",
+        param_single_value_name: "single_value",
+        param_single_value_description: "Single-value",
+    },
+};