ondc-code-generator 0.4.6 → 0.5.1

package/dist/generator/generators/python/templates/master-doc.mustache

@@ -0,0 +1,40 @@
+"""
+Perform Level-1 validations for a given `action`.
+
+Args:
+    action: string identifier of the action to validate against.
+    payload: Any JSON-like structure to validate (dict/list/nested).
+    config: Partial configuration. Can be:
+        - a plain dict (snake_case or camelCase keys),
+        - a dataclass/pydantic/object with fields,
+        - or a `ValidationConfig` TypedDict.
+        Missing fields are filled with defaults.
+    external_data: Optional dict of extra data available to rules.
+        `_SELF` is automatically set to the normalized payload.
+
+Config fields (merged with defaults):
+    - only_invalid (bool, default: True)
+    - hide_parent_errors (bool, default: True)
+    - _debug (bool, default: False)
+
+Returns:
+    ValidationOutput: a list of validation results, each shaped like:
+        {
+            "test_name": str,
+            "valid": bool,
+            "code": int,
+            "description"?: str,
+            "_debug_info"?: {
+            "fed_config"?: str,
+            "output_code"?: Any
+            }
+        }
+
+Raises:
+    ValueError: if the action is unknown.
+
+Example:
+    >>> out = perform_l1_validations("search", payload, {"only_invalid": False})
+    >>> out[0]["test_name"]
+    'REGEX_CONTEXT_LOCATION_CITY_CODE'
+"""

package/dist/generator/generators/python/templates/requirements.mustache

@@ -0,0 +1,2 @@
+# requirements.txt
+jsonpath-ng>=1.6.0

package/dist/generator/generators/python/templates/test-config.mustache

@@ -0,0 +1,62 @@
+from typing import Dict, Any, List
+from typing import TypedDict, Optional
+
+
+# External data type definitions
+ExternalData = Dict[str, Any]
+
+
+class ValidationConfig(TypedDict, total=False):
+    """Config options for validations.
+    Attributes:
+        only_invalid (bool): If True, only invalid results will be returned.
+        hide_parent_errors (Optional[bool]): If True, parent errors will be hidden.
+        _debug (Optional[bool]): If True, debug mode will be enabled.
+    """
+    only_invalid: Optional[bool]
+    hide_parent_errors: Optional[bool]
+    _debug: Optional[bool]
+
+# Input structure for validation functions
+ValidationInput = Dict[str, Any]
+
+class DebugInfo(TypedDict, total=False):
+    """
+    Diagnostic information useful for debugging.
+
+    Attributes:
+        fed_config: The configuration used to generate the validation.
+        output_code: The identifier/code of the validation rule that was executed.
+    """
+    fed_config: Any
+    output_code: Any
+
+
+class ValidationResult(TypedDict, total=False):
+    """
+    Represents the output of a single validation test.
+
+    Attributes:
+        test_name: The name of the validation test.
+        valid: Whether the test passed (True) or failed (False).
+        code: Numeric code representing the result or error type.
+        description: Optional. Additional details about the test result.
+        _debug_info: Optional. Diagnostic information useful for debugging.
+    """
+    test_name: str
+    valid: bool
+    code: int
+    description: Optional[str]
+    _debug_info: Optional[DebugInfo]
+
+
+# Represents the output of a validation run:
+# a list of individual validation results.
+ValidationOutput = List[ValidationResult]
+
+# Test function array type
+TestFunctionArray = List[callable]
+
+{{#externalData}}
+# {{name}}: Any
+{{/externalData}}

package/dist/generator/generators/python/templates/test-object.mustache

@@ -0,0 +1,29 @@
+def {{name}}(input_data):
+    scope = payload_utils["get_json_path"](input_data["payload"], "{{{scopePath}}}")
+    sub_results = []
+    valid = True
+
+    for {{testName}}_obj in scope:
+        {{testName}}_obj["_EXTERNAL"] = input_data["external_data"]
+{{#variables}}
+        {{name}} = {{{value}}}
+{{/variables}}
+        
+{{#hasContinue}}
+        skip_check = {{{skipCheckStatement}}}
+        if skip_check:
+            continue
+{{/hasContinue}}
+
+{{{validationCode}}}
+        # del {{testName}}_obj["_EXTERNAL"]
+
+    return [{
+        "test_name": "{{testName}}",
+        "valid": valid,
+        "code": {{successCode}} if valid else {{errorCode}}, 
+        "_debug_info": {
+            "fed_config": r"""
+{{{TEST_OBJECT}}}
+"""
+    }}] + sub_results

package/dist/generator/generators/python/templates/validation-code.mustache

@@ -0,0 +1,35 @@
+{{#isNested}}
+{{{nestedFunctions}}}
+
+        test_functions = [
+    {{#names}}
+            {{name}},
+    {{/names}}
+        ]
+
+        all_results = []
+        for fn in test_functions:
+            sub_result = fn(input_data)
+            all_results.extend(sub_result)
+
+
+        sub_results = all_results
+        valid = all(r["valid"] for r in sub_results)
+{{/isNested}}
+{{^isNested}}
+        validate = {{{returnStatement}}}
+
+        if not validate:
+            del {{testName}}_obj["_EXTERNAL"]
+            return [{
+                "test_name": "{{testName}}",
+                "valid": False,
+                "code": {{errorCode}},
+                "description": r"""{{{errorDescription}}}""",
+                "_debug_info": {
+                    "fed_config": r"""
+{{{TEST_OBJECT}}}
+"""
+                }
+            }]
+{{/isNested}}

package/dist/generator/generators/python/templates/validation-utils.mustache

@@ -0,0 +1,93 @@
+import re
+from datetime import datetime
+from typing import List
+
+def are_unique(operand: List[str]) -> bool:
+    return len(set(operand)) == len(operand)
+
+def are_present(operand: List[str]) -> bool:
+    return none_in(operand, ["null", "undefined", None]) and len(operand) > 0
+
+def all_in(left: List[str], right: List[str]) -> bool:
+    if len(left) == 0 and len(right) != 0:
+        return False
+    return all(v in right for v in left)
+
+def any_in(left: List[str], right: List[str]) -> bool:
+    if len(left) == 0 and len(right) != 0:
+        return False
+    return any(v in right for v in left)
+
+def none_in(left: List[str], right: List[str]) -> bool:
+    return all(v not in right for v in left)
+
+def equal_to(left: List[str], right: List[str]) -> bool:
+    if len(left) != len(right):
+        return False
+    return all(v == right[i] for i, v in enumerate(left))
+
+def is_iso8601(s: str) -> bool:
+    iso8601_regex = r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$'
+    if not re.match(iso8601_regex, s):
+        return False
+    try:
+        datetime.fromisoformat(s.replace('Z', '+00:00'))
+        return True
+    except ValueError:
+        return False
+
+def greater_than(left: List[str], right: List[str]) -> bool:
+    def are_all_iso(arr): return all(is_iso8601(v) for v in arr)
+    def are_all_numbers(arr): return all(is_number(v) for v in arr)
+
+    if are_all_iso(left) and are_all_iso(right):
+        left_dates = [datetime.fromisoformat(d.replace('Z', '+00:00')).timestamp() for d in left]
+        right_dates = [datetime.fromisoformat(d.replace('Z', '+00:00')).timestamp() for d in right]
+        return all(ld > right_dates[i] if i < len(right_dates) else True for i, ld in enumerate(left_dates))
+    elif are_all_numbers(left) and are_all_numbers(right):
+        left_numbers = [float(n) for n in left]
+        right_numbers = [float(n) for n in right]
+        return all(ln > right_numbers[i] if i < len(right_numbers) else True for i, ln in enumerate(left_numbers))
+    return False
+
+def less_than(left: List[str], right: List[str]) -> bool:
+    def are_all_iso(arr): return all(is_iso8601(v) for v in arr)
+    def are_all_numbers(arr): return all(is_number(v) for v in arr)
+
+    if are_all_iso(left) and are_all_iso(right):
+        left_dates = [datetime.fromisoformat(d.replace('Z', '+00:00')).timestamp() for d in left]
+        right_dates = [datetime.fromisoformat(d.replace('Z', '+00:00')).timestamp() for d in right]
+        return all(ld < right_dates[i] if i < len(right_dates) else True for i, ld in enumerate(left_dates))
+    elif are_all_numbers(left) and are_all_numbers(right):
+        left_numbers = [float(n) for n in left]
+        right_numbers = [float(n) for n in right]
+        return all(ln < right_numbers[i] if i < len(right_numbers) else True for i, ln in enumerate(left_numbers))
+    return False
+
+def follow_regex(left: List[str], regex_array: List[str]) -> bool:
+    if len(left) == 0 and len(regex_array) != 0:
+        return False
+    for regex in regex_array:
+        re_obj = re.compile(regex)
+        if any(not re_obj.match(v) for v in left):
+            return False
+    return True
+
+def is_number(s: str) -> bool:
+    try:
+        float(s)
+        return True
+    except ValueError:
+        return False
+
+validation_utils = {
+    "are_unique": are_unique,
+    "are_present": are_present,
+    "all_in": all_in,
+    "any_in": any_in,
+    "none_in": none_in,
+    "equal_to": equal_to,
+    "follow_regex": follow_regex,
+    "greater_than": greater_than,
+    "less_than": less_than,
+}

package/dist/generator/generators/typescript/templates/api-test.mustache

@@ -4,4 +4,32 @@ import { testFunctionArray, validationInput, validationOutput } from "../types/t
 
 
 
-export default {{{functionCode}}}
+export default function {{apiName}}(input: validationInput): validationOutput{
+
+    let totalResults = {{apiName}}Validations(input);
+
+    if (input.config._debug === false) {
+		totalResults.forEach((r) => {
+			delete r._debugInfo;
+		});
+	}
+	if(input.config.hideParentErrors === true) {
+		// delete results with valid false and no description
+		totalResults = totalResults.filter((r) => !(r.valid === false && !r.description));
+	}
+	if (input.config.onlyInvalid === true) {
+		const res = totalResults.filter((r) => r.valid === false);
+		if(res.length === 0) {
+			const targetSuccess = totalResults.find((r) => r.testName === "{{apiName}}Validations");
+			if(!targetSuccess) {
+				throw new Error("Critical: Overall test result not found");
+			}
+			return [targetSuccess];
+		}
+		return res;
+	}
+
+    return totalResults;
+}
+
+{{{functionCode}}}

package/dist/generator/generators/typescript/templates/index.mustache

@@ -0,0 +1,33 @@
+{{{importsCode}}}
+
+/**
+ * Perform Level-1 validations against a payload for a given action.
+ *
+ * @remarks
+ * **Output shape** — {@link validationOutput} is an array of:
+ * - `testName: string`
+ * - `valid: boolean`
+ * - `code: number`
+ * - `description?: string`
+ * - `_debugInfo?: { fedConfig?: string; outputCode?: unknown }`
+ *
+ * **Config** — {@link ValidationConfig} (partial accepted here):
+ * - `onlyInvalid` (default `true`)
+ * - `hideParentErrors` (default `true`)
+ * - `_debug` (default `false`)
+ *
+ * @param action - One of {@link Action}.
+ * @param payload - The JSON payload to validate.
+ * @param config - Partial {@link ValidationConfig}. Merged with defaults.
+ * @param externalData - Extra data accessible to rules (we set `_SELF` to the normalized payload).
+ * @returns {@link validationOutput}
+ *
+ * @example
+ * ```ts
+ * import { performL1_validations } from "@your/pkg";
+ *
+ * const out = performL1_validations("search", payload, { onlyInvalid: false });
+ * // e.g. out[0] => { testName, valid, code, description?, _debugInfo? }
+ * ```
+ */
+ {{{masterFunction}}}

package/dist/generator/generators/typescript/templates/test-config.mustache

@@ -1,14 +1,54 @@
-
+/**
+ * Configuration options for running validation routines.
+ *
+ * @property onlyInvalid - If true, only invalid results will be returned.
+ * @property hideParentErrors - Optional. Hides nested error details if set to true.
+ * @property _debug - Optional. Enables debug mode for additional diagnostic information.
+ */
 export interface ValidationConfig {
-    runAllValidations: boolean;
+	onlyInvalid: boolean;
+  hideParentErrors: boolean;
+	_debug: boolean;
 }
 
+
+/**
+ * Represents the output of a validation run.
+ *
+ * Each element in the array corresponds to a single validation test result.
+ *
+ * Object shape:
+ * ```ts
+ * {
+ *   testName: string;
+ *   valid: boolean;
+ *   code: number;
+ *   description?: string;
+ *   _debugInfo?: {
+ *     fedConfig: any;
+ *   };
+ * }
+ * ```
+ *
+ * ### Properties
+ * - **testName** — The name of the validation test.
+ * - **valid** — Whether the test passed (`true`) or failed (`false`).
+ * - **code** — Numeric code representing the result or error type.
+ * - **description** — *(Optional)* Additional details about the test result.
+ * - **_debugInfo** — *(Optional)* Diagnostic information useful for debugging.
+ *   - **fedConfig** — The configuration used to generate the validation.
+ */
 export type validationOutput = {
-	valid: boolean;
-	code: number;
-	description?: string;
+  testName: string;
+  valid: boolean;
+  code: number;
+  description?: string;
+  _debugInfo?: {
+    fedConfig: any;
+  };
 }[];
 
+
 /*
 {% comment %} export type ExternalData = {
     {{#externalData}}

package/dist/generator/generators/typescript/templates/test-object.mustache

@@ -16,5 +16,15 @@ function {{name}}(input: validationInput): validationOutput {
         {{{validationCode}}}
         delete testObj._EXTERNAL;
     }
-    return [{valid: valid,code: {{successCode}} },...subResults];
+    return [{
+        testName: "{{testName}}",
+        valid: valid,
+        code: valid ? {{successCode}} : {{errorCode}},
+        _debugInfo: {
+            fedConfig: 
+`
+{{{TEST_OBJECT}}}
+`,
+        }
+    },...subResults];
 }

package/dist/generator/generators/typescript/templates/validation-code.mustache

@@ -9,20 +9,13 @@ const testFunctions: testFunctionArray = [
     {{/names}}
 ];
 
-let invalidResults: validationOutput = [];
+let allResults : validationOutput = [];
 for (const fn of testFunctions) {
     const subResult = fn(input);
-    // .filter(r => !r.valid);
-    invalidResults = [...invalidResults, ...subResult];
-    if(!input.config.runAllValidations && invalidResults.length > 0) {
-        return invalidResults;
-    }
-}
-if(invalidResults.length > 0) {
-    // return invalidResults;
-    subResults = invalidResults;
-    valid = subResults.every(r => r.valid);
+    allResults  = [...allResults , ...subResult];
 }
+subResults = allResults ;
+valid = subResults.every((r) => r.valid);
 
 {{/isNested}}
 
@@ -32,9 +25,16 @@ const validate = {{{returnStatement}}}
 if(!validate){
     delete testObj._EXTERNAL;
     return [{
+        testName: "{{testName}}",
         valid: false,
         code: {{errorCode}},
-        description: `{{{errorDescription}}}`
+        description: `{{{errorDescription}}}`,
+        _debugInfo: {
+            fedConfig: 
+`
+{{{TEST_OBJECT}}}
+`,
+        }
     }]
 }
 {{/isNested}}

package/dist/generator/generators/typescript/ts-generator.js

@@ -23,13 +23,14 @@ export class TypescriptGenerator extends CodeGenerator {
             for (const key in testConfig) {
                 const testObjects = testConfig[key];
                 const betaConfig = {
-                    [TestObjectSyntax.Name]: key,
+                    [TestObjectSyntax.Name]: key + "Validations",
                     [TestObjectSyntax.Return]: testObjects,
                 };
                 const testFunction = await this.generateTestFunction(betaConfig);
                 const apiTestTemplate = readFileSync(path.resolve(__dirname, "./templates/api-test.mustache"), "utf-8");
                 const finalCode = Mustache.render(apiTestTemplate, {
                     functionCode: testFunction.code,
+                    apiName: key,
                 });
                 await writeAndFormatCode(this.rootPath, `./api-tests/${key}.ts`, finalCode, "typescript");
             }
@@ -63,6 +64,9 @@ export class TypescriptGenerator extends CodeGenerator {
                     : undefined,
                 validationCode: await this.createValidationLogicCode(testObject),
                 successCode: testObject[TestObjectSyntax.SuccessCode] ?? 200,
+                errorCode: testObject[TestObjectSyntax.ErrorCode] ?? 30000,
+                testName: testObject[TestObjectSyntax.Name],
+                TEST_OBJECT: `${JSON.stringify(testObject)}`,
             };
             return {
                 funcName: testObject[TestObjectSyntax.Name],
@@ -80,6 +84,8 @@ export class TypescriptGenerator extends CodeGenerator {
                     returnStatement: returnStatement,
                     errorCode: testObject[TestObjectSyntax.ErrorCode] ?? 30000,
                     errorDescription: this.CreateErrorMarkdown(testObject, skipList),
+                    testName: testObject[TestObjectSyntax.Name],
+                    TEST_OBJECT: `${JSON.stringify(testObject)}`,
                 });
             }
             else {
@@ -96,6 +102,8 @@ export class TypescriptGenerator extends CodeGenerator {
                     isNested: true,
                     nestedFunctions: functionCodes.map((f) => f.code).join("\n"),
                     names: names,
+                    testName: testObject[TestObjectSyntax.Name],
+                    TEST_OBJECT: `${JSON.stringify(testObject)}`,
                 });
             }
         };
@@ -158,31 +166,35 @@ export class TypescriptGenerator extends CodeGenerator {
     }
     generateIndexFile(apis, functionName = "L1Validations") {
         functionName = functionName.replace(/[^a-zA-Z0-9_]/g, "");
-        const importsCode = apis
+        let importsCode = apis
             .map((api) => `import ${api} from "./api-tests/${api}";`)
             .join("\n");
+        importsCode += `\nimport { ValidationConfig,validationOutput } from "./types/test-config";`;
+        importsCode += `\nimport normalizeKeys from "./utils/json-normalizer";`;
+        const masterTemplate = readFileSync(path.resolve(__dirname, "./templates/index.mustache"), "utf-8");
         const masterFunction = `
-				export function perform${functionName}(action: string, payload: any,allErrors = false, externalData : any = {}) {
-				const normalizedPayload = normalizeKeys(JSON.parse(JSON.stringify(payload)));
-				externalData._SELF = normalizedPayload;
+				export function perform${functionName}(action: string, payload: any, config?: Partial<ValidationConfig>, externalData: any = {}) {
+					const completeConfig: ValidationConfig = {
+						...{ onlyInvalid: true, standardLogs: false, hideParentErrors: true, _debug: false },
+						...config,
+					};
+					const normalizedPayload = normalizeKeys(JSON.parse(JSON.stringify(payload)));
+					externalData._SELF = normalizedPayload;
 					switch (action) {
 						${apis
             .map((api) => `case "${api}": return ${api}({
 				payload: normalizedPayload,
 				externalData: externalData,
-				config: {
-					runAllValidations: allErrors,
-				},
+				config: completeConfig,
 			});`)
             .join("\n")}
 						default:
 							throw new Error("Action not found");
 					}
 			}`;
-        return `	
-				import normalizeKeys from "./utils/json-normalizer";
-				${importsCode}
-				${masterFunction}
-			`;
+        return Mustache.render(masterTemplate, {
+            importsCode: importsCode,
+            masterFunction: masterFunction,
+        });
     }
 }

package/dist/generator/validators/tests-config/sub-validations.js

@@ -1,4 +1,4 @@
-import { TestObjectSyntax, nodeReservedKeywords, ExternalDataSyntax, ConfigSyntax, } from "../../../constants/syntax.js";
+import { TestObjectSyntax, ReservedKeywords, ExternalDataSyntax, ConfigSyntax, } from "../../../constants/syntax.js";
 import { buildAst } from "../../../services/return-complier/ast.js";
 import { checkValidVariables } from "../../../services/return-complier/ast-functions/semantic-validations.js";
 import { parseReturnInput } from "../../../services/return-complier/parser.js";
@@ -31,7 +31,7 @@ export class NameValidator extends TestObjectValidator {
             if (name.length < 1) {
                 throw new Error(`${TestObjectSyntax.Name} can't be a non-empty string at path ${this.validationPath}`);
             }
-            if (nodeReservedKeywords.has(name)) {
+            if (ReservedKeywords.has(name)) {
                 throw new Error(`${TestObjectSyntax.Name} can't be a reserved keyword at path ${this.validationPath}`);
             }
             if (!isSnakeCase(name)) {
@@ -141,7 +141,7 @@ export class VariableValidator extends TestObjectValidator {
         this.minimal = minimal;
     }
     validateKey(key) {
-        if (nodeReservedKeywords.has(key)) {
+        if (ReservedKeywords.has(key)) {
             throw new Error(`${key} can't be a reserved keyword at path ${this.validationPath}`);
         }
         if (key.includes(" ")) {

package/dist/index.js

@@ -7,7 +7,7 @@ export { ConfigCompiler };
 // const __dirname = path.dirname(__filename);
 // import { SupportedLanguages } from "./types/compiler-types.js";
 // const main = async () => {
-// 	const compiler = new ConfigCompiler(SupportedLanguages.Typescript);
+// 	const compiler = new ConfigCompiler(SupportedLanguages.Python);
 // 	const buildPath = path.resolve(__dirname, "../samples/build.yaml");
 // 	const valConfigPath = path.resolve(
 // 		__dirname,
@@ -16,7 +16,20 @@ export { ConfigCompiler };
 // 	const buildYaml = readFileSync(buildPath, "utf-8");
 // 	const valConfig = JSON.parse(readFileSync(valConfigPath, "utf-8"));
 // 	await compiler.initialize(buildYaml);
-// 	await compiler.generateCode(valConfig, "L1-validations", false, "./alpha/");
+// 	await compiler.generateCode(
+// 		valConfig,
+// 		"L1_validations",
+// 		false,
+// 		"./alpha/python/"
+// 	);
+// 	const compilerTy = new ConfigCompiler(SupportedLanguages.Typescript);
+// 	await compilerTy.initialize(buildYaml);
+// 	await compilerTy.generateCode(
+// 		valConfig,
+// 		"L1_validations",
+// 		false,
+// 		"./alpha/typescript/"
+// 	);
 // };
 // (async () => {
 // 	await main();

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

@@ -1,3 +1,4 @@
 export declare enum SupportedLanguages {
-    Typescript = "typescript"
+    Typescript = "typescript",
+    Python = "python"
 }

package/dist/types/compiler-types.js

@@ -1,4 +1,5 @@
 export var SupportedLanguages;
 (function (SupportedLanguages) {
     SupportedLanguages["Typescript"] = "typescript";
+    SupportedLanguages["Python"] = "python";
 })(SupportedLanguages || (SupportedLanguages = {}));

package/dist/utils/fs-utils.js

@@ -9,11 +9,54 @@ export function writeFileWithFsExtra(rootPath, relativeFilePath, content) {
     fs.outputFileSync(filePath, content);
 }
 export async function formatCode(code, lang) {
+    if (lang === "text") {
+        // No formatting for plain text files
+        return code;
+    }
+    if (lang == "python") {
+        // Basic Python formatting - clean up extra whitespace and blank lines
+        return formatPythonCode(code);
+    }
     return await prettier.format(code, {
         parser: lang,
         tabWidth: 4,
     });
 }
+function formatPythonCode(code) {
+    const lines = code.split("\n");
+    const formattedLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Skip lines that are only whitespace
+        if (line.trim() === "") {
+            // Only add empty line if the previous line wasn't empty
+            if (formattedLines.length > 0 &&
+                formattedLines[formattedLines.length - 1].trim() !== "") {
+                formattedLines.push("");
+            }
+            continue;
+        }
+        // Add the line as-is (preserve existing indentation)
+        formattedLines.push(line);
+    }
+    // Remove multiple consecutive empty lines
+    const cleanedLines = [];
+    let lastWasEmpty = false;
+    for (const line of formattedLines) {
+        const isEmpty = line.trim() === "";
+        if (isEmpty && lastWasEmpty) {
+            continue; // Skip consecutive empty lines
+        }
+        cleanedLines.push(line);
+        lastWasEmpty = isEmpty;
+    }
+    // Remove trailing empty lines
+    while (cleanedLines.length > 0 &&
+        cleanedLines[cleanedLines.length - 1].trim() === "") {
+        cleanedLines.pop();
+    }
+    return cleanedLines.join("\n") + "\n";
+}
 export async function writeAndFormatCode(rootPath, relativeFilePath, content, lang) {
     const formattedCode = await formatCode(content, lang);
     writeFileWithFsExtra(rootPath, relativeFilePath, formattedCode);