@microsoft/power-apps-cli 0.6.1 → 0.6.7

package/node_modules/@microsoft/powerapps-player-actions/lib/CodeGen/modelServiceGenerator.js

@@ -1,7 +1,6 @@
 /*!
  * Copyright (C) Microsoft Corporation. All rights reserved.
  */
-var _a;
 import * as path from 'path';
 import { ParameterPropertyInfo } from '../Common/parameterPropertyInfo';
 import { getVfs } from '../VfsManager';
@@ -10,7 +9,7 @@ import { extractModelName, formatPropertyName, getServiceName, isValidPropertyNa
 /**
  * TypeScript type constants
  */
-export const TypeScriptTypes = {
+const TypeScriptTypes = {
     STRING: 'string',
     NUMBER: 'number',
     BOOLEAN: 'boolean',
@@ -18,598 +17,656 @@ export const TypeScriptTypes = {
     UNKNOWN: 'unknown',
     OBJECT: 'Record<string, unknown>',
 };
+// Configuration constants for output folders
+const GENERATED_FOLDER = 'generated';
+const MODELS_FOLDER = `${GENERATED_FOLDER}/models`;
+const SERVICES_FOLDER = `${GENERATED_FOLDER}/services`;
+const RELATIVE_MODEL_PATH = '../models';
+let _schemaFolderPath;
+let _outputDir;
 /*
- * Main generator utility
- * This class provides methods to generate TypeScript models and services from JSON schema files.
- *
+ * The main entry point for the model service generator.
+ * It processes the schema files in the specified folder and generates TypeScript models and services.
  */
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-export class ModelServiceGenerator {
-    /*
-     * The main entry point for the ModelServiceGenerator class.
-     * It processes the schema files in the specified folder and generates TypeScript models and services.
-     */
-    static async run(args, logger) {
-        const scenario = logger.trackScenario('ModelServiceGenerator.Run', { args });
-        try {
-            const vfs = getVfs();
-            const { isValid, schemaFolderPath, outputDir, schemaFilePath } = this.validateArguments(args);
-            if (!isValid || !schemaFolderPath || !outputDir) {
-                return;
-            }
-            _a._schemaFolderPath = schemaFolderPath;
-            _a._outputDir = outputDir;
-            await this.ensureOutputDirectoryExists(outputDir, vfs);
-            let schemaFiles = [];
-            if (schemaFilePath) {
-                schemaFiles = [schemaFilePath];
-            }
-            else {
-                schemaFiles = await getAllJsonFiles(schemaFolderPath);
-            }
-            for (const schemaPath of schemaFiles) {
-                try {
-                    await this.processSchema(schemaPath, outputDir, vfs);
-                }
-                catch (ex) {
-                    const err = ex;
-                    throw new Error(`Error processing schema at path '${schemaPath}': ${err.message}`);
-                }
-            }
-            // Generate index.ts file
-            await this.generateIndexFile(outputDir, vfs);
-            scenario.complete();
-        }
-        catch (error) {
-            scenario.failure({ error });
-        }
-        finally {
-            _a._schemaFolderPath = undefined;
-            _a._outputDir = undefined;
-        }
-    }
-    /**
-     * The validateArguments method validates the command line arguments.
-     * It checks if the correct number of arguments is provided and returns an object containing their values.
-     * It returns {isValid, schemaFolderPath, outputDir}.
-     */
-    static validateArguments(args) {
-        if (args.length < 2) {
-            return { isValid: false };
-        }
-        return {
-            isValid: true,
-            schemaFolderPath: args[0],
-            outputDir: args[1],
-            schemaFilePath: args[2], // Optional third argument for single schema file
-        };
-    }
-    /*
-     * The EnsureOutputDirectoryExists method ensures that the output directory exists.
-     * It creates the directory if it does not exist.
-     */
-    static async ensureOutputDirectoryExists(outputDir, vfs) {
-        if (!(await vfs.exists(outputDir))) {
-            await vfs.mkdir(outputDir, { recursive: true });
-        }
-    }
-    /**
-     * The processSchema method processes a single schema file.
-     * It generates TypeScript models and services based on the schema.
-     */
-    static async processSchema(schemaPath, outputDir, vfs) {
-        // Destructure result from initializeSchemaProcessing (returns: schema, schemaJson, outputDir, modelName, dataSourceName)
-        const { schema, schemaJson, outputDir: processedOutputDir, modelName, dataSourceName, } = await this.initializeSchemaProcessing(schemaPath, outputDir, vfs);
-        if (this.isSwaggerSchema(schema)) {
-            await this.handleSwaggerSchema(modelName, dataSourceName, schema, processedOutputDir, vfs);
-        }
-        else if (isSqlStoredProcedure(schema)) {
-            await this.handleSqlStoredProcedure(modelName, dataSourceName, schema, schemaJson, processedOutputDir, vfs);
+export async function generateModelService(options) {
+    const { logger, schemaFolderPath, codeGenPath, schemaFilePath } = options;
+    const scenario = logger.trackScenario('ModelServiceGenerator.GenerateModelService', options);
+    try {
+        const vfs = getVfs();
+        if (!schemaFolderPath || !codeGenPath) {
+            return;
         }
-        else if (isSharepointSchema(schema)) {
-            await this.handleSharepointSchema(modelName, dataSourceName, schema, schemaJson, processedOutputDir, vfs);
+        _schemaFolderPath = schemaFolderPath;
+        _outputDir = codeGenPath;
+        await ensureOutputDirectoryExists(codeGenPath, vfs);
+        let schemaFiles = [];
+        if (schemaFilePath) {
+            schemaFiles = [schemaFilePath];
         }
         else {
-            await this.handleStandardSchema(modelName, dataSourceName, schema, schemaJson, processedOutputDir, vfs);
+            schemaFiles = await getAllJsonFiles(schemaFolderPath);
+        }
+        for (const schemaPath of schemaFiles) {
+            try {
+                await processSchema(schemaPath, codeGenPath, vfs);
+            }
+            catch (ex) {
+                const err = ex;
+                throw new Error(`Error processing schema at path '${schemaPath}': ${err.message}`);
+            }
         }
+        // Generate index.ts file
+        await generateIndexFile(codeGenPath, vfs);
+        scenario.complete();
     }
-    /**
-     * The getModelNameFromSchema method retrieves the model name from a schema file.
-     */
-    static async getModelNameFromSchema(schemaPath, vfs) {
-        const schema = await this.loadSchemaFromFile(schemaPath, vfs, false);
-        const { modelName } = extractModelName(schema, schemaPath, vfs);
-        return modelName;
+    catch (error) {
+        scenario.failure({ error });
     }
-    /**
-     * The initializeSchemaProcessing method initializes the schema processing.
-     * Returns an object containing the parsed schema, the schema JSON string, the output directory, model name, and data source name.
-     */
-    static async initializeSchemaProcessing(schemaPath, outputDir, vfs) {
-        const { schema, schemaJson } = await this.loadSchemaFromFile(schemaPath, vfs, true);
-        await this.ensureOutputDirectoriesExist(outputDir, vfs);
-        // Ensure schema is a JsonObject for processing
-        if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) {
-            throw new Error('Schema must be a valid JSON object');
-        }
-        // model name is used for the generated TypeScript interface and file names
-        // dataSourceName is the logical name of the datasource ex:entity set name for Dataverse
-        const { modelName, dataSourceName } = extractModelName(schema, schemaPath, vfs);
-        return {
-            schema: schema,
-            schemaJson,
-            outputDir,
-            modelName,
-            dataSourceName,
-        };
-    }
-    static async loadSchemaFromFile(schemaPath, vfs, asObjectWithRaw = false) {
-        if (!(await vfs.exists(schemaPath))) {
-            throw new Error(`Schema file not found at path: ${schemaPath}`);
-        }
-        const schemaJson = await vfs.readFile(schemaPath, 'utf-8');
-        const schema = JSON.parse(schemaJson);
-        if (asObjectWithRaw) {
-            return { schema, schemaJson };
-        }
-        else {
-            return schema;
-        }
+    finally {
+        _schemaFolderPath = undefined;
+        _outputDir = undefined;
     }
-    /**
-     * The ensureOutputDirectoriesExist method ensures that the required output directories exist.
-     * It creates the main output directory, plus 'generated/models' and 'generated/services' subfolders if needed.
-     */
-    static async ensureOutputDirectoriesExist(outputDir, vfs) {
+}
+/**
+ * Clears and regenerates the model and service files.
+ */
+export async function clearAndRegenerateModelService(options) {
+    const { schemaFolderPath, codeGenPath, vfs, logger } = options;
+    const modelsDir = vfs.join(codeGenPath, MODELS_FOLDER);
+    const servicesDir = vfs.join(codeGenPath, SERVICES_FOLDER);
+    // Delete Models directory if it exists
+    if (await vfs.exists(modelsDir)) {
+        await vfs.rmdir(modelsDir);
+    }
+    // Delete Services directory if it exists
+    if (await vfs.exists(servicesDir)) {
+        await vfs.rmdir(servicesDir);
+    }
+    await generateModelService({ schemaFolderPath, codeGenPath, logger });
+}
+/*
+ * The EnsureOutputDirectoryExists method ensures that the output directory exists.
+ * It creates the directory if it does not exist.
+ */
+async function ensureOutputDirectoryExists(outputDir, vfs) {
+    if (!(await vfs.exists(outputDir))) {
         await vfs.mkdir(outputDir, { recursive: true });
-        await vfs.mkdir(vfs.join(outputDir, this.MODELS_FOLDER), { recursive: true });
-        await vfs.mkdir(vfs.join(outputDir, this.SERVICES_FOLDER), {
-            recursive: true,
-        });
     }
-    /**
-     * The isSwaggerSchema method checks if the schema is a Swagger schema.
-     * Returns true if schema.properties.swagger exists.
-     */
-    static isSwaggerSchema(schema) {
-        return (typeof schema === 'object' &&
-            schema !== null &&
-            !Array.isArray(schema) &&
-            'properties' in schema &&
-            schema.properties !== null &&
-            typeof schema.properties === 'object' &&
-            !Array.isArray(schema.properties) &&
-            Object.prototype.hasOwnProperty.call(schema.properties, 'swagger'));
+}
+/**
+ * The processSchema method processes a single schema file.
+ * It generates TypeScript models and services based on the schema.
+ */
+async function processSchema(schemaPath, outputDir, vfs) {
+    // Destructure result from initializeSchemaProcessing (returns: schema, schemaJson, outputDir, modelName, dataSourceName)
+    const { schema, schemaJson, outputDir: processedOutputDir, modelName, dataSourceName, } = await initializeSchemaProcessing(schemaPath, outputDir, vfs);
+    if (isSwaggerSchema(schema)) {
+        await handleSwaggerSchema(modelName, dataSourceName, schema, processedOutputDir, vfs);
     }
-    /**
-     * Checks if a property is a Dataverse lookup column.
-     */
-    static isDataverseLookupProperty(propValue) {
-        return propValue['x-ms-dataverse-type'] === 'LookupType';
+    else if (isSqlStoredProcedure(schema)) {
+        await handleSqlStoredProcedure(modelName, dataSourceName, schema, schemaJson, processedOutputDir, vfs);
     }
-    /**
-     * Gets all Dataverse lookup columns from the properties object.
-     */
-    static getDataverseLookupColumns(propertiesNode) {
-        const lookupColumns = new Map();
-        for (const [propName, propValue] of Object.entries(propertiesNode)) {
-            const propValueAsObject = typeof propValue === 'object' && propValue !== null && !Array.isArray(propValue)
-                ? propValue
-                : undefined;
-            if (propValueAsObject && this.isDataverseLookupProperty(propValueAsObject)) {
-                lookupColumns.set(propName, propValueAsObject);
-            }
-        }
-        return lookupColumns;
+    else if (isSharepointSchema(schema)) {
+        await handleSharepointSchema(modelName, dataSourceName, schema, schemaJson, processedOutputDir, vfs);
     }
-    /**
-     * Generates the OData bind property name for a lookup column.
-     * Example: "cr160_lookupcol" -> "cr160_lookupcol@odata.bind"
-     */
-    static generateODataBindPropertyName(schemaName) {
-        return `${schemaName}@odata.bind`;
+    else {
+        await handleStandardSchema(modelName, dataSourceName, schema, schemaJson, processedOutputDir, vfs);
     }
-    /**
-     * Generates the value property name for a lookup column.
-     * Example: "cr160_lookupcol" -> "_cr160_lookupcol_value"
-     */
-    static generateLookupValuePropertyName(lookupPropertyName) {
-        return `_${lookupPropertyName}_value`;
+}
+/**
+ * The initializeSchemaProcessing method initializes the schema processing.
+ * Returns an object containing the parsed schema, the schema JSON string, the output directory, model name, and data source name.
+ */
+async function initializeSchemaProcessing(schemaPath, outputDir, vfs) {
+    const { schema, schemaJson } = await loadSchemaFromFile(schemaPath, vfs, true);
+    await ensureOutputDirectoriesExist(outputDir, vfs);
+    // Ensure schema is a JsonObject for processing
+    if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) {
+        throw new Error('Schema must be a valid JSON object');
+    }
+    // model name is used for the generated TypeScript interface and file names
+    // dataSourceName is the logical name of the datasource ex:entity set name for Dataverse
+    const { modelName, dataSourceName } = extractModelName(schema, schemaPath, vfs);
+    return {
+        schema: schema,
+        schemaJson,
+        outputDir,
+        modelName,
+        dataSourceName,
+    };
+}
+async function loadSchemaFromFile(schemaPath, vfs, asObjectWithRaw = false) {
+    if (!(await vfs.exists(schemaPath))) {
+        throw new Error(`Schema file not found at path: ${schemaPath}`);
     }
-    /**
-     * The addCopyrightNotice method adds a copyright notice to the generated files.
-     */
-    static addCopyrightNotice(lines) {
-        lines.push('/*!');
-        lines.push(' * Copyright (C) Microsoft Corporation. All rights reserved.');
-        lines.push(' * This file is autogenerated. Do not edit this file directly.');
-        lines.push(' */');
-        lines.push('');
+    const schemaJson = await vfs.readFile(schemaPath, 'utf-8');
+    const schema = JSON.parse(schemaJson);
+    if (asObjectWithRaw) {
+        return { schema, schemaJson };
     }
-    /**
-     * Generates TypeScript interfaces for Dataverse entities with lookup columns.
-     * Creates both a base interface (for PATCH/POST) and an extended interface (for GET).
-     */
-    static generateDataverseInterfaces(modelName, definition) {
-        const lines = [];
-        this.addCopyrightNotice(lines);
-        const propertiesNode = this.getPropertiesNode(definition);
-        const lookupColumns = this.getDataverseLookupColumns(propertiesNode);
-        if (lookupColumns.size === 0) {
-            // No lookup columns, generate single interface
-            const singleInterface = this.generatePropertyLines(modelName, definition);
-            return { baseInterface: lines.join('\n') + singleInterface, extendedInterface: '' };
-        }
-        // Generate base interface for PATCH operations
-        const baseInterfaceName = `${modelName}Base`;
-        const baseInterfaceCode = this.generateDataverseBaseInterface(baseInterfaceName, modelName, definition, lookupColumns);
-        // Generate extended interface for GET operations
-        const extendedInterfaceName = modelName;
-        const extendedInterfaceCode = this.generateDataverseExtendedInterface(extendedInterfaceName, baseInterfaceName, definition, lookupColumns);
-        const baseInterface = lines.join('\n') + baseInterfaceCode;
-        const extendedInterface = extendedInterfaceCode;
-        return { baseInterface, extendedInterface };
+    else {
+        return schema;
     }
-    /**
-     * Generates the base interface for Dataverse PATCH/POST operations.
-     * Replaces lookup columns with @odata.bind properties.
-     */
-    static generateDataverseBaseInterface(interfaceName, originalModelName, definition, lookupColumns) {
-        const lines = [];
-        const requiredFields = this.getRequiredFields(definition);
-        const propertiesNode = this.getPropertiesNode(definition);
-        // Generate optionset enums first - use original model name for enum generation
-        const enumLines = this.generateOptionsetEnums(originalModelName, propertiesNode, '');
-        if (enumLines.length > 0) {
-            lines.push(...enumLines);
-            lines.push('');
-        }
-        lines.push(`export interface ${convertToValidIdentifier(interfaceName)} {`);
-        for (const [propName, propValue] of Object.entries(propertiesNode)) {
-            const propValueAsObject = typeof propValue === 'object' && propValue !== null && !Array.isArray(propValue)
-                ? propValue
-                : undefined;
-            // Skip read-only properties. They should not be included in PATCH/POST interfaces.
-            if (propValueAsObject === null || propValueAsObject === void 0 ? void 0 : propValueAsObject['x-ms-read-only']) {
-                continue;
-            }
-            // Handle lookup columns and their related properties
-            if (lookupColumns.has(propName) || this.isLookupRelatedProperty(propName, lookupColumns)) {
-                if (lookupColumns.has(propName)) {
-                    // Add @odata.bind property instead
-                    const schemaName = propValueAsObject === null || propValueAsObject === void 0 ? void 0 : propValueAsObject['x-ms-schema-name'];
-                    // Ensure schemaName is a string before passing to generateODataBindPropertyName
-                    const schemaNameStr = typeof schemaName === 'string' ? schemaName : propName;
-                    const odataBindProp = this.generateODataBindPropertyName(schemaNameStr);
-                    const formattedPropName = formatPropertyName(odataBindProp);
-                    const optionalMark = requiredFields.has(propName) ? '' : '?';
-                    lines.push(`  ${formattedPropName}${optionalMark}: string;`);
-                }
-                continue;
-            }
-            let formattedPropName = formatPropertyName(convertToValidIdentifier(propName));
-            formattedPropName = normalizePropertyName(formattedPropName);
-            const tsType = this.determineTypeScriptType(originalModelName, propValueAsObject, '', propName);
-            const optionalMark = requiredFields.has(propName) ? '' : '?';
-            this.addPropertyComment(lines, propValueAsObject, '');
-            lines.push(`  ${formattedPropName}${optionalMark}: ${tsType};`);
+}
+/**
+ * The ensureOutputDirectoriesExist method ensures that the required output directories exist.
+ * It creates the main output directory, plus 'generated/models' and 'generated/services' subfolders if needed.
+ */
+async function ensureOutputDirectoriesExist(outputDir, vfs) {
+    await vfs.mkdir(outputDir, { recursive: true });
+    await vfs.mkdir(vfs.join(outputDir, MODELS_FOLDER), { recursive: true });
+    await vfs.mkdir(vfs.join(outputDir, SERVICES_FOLDER), {
+        recursive: true,
+    });
+}
+/**
+ * The isSwaggerSchema method checks if the schema is a Swagger schema.
+ * Returns true if schema.properties.swagger exists.
+ */
+function isSwaggerSchema(schema) {
+    return (typeof schema === 'object' &&
+        schema !== null &&
+        !Array.isArray(schema) &&
+        'properties' in schema &&
+        schema.properties !== null &&
+        typeof schema.properties === 'object' &&
+        !Array.isArray(schema.properties) &&
+        Object.prototype.hasOwnProperty.call(schema.properties, 'swagger'));
+}
+/**
+ * Checks if a property is a Dataverse lookup column.
+ */
+function isDataverseLookupProperty(propValue) {
+    return propValue['x-ms-dataverse-type'] === 'LookupType';
+}
+/**
+ * Gets all Dataverse lookup columns from the properties object.
+ */
+function getDataverseLookupColumns(propertiesNode) {
+    const lookupColumns = new Map();
+    for (const [propName, propValue] of Object.entries(propertiesNode)) {
+        const propValueAsObject = typeof propValue === 'object' && propValue !== null && !Array.isArray(propValue)
+            ? propValue
+            : undefined;
+        if (propValueAsObject && isDataverseLookupProperty(propValueAsObject)) {
+            lookupColumns.set(propName, propValueAsObject);
         }
-        lines.push('}');
-        return lines.join('\n');
     }
-    /**
-     * Generates the extended interface for Dataverse GET operations.
-     * Extends the base interface and adds lookup object and value properties.
-     */
-    static generateDataverseExtendedInterface(modelName, baseInterfaceName, definition, lookupColumns) {
-        const lines = [];
-        lines.push(`export interface ${convertToValidIdentifier(modelName)} extends ${convertToValidIdentifier(baseInterfaceName)} {`);
-        const requiredFields = this.getRequiredFields(definition);
-        const propertiesNode = this.getPropertiesNode(definition);
-        // Add read-only properties (excluding lookup columns which are handled separately)
-        for (const [propName, propValue] of Object.entries(propertiesNode)) {
-            const propValueAsObject = typeof propValue === 'object' && propValue !== null && !Array.isArray(propValue)
-                ? propValue
-                : undefined;
-            // Only include read-only properties in the extended interface
-            if (!(propValueAsObject === null || propValueAsObject === void 0 ? void 0 : propValueAsObject['x-ms-read-only'])) {
-                continue;
-            }
-            // Skip lookup columns as they will be handled in the lookup-specific section
+    return lookupColumns;
+}
+/**
+ * Generates the OData bind property name for a lookup column.
+ * Example: "cr160_lookupcol" -> "cr160_lookupcol@odata.bind"
+ */
+function generateODataBindPropertyName(schemaName) {
+    return `${schemaName}@odata.bind`;
+}
+/**
+ * Generates the value property name for a lookup column.
+ * Example: "cr160_lookupcol" -> "_cr160_lookupcol_value"
+ */
+function generateLookupValuePropertyName(lookupPropertyName) {
+    return `_${lookupPropertyName}_value`;
+}
+/**
+ * The addCopyrightNotice method adds a copyright notice to the generated files.
+ */
+function addCopyrightNotice(lines) {
+    lines.push('/*!');
+    lines.push(' * Copyright (C) Microsoft Corporation. All rights reserved.');
+    lines.push(' * This file is autogenerated. Do not edit this file directly.');
+    lines.push(' */');
+    lines.push('');
+}
+/**
+ * Generates TypeScript interfaces for Dataverse entities with lookup columns.
+ * Creates both a base interface (for PATCH/POST) and an extended interface (for GET).
+ */
+function generateDataverseInterfaces(modelName, definition) {
+    const lines = [];
+    addCopyrightNotice(lines);
+    const propertiesNode = getPropertiesNode(definition);
+    const lookupColumns = getDataverseLookupColumns(propertiesNode);
+    if (lookupColumns.size === 0) {
+        // No lookup columns, generate single interface
+        const singleInterface = generatePropertyLines(modelName, definition);
+        return { baseInterface: lines.join('\n') + singleInterface, extendedInterface: '' };
+    }
+    // Generate base interface for PATCH operations
+    const baseInterfaceName = `${modelName}Base`;
+    const baseInterfaceCode = generateDataverseBaseInterface(baseInterfaceName, modelName, definition, lookupColumns);
+    // Generate extended interface for GET operations
+    const extendedInterfaceName = modelName;
+    const extendedInterfaceCode = generateDataverseExtendedInterface(extendedInterfaceName, baseInterfaceName, definition, lookupColumns);
+    const baseInterface = lines.join('\n') + baseInterfaceCode;
+    const extendedInterface = extendedInterfaceCode;
+    return { baseInterface, extendedInterface };
+}
+/**
+ * Generates the base interface for Dataverse PATCH/POST operations.
+ * Replaces lookup columns with @odata.bind properties.
+ */
+function generateDataverseBaseInterface(interfaceName, originalModelName, definition, lookupColumns) {
+    const lines = [];
+    const requiredFields = getRequiredFields(definition);
+    const propertiesNode = getPropertiesNode(definition);
+    // Generate optionset enums first - use original model name for enum generation
+    const enumLines = generateOptionsetEnums(originalModelName, propertiesNode, '');
+    if (enumLines.length > 0) {
+        lines.push(...enumLines);
+        lines.push('');
+    }
+    lines.push(`export interface ${convertToValidIdentifier(interfaceName)} {`);
+    for (const [propName, propValue] of Object.entries(propertiesNode)) {
+        const propValueAsObject = typeof propValue === 'object' && propValue !== null && !Array.isArray(propValue)
+            ? propValue
+            : undefined;
+        // Skip read-only properties. They should not be included in PATCH/POST interfaces.
+        if (propValueAsObject === null || propValueAsObject === void 0 ? void 0 : propValueAsObject['x-ms-read-only']) {
+            continue;
+        }
+        // Handle lookup columns and their related properties
+        if (lookupColumns.has(propName) || isLookupRelatedProperty(propName, lookupColumns)) {
             if (lookupColumns.has(propName)) {
-                continue;
+                // Add @odata.bind property instead
+                const schemaName = propValueAsObject === null || propValueAsObject === void 0 ? void 0 : propValueAsObject['x-ms-schema-name'];
+                // Ensure schemaName is a string before passing to generateODataBindPropertyName
+                const schemaNameStr = typeof schemaName === 'string' ? schemaName : propName;
+                const odataBindProp = generateODataBindPropertyName(schemaNameStr);
+                const formattedPropName = formatPropertyName(odataBindProp);
+                const optionalMark = requiredFields.has(propName) ? '' : '?';
+                lines.push(`  ${formattedPropName}${optionalMark}: string;`);
             }
-            let formattedPropName = formatPropertyName(convertToValidIdentifier(propName));
-            formattedPropName = normalizePropertyName(formattedPropName);
-            const tsType = this.determineTypeScriptType(modelName, propValueAsObject, '', propName);
-            const optionalMark = requiredFields.has(propName) ? '' : '?';
-            this.addPropertyComment(lines, propValueAsObject, '');
-            lines.push(`  ${formattedPropName}${optionalMark}: ${tsType};`);
+            continue;
         }
-        // Add lookup-specific properties
-        const lookupPropNames = Array.from(lookupColumns.keys());
-        for (const lookupPropName of lookupPropNames) {
-            // Add the lookup object property
-            lines.push(`  ${formatPropertyName(convertToValidIdentifier(lookupPropName))}?: object;`);
-            // Add the lookup value property (_propname_value)
-            const valuePropName = this.generateLookupValuePropertyName(lookupPropName);
-            const formattedValuePropName = formatPropertyName(valuePropName);
-            lines.push(`  ${formattedValuePropName}?: string;`);
-        }
-        lines.push('}');
-        return lines.join('\n');
+        let formattedPropName = formatPropertyName(convertToValidIdentifier(propName));
+        formattedPropName = normalizePropertyName(formattedPropName);
+        const tsType = determineTypeScriptType(originalModelName, propValueAsObject, '', propName);
+        const optionalMark = requiredFields.has(propName) ? '' : '?';
+        addPropertyComment(lines, propValueAsObject, '');
+        lines.push(`  ${formattedPropName}${optionalMark}: ${tsType};`);
     }
-    /**
-     * Checks if a property is related to a lookup column (like name properties).
-     */
-    static isLookupRelatedProperty(propName, lookupColumns) {
-        // Check if this property is a name property for any lookup column
-        const lookupPropNames = Array.from(lookupColumns.keys());
-        for (const lookupPropName of lookupPropNames) {
-            if (propName === `${lookupPropName}name`) {
-                return true;
-            }
+    lines.push('}');
+    return lines.join('\n');
+}
+/**
+ * Generates the extended interface for Dataverse GET operations.
+ * Extends the base interface and adds lookup object and value properties.
+ */
+function generateDataverseExtendedInterface(modelName, baseInterfaceName, definition, lookupColumns) {
+    const lines = [];
+    lines.push(`export interface ${convertToValidIdentifier(modelName)} extends ${convertToValidIdentifier(baseInterfaceName)} {`);
+    const requiredFields = getRequiredFields(definition);
+    const propertiesNode = getPropertiesNode(definition);
+    // Add read-only properties (excluding lookup columns which are handled separately)
+    for (const [propName, propValue] of Object.entries(propertiesNode)) {
+        const propValueAsObject = typeof propValue === 'object' && propValue !== null && !Array.isArray(propValue)
+            ? propValue
+            : undefined;
+        // Only include read-only properties in the extended interface
+        if (!(propValueAsObject === null || propValueAsObject === void 0 ? void 0 : propValueAsObject['x-ms-read-only'])) {
+            continue;
+        }
+        // Skip lookup columns as they will be handled in the lookup-specific section
+        if (lookupColumns.has(propName)) {
+            continue;
+        }
+        let formattedPropName = formatPropertyName(convertToValidIdentifier(propName));
+        formattedPropName = normalizePropertyName(formattedPropName);
+        const tsType = determineTypeScriptType(modelName, propValueAsObject, '', propName);
+        const optionalMark = requiredFields.has(propName) ? '' : '?';
+        addPropertyComment(lines, propValueAsObject, '');
+        lines.push(`  ${formattedPropName}${optionalMark}: ${tsType};`);
+    }
+    // Add lookup-specific properties
+    const lookupPropNames = Array.from(lookupColumns.keys());
+    for (const lookupPropName of lookupPropNames) {
+        // Add the lookup object property
+        lines.push(`  ${formatPropertyName(convertToValidIdentifier(lookupPropName))}?: object;`);
+        // Add the lookup value property (_propname_value)
+        const valuePropName = generateLookupValuePropertyName(lookupPropName);
+        const formattedValuePropName = formatPropertyName(valuePropName);
+        lines.push(`  ${formattedValuePropName}?: string;`);
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+/**
+ * Checks if a property is related to a lookup column (like name properties).
+ */
+function isLookupRelatedProperty(propName, lookupColumns) {
+    // Check if this property is a name property for any lookup column
+    const lookupPropNames = Array.from(lookupColumns.keys());
+    for (const lookupPropName of lookupPropNames) {
+        if (propName === `${lookupPropName}name`) {
+            return true;
         }
-        return false;
     }
-    /**
-     * The handleSwaggerSchema method handles the Swagger schema.
-     * It generates TypeScript models and services from the Swagger schema.
-     */
-    static async handleSwaggerSchema(modelName, dataSourceName, schema, outputDir, vfs) {
-        const swaggerObject = this.getSwaggerObject(schema);
-        const modelFilePath = vfs.join(outputDir, this.MODELS_FOLDER, `${modelName}Model.ts`);
-        const serviceFilePath = vfs.join(outputDir, this.SERVICES_FOLDER, `${modelName}Service.ts`);
-        const modelLines = [];
-        this.addCopyrightNotice(modelLines);
-        this.processDefinitions(swaggerObject, modelLines);
-        const parameterTypes = this.processParameters(swaggerObject, modelLines);
-        await this.writeToFile(modelFilePath, modelLines, vfs);
-        if ('paths' in swaggerObject &&
-            typeof swaggerObject.paths === 'object' &&
-            swaggerObject.paths !== null &&
-            !Array.isArray(swaggerObject.paths)) {
-            const serviceCode = this.generateServiceFromPaths(modelName, dataSourceName, swaggerObject.paths, parameterTypes);
-            await this.writeToFileWithContent(serviceFilePath, serviceCode, vfs);
-        }
+    return false;
+}
+/**
+ * The handleSwaggerSchema method handles the Swagger schema.
+ * It generates TypeScript models and services from the Swagger schema.
+ */
+async function handleSwaggerSchema(modelName, dataSourceName, schema, outputDir, vfs) {
+    const swaggerObject = getSwaggerObject(schema);
+    const modelFilePath = vfs.join(outputDir, MODELS_FOLDER, `${modelName}Model.ts`);
+    const serviceFilePath = vfs.join(outputDir, SERVICES_FOLDER, `${modelName}Service.ts`);
+    const modelLines = [];
+    addCopyrightNotice(modelLines);
+    processDefinitions(swaggerObject, modelLines);
+    const parameterTypes = processParameters(swaggerObject, modelLines);
+    await writeToFile(modelFilePath, modelLines, vfs);
+    if ('paths' in swaggerObject &&
+        typeof swaggerObject.paths === 'object' &&
+        swaggerObject.paths !== null &&
+        !Array.isArray(swaggerObject.paths)) {
+        const serviceCode = generateServiceFromPaths(modelName, dataSourceName, swaggerObject.paths, parameterTypes);
+        await writeToFileWithContent(serviceFilePath, serviceCode, vfs);
     }
-    /**
-     * The getSwaggerObject method retrieves the Swagger object from the schema.
-     * Throws an error if the schema is not valid Swagger format.
-     */
-    static getSwaggerObject(schema) {
-        if (schema !== null && typeof schema === 'object' && !Array.isArray(schema)) {
-            const properties = schema.properties;
-            if (typeof properties === 'object' && properties !== null && !Array.isArray(properties)) {
-                const swaggerNode = properties.swagger;
-                if (!swaggerNode || typeof swaggerNode !== 'object' || Array.isArray(swaggerNode)) {
-                    throw new Error("Invalid schema format: 'swagger' node is missing or malformed.");
-                }
-                return swaggerNode;
+}
+/**
+ * The getSwaggerObject method retrieves the Swagger object from the schema.
+ * Throws an error if the schema is not valid Swagger format.
+ */
+function getSwaggerObject(schema) {
+    if (schema !== null && typeof schema === 'object' && !Array.isArray(schema)) {
+        const properties = schema.properties;
+        if (typeof properties === 'object' && properties !== null && !Array.isArray(properties)) {
+            const swaggerNode = properties.swagger;
+            if (!swaggerNode || typeof swaggerNode !== 'object' || Array.isArray(swaggerNode)) {
+                throw new Error("Invalid schema format: 'swagger' node is missing or malformed.");
             }
+            return swaggerNode;
         }
-        throw new Error('Schema must be a JSON object with properties to extract swagger object');
     }
-    /*
-     * The processDefinitions function processes the definitions node of the Swagger schema.
-     * It collects model interface names and pushes generated code lines to modelLines.
-     */
-    static processDefinitions(swaggerObject, modelLines) {
-        const definitionTypes = [];
-        if ('definitions' in swaggerObject &&
-            typeof swaggerObject.definitions === 'object' &&
-            swaggerObject.definitions !== null &&
-            !Array.isArray(swaggerObject.definitions)) {
-            const definitionsObject = swaggerObject.definitions;
-            for (const [interfaceName, definitionValue] of Object.entries(definitionsObject)) {
-                if (definitionValue && typeof definitionValue === 'object' && !Array.isArray(definitionValue)) {
-                    const modelCode = this.generateModelFromSchema(interfaceName, definitionValue);
-                    modelLines.push(modelCode);
-                    modelLines.push(''); // Add a blank line between models
-                    definitionTypes.push(interfaceName);
-                }
+    throw new Error('Schema must be a JSON object with properties to extract swagger object');
+}
+/*
+ * The processDefinitions function processes the definitions node of the Swagger schema.
+ * It collects model interface names and pushes generated code lines to modelLines.
+ */
+function processDefinitions(swaggerObject, modelLines) {
+    const definitionTypes = [];
+    if ('definitions' in swaggerObject &&
+        typeof swaggerObject.definitions === 'object' &&
+        swaggerObject.definitions !== null &&
+        !Array.isArray(swaggerObject.definitions)) {
+        const definitionsObject = swaggerObject.definitions;
+        for (const [interfaceName, definitionValue] of Object.entries(definitionsObject)) {
+            if (definitionValue && typeof definitionValue === 'object' && !Array.isArray(definitionValue)) {
+                const modelCode = generateModelFromSchema(interfaceName, definitionValue);
+                modelLines.push(modelCode);
+                modelLines.push(''); // Add a blank line between models
+                definitionTypes.push(interfaceName);
             }
         }
-        return definitionTypes;
     }
-    /*
-     * The processParameters function processes the parameters node of the Swagger schema.
-     */
-    static processParameters(swaggerObject, modelLines) {
-        const parameterTypes = {};
-        if ('parameters' in swaggerObject &&
-            typeof swaggerObject.parameters === 'object' &&
-            swaggerObject.parameters !== null &&
-            !Array.isArray(swaggerObject.parameters)) {
-            const parametersObject = swaggerObject.parameters;
-            for (const [interfaceName, parameterValue] of Object.entries(parametersObject)) {
-                if (parameterValue && typeof parameterValue === 'object' && !Array.isArray(parameterValue)) {
-                    const { propertyInfo } = this.generateModelFromParameters(interfaceName, parameterValue);
-                    // Optionally: modelLines.push(modelCode); // If you want to collect interface code
-                    parameterTypes[interfaceName] = propertyInfo;
-                }
+    return definitionTypes;
+}
+/*
+ * The processParameters function processes the parameters node of the Swagger schema.
+ */
+function processParameters(swaggerObject, modelLines) {
+    const parameterTypes = {};
+    if ('parameters' in swaggerObject &&
+        typeof swaggerObject.parameters === 'object' &&
+        swaggerObject.parameters !== null &&
+        !Array.isArray(swaggerObject.parameters)) {
+        const parametersObject = swaggerObject.parameters;
+        for (const [interfaceName, parameterValue] of Object.entries(parametersObject)) {
+            if (parameterValue && typeof parameterValue === 'object' && !Array.isArray(parameterValue)) {
+                const { propertyInfo } = generateModelFromParameters(interfaceName, parameterValue);
+                // Optionally: modelLines.push(modelCode); // If you want to collect interface code
+                parameterTypes[interfaceName] = propertyInfo;
             }
         }
-        return parameterTypes;
-    }
-    /**
-     * Writes the lines to a file at the specified path.
-     *
-     * @param {string} filePath The path to the file to write
-     * @param {string[]} lines The lines to write to the file
-     * @param {boolean} [createDirPath=true] Create the directory path if it does not exist
-     */
-    static async writeToFile(filePath, lines, vfs, createDirPath = true) {
-        const dir = vfs.dirname(filePath);
-        if (createDirPath && !(await vfs.exists(dir))) {
-            await vfs.mkdir(dir, { recursive: true });
-        }
-        await vfs.writeFile(filePath, lines.join('\n'));
     }
-    /**
-     * The writeToFile method writes the generated code to a file from a string.
-     */
-    static async writeToFileWithContent(filePath, content, vfs) {
-        await vfs.writeFile(filePath, content);
+    return parameterTypes;
+}
+/**
+ * Writes the lines to a file at the specified path.
+ *
+ * @param {string} filePath The path to the file to write
+ * @param {string[]} lines The lines to write to the file
+ * @param {boolean} [createDirPath=true] Create the directory path if it does not exist
+ */
+async function writeToFile(filePath, lines, vfs, createDirPath = true) {
+    const dir = vfs.dirname(filePath);
+    if (createDirPath && !(await vfs.exists(dir))) {
+        await vfs.mkdir(dir, { recursive: true });
     }
-    /**
-     * The generateModelFromSchema method generates TypeScript models from the schema.
-     * Returns a type alias or interface definition string.
-     */
-    static generateModelFromSchema(modelName, definition) {
-        modelName = convertToValidIdentifier(this.simplifyGenericInterfaceName(modelName));
-        const lines = [];
-        // If it's a simple type (e.g., string, number, boolean) and has no "properties" or "items", generate a type alias
-        // Note: We exclude definitions with "items" because those are array types that need special handling
-        if ('type' in definition &&
-            definition.type &&
-            !('properties' in definition) &&
-            !('items' in definition)) {
-            const tsType = this.mapJsonTypeToTypeScript(definition.type);
-            lines.push(`export type ${modelName} = ${tsType};`);
-            return lines.join('\n');
-        }
-        // If it's an empty object, generate a type alias for object
-        const { isEmpty, itemsNode } = this.isEmptyObject(definition);
-        if (isEmpty) {
-            lines.push(this.generateTypeAliasForEmptyObject(modelName));
-            return lines.join('\n');
-        }
-        // Check if this is an array type definition
-        const isArrayType = definition.type === 'array' && itemsNode;
-        if (isArrayType) {
-            // For array types, generate an interface for the item type and a type alias for the array
-            const itemInterfaceName = `${modelName}Item`;
-            const itemModelCode = this.generatePropertyLines(itemInterfaceName, itemsNode);
-            lines.push(itemModelCode);
-            lines.push('');
-            lines.push(`export type ${modelName} = ${itemInterfaceName}[];`);
-            return lines.join('\n');
-        }
-        // If itemsNode exists but not an array type, pass that; otherwise, pass the full definition
-        const modelCode = itemsNode
-            ? this.generatePropertyLines(modelName, itemsNode)
-            : this.generatePropertyLines(modelName, definition);
-        lines.push(modelCode);
+    await vfs.writeFile(filePath, lines.join('\n'));
+}
+/**
+ * The writeToFile method writes the generated code to a file from a string.
+ */
+async function writeToFileWithContent(filePath, content, vfs) {
+    await vfs.writeFile(filePath, content);
+}
+/**
+ * The generateModelFromSchema method generates TypeScript models from the schema.
+ * Returns a type alias or interface definition string.
+ */
+function generateModelFromSchema(modelName, definition) {
+    modelName = convertToValidIdentifier(simplifyGenericInterfaceName(modelName));
+    const lines = [];
+    // If it's a simple type (e.g., string, number, boolean) and has no "properties" or "items", generate a type alias
+    // Note: We exclude definitions with "items" because those are array types that need special handling
+    if ('type' in definition && definition.type && !('properties' in definition) && !('items' in definition)) {
+        const tsType = mapJsonTypeToTypeScript(definition.type);
+        lines.push(`export type ${modelName} = ${tsType};`);
         return lines.join('\n');
     }
-    /**
-     * The simplifyGenericInterfaceName method simplifies the generic interface name.
-     * It removes the generic parameters from the name.
-     */
-    static simplifyGenericInterfaceName(modelName) {
-        return this.normalizeGenericTypeName(modelName);
-    }
-    /**
-     * The isEmptyObject method checks if the definition is an empty object.
-     * Returns an object with isEmpty (boolean) and itemsNode.
-     */
-    static isEmptyObject(definition) {
-        let itemsNode;
-        const hasNoProperties = !('properties' in definition) ||
-            typeof definition.properties !== 'object' ||
-            definition.properties === null ||
-            Array.isArray(definition.properties) ||
-            Object.keys(definition.properties).length === 0;
-        const hasNoItems = !('items' in definition) ||
-            typeof definition.items !== 'object' ||
-            definition.items === null ||
-            Array.isArray(definition.items) ||
-            Object.keys(definition.items).length === 0;
-        if ('items' in definition &&
-            typeof definition.items === 'object' &&
-            definition.items !== null &&
-            !Array.isArray(definition.items)) {
-            itemsNode = definition.items;
-        }
-        return { isEmpty: hasNoProperties && hasNoItems, itemsNode };
+    // If it's an empty object, generate a type alias for object
+    const { isEmpty, itemsNode } = isEmptyObject(definition);
+    if (isEmpty) {
+        lines.push(generateTypeAliasForEmptyObject(modelName));
+        return lines.join('\n');
     }
-    /**
-     * The generateTypeAliasForEmptyObject method generates a TypeScript type alias for an empty object.
-     */
-    static generateTypeAliasForEmptyObject(modelName) {
-        return `export type ${convertToValidIdentifier(modelName)} = object;`;
+    // Check if this is an array type definition
+    const isArrayType = definition.type === 'array' && itemsNode;
+    if (isArrayType) {
+        // For array types, generate an interface for the item type and a type alias for the array
+        const itemInterfaceName = `${modelName}Item`;
+        const itemModelCode = generatePropertyLines(itemInterfaceName, itemsNode);
+        lines.push(itemModelCode);
+        lines.push('');
+        lines.push(`export type ${modelName} = ${itemInterfaceName}[];`);
+        return lines.join('\n');
     }
-    /*
-     * The GeneratePropertyLines method generates TypeScript property lines from the schema.
-     */
-    static generatePropertyLines(modelName, definition, addInterfaceName = true, padding = '') {
-        if (!definition || typeof definition !== 'object' || Array.isArray(definition)) {
-            throw new Error('The definition must be a valid JSON object.');
-        }
-        const lines = [];
-        const requiredFields = this.getRequiredFields(definition);
-        const propertiesNode = this.getPropertiesNode(definition);
-        // Generate optionset enums first (before the interface)
-        const enumLines = this.generateOptionsetEnums(modelName, propertiesNode, padding);
-        if (enumLines.length > 0) {
-            lines.push(...enumLines);
+    // If itemsNode exists but not an array type, pass that; otherwise, pass the full definition
+    const modelCode = itemsNode
+        ? generatePropertyLines(modelName, itemsNode)
+        : generatePropertyLines(modelName, definition);
+    lines.push(modelCode);
+    return lines.join('\n');
+}
+/**
+ * The simplifyGenericInterfaceName method simplifies the generic interface name.
+ * It removes the generic parameters from the name.
+ */
+function simplifyGenericInterfaceName(modelName) {
+    return normalizeGenericTypeName(modelName);
+}
+/**
+ * The isEmptyObject method checks if the definition is an empty object.
+ * Returns an object with isEmpty (boolean) and itemsNode.
+ */
+function isEmptyObject(definition) {
+    let itemsNode;
+    const hasNoProperties = !('properties' in definition) ||
+        typeof definition.properties !== 'object' ||
+        definition.properties === null ||
+        Array.isArray(definition.properties) ||
+        Object.keys(definition.properties).length === 0;
+    const hasNoItems = !('items' in definition) ||
+        typeof definition.items !== 'object' ||
+        definition.items === null ||
+        Array.isArray(definition.items) ||
+        Object.keys(definition.items).length === 0;
+    if ('items' in definition &&
+        typeof definition.items === 'object' &&
+        definition.items !== null &&
+        !Array.isArray(definition.items)) {
+        itemsNode = definition.items;
+    }
+    return { isEmpty: hasNoProperties && hasNoItems, itemsNode };
+}
+/**
+ * The generateTypeAliasForEmptyObject method generates a TypeScript type alias for an empty object.
+ */
+function generateTypeAliasForEmptyObject(modelName) {
+    return `export type ${convertToValidIdentifier(modelName)} = object;`;
+}
+/*
+ * The GeneratePropertyLines method generates TypeScript property lines from the schema.
+ */
+function generatePropertyLines(modelName, definition, addInterfaceName = true, padding = '') {
+    if (!definition || typeof definition !== 'object' || Array.isArray(definition)) {
+        throw new Error('The definition must be a valid JSON object.');
+    }
+    const lines = [];
+    const requiredFields = getRequiredFields(definition);
+    const propertiesNode = getPropertiesNode(definition);
+    // Generate optionset enums first (before the interface)
+    // BUT only for top-level interfaces (addInterfaceName === true)
+    // Nested inline objects should not generate enums to avoid exporting them mid-interface
+    if (addInterfaceName) {
+        // Collect all enums including from nested objects
+        const allEnumLines = collectAllEnums(modelName, propertiesNode, padding);
+        if (allEnumLines.length > 0) {
+            lines.push(...allEnumLines);
             lines.push(''); // Add blank line between enums and interface
         }
-        this.addInterfaceDeclarationWithPadding(lines, modelName, addInterfaceName, padding);
-        for (const [propName, propValue] of Object.entries(propertiesNode)) {
-            let formattedPropName = formatPropertyName(convertToValidIdentifier(propName));
-            // Normalize specific property names (e.g., "resultsets" => "ResultSets")
-            formattedPropName = normalizePropertyName(formattedPropName);
-            const propValueAsObject = typeof propValue === 'object' && propValue !== null && !Array.isArray(propValue)
-                ? propValue
-                : undefined;
-            const tsType = this.determineTypeScriptType(modelName, propValueAsObject, padding, propName);
-            const optionalMark = requiredFields.has(propName) ? '' : '?';
-            this.addPropertyComment(lines, propValueAsObject, padding);
-            lines.push(`${padding}  ${formattedPropName}${optionalMark}: ${tsType};`);
+    }
+    addInterfaceDeclarationWithPadding(lines, modelName, addInterfaceName, padding);
+    for (const [propName, propValue] of Object.entries(propertiesNode)) {
+        let formattedPropName = formatPropertyName(convertToValidIdentifier(propName));
+        // Normalize specific property names (e.g., "resultsets" => "ResultSets")
+        formattedPropName = normalizePropertyName(formattedPropName);
+        const propValueAsObject = typeof propValue === 'object' && propValue !== null && !Array.isArray(propValue)
+            ? propValue
+            : undefined;
+        const tsType = determineTypeScriptType(modelName, propValueAsObject, padding, propName);
+        const optionalMark = requiredFields.has(propName) ? '' : '?';
+        addPropertyComment(lines, propValueAsObject, padding);
+        lines.push(`${padding}  ${formattedPropName}${optionalMark}: ${tsType};`);
+    }
+    closeInterfaceDeclarationWithPadding(lines, padding);
+    return lines.join('\n');
+}
+/**
+ * Recursively collects all enum declarations from properties, including nested objects.
+ * This ensures enums are hoisted to the top level and not exported mid-interface.
+ */
+function collectAllEnums(modelName, propertiesNode, padding) {
+    const enumLines = [];
+    for (const [propName, propValue] of Object.entries(propertiesNode)) {
+        const propValueAsObject = typeof propValue === 'object' && propValue !== null && !Array.isArray(propValue)
+            ? propValue
+            : undefined;
+        if (!propValueAsObject) {
+            continue;
+        }
+        // Check if this property has optionset data
+        if (hasOptionsetData(propValueAsObject)) {
+            const enumName = generateOptionsetEnumName(modelName, propName);
+            const enumDeclaration = generateOptionsetConstDeclaration(enumName, propValueAsObject, padding);
+            enumLines.push(enumDeclaration);
+        }
+        // Recursively collect enums from nested objects
+        if (propValueAsObject.properties && typeof propValueAsObject.properties === 'object') {
+            const nestedEnums = collectAllEnums(modelName, propValueAsObject.properties, padding);
+            enumLines.push(...nestedEnums);
+        }
+        // Recursively collect enums from array items
+        if (propValueAsObject.type === 'array' &&
+            propValueAsObject.items &&
+            typeof propValueAsObject.items === 'object' &&
+            !Array.isArray(propValueAsObject.items)) {
+            const itemsObj = propValueAsObject.items;
+            if (itemsObj.properties && typeof itemsObj.properties === 'object') {
+                const itemEnums = collectAllEnums(modelName, itemsObj.properties, padding);
+                enumLines.push(...itemEnums);
+            }
         }
-        this.closeInterfaceDeclarationWithPadding(lines, padding);
-        return lines.join('\n');
     }
-    /**
-     * Checks if a property has optionset data (enum and x-ms-enum-values)
-     */
-    static hasOptionsetData(propValue) {
-        const hasEnum = Array.isArray(propValue.enum) && propValue.enum.length > 0;
-        return hasEnum;
+    return enumLines;
+}
+/**
+ * Checks if a property has optionset data (enum and x-ms-enum-values)
+ */
+function hasOptionsetData(propValue) {
+    const hasEnum = Array.isArray(propValue.enum) && propValue.enum.length > 0;
+    return hasEnum;
+}
+/**
+ * Generates the enum name for an optionset property
+ */
+function generateOptionsetEnumName(modelName, propName) {
+    const formattedPropName = formatPropertyName(propName);
+    return `${modelName}${formattedPropName}`;
+}
+/**
+ * The generateOptionsetEnums method generates TypeScript const objects for optionset properties.
+ * These const objects are compatible with TypeScript's erasableSyntaxOnly flag and provide
+ * type safety while preserving the original numeric values from the schema.
+ * @returns An array of const object declaration strings.
+ */
+function generateOptionsetEnums(modelName, propertiesNode, padding) {
+    const enumLines = [];
+    for (const [propName, propValue] of Object.entries(propertiesNode)) {
+        const propValueAsObject = typeof propValue === 'object' && propValue !== null && !Array.isArray(propValue)
+            ? propValue
+            : undefined;
+        // Check if this property has optionset data
+        if (propValueAsObject && hasOptionsetData(propValueAsObject)) {
+            const enumName = generateOptionsetEnumName(modelName, propName);
+            const enumDeclaration = generateOptionsetConstDeclaration(enumName, propValueAsObject, padding);
+            enumLines.push(enumDeclaration);
+        }
+    }
+    return enumLines;
+}
+/**
+ * Formats an enum label as a quoted string literal, escaping single quotes.
+ * Returns an empty string literal for empty labels.
+ */
+function formatEnumLabel(label) {
+    if (!label || (typeof label === 'string' && label.trim() === '')) {
+        return `''`; // Placeholder for empty labels
     }
-    /**
-     * Generates the enum name for an optionset property
-     */
-    static generateOptionsetEnumName(modelName, propName) {
-        const formattedPropName = formatPropertyName(propName);
-        return `${modelName}${formattedPropName}`;
+    else {
+        // Escape single quotes in the label to prevent breaking the string literal
+        const escapedLabel = label.replace(/'/g, "\\'");
+        return `'${escapedLabel}'`;
     }
-    /**
-     * The generateOptionsetEnums method generates TypeScript const objects for optionset properties.
-     * These const objects are compatible with TypeScript's erasableSyntaxOnly flag and provide
-     * type safety while preserving the original numeric values from the schema.
-     * @returns An array of const object declaration strings.
-     */
-    static generateOptionsetEnums(modelName, propertiesNode, padding) {
-        const enumLines = [];
-        for (const [propName, propValue] of Object.entries(propertiesNode)) {
-            const propValueAsObject = typeof propValue === 'object' && propValue !== null && !Array.isArray(propValue)
-                ? propValue
-                : undefined;
-            // Check if this property has optionset data
-            if (propValueAsObject && this.hasOptionsetData(propValueAsObject)) {
-                const enumName = this.generateOptionsetEnumName(modelName, propName);
-                const enumDeclaration = this.generateOptionsetConstDeclaration(enumName, propValueAsObject, padding);
-                enumLines.push(enumDeclaration);
-            }
+}
+/**
+ * Generates const object declaration for an optionset property.
+ * Creates a const object with typed properties that is compatible with erasableSyntaxOnly.
+ * Also generates a corresponding type alias for type safety.
+ */
+function generateOptionsetConstDeclaration(enumName, propValue, padding) {
+    // Check for x-ms-enum-values format (array of objects or numbers)
+    const enumValues = propValue['x-ms-enum-values'];
+    const enumLabels = propValue.enum;
+    const lines = [];
+    enumName = convertToValidIdentifier(enumName);
+    // Check if x-ms-enum-values exists and is an array
+    if (enumValues && Array.isArray(enumValues) && enumLabels && Array.isArray(enumLabels)) {
+        // Check if x-ms-enum-values contains objects with numeric values (Dataverse format)
+        const hasObjectFormat = enumValues.length > 0 && typeof enumValues[0] === 'object' && enumValues[0] !== null;
+        if (hasObjectFormat) {
+            // This is the Swagger format where x-ms-enum-values contains objects like {displayName, value}
+            // Just use the enum array for string union type
+            const labelStrings = enumLabels.map((label) => formatEnumLabel(label));
+            lines.push(`${padding}export type ${enumName} = ${labelStrings.join('|')};`);
         }
-        return enumLines;
-    }
-    /**
-     * Generates const object declaration for an optionset property.
-     * Creates a const object with typed properties that is compatible with erasableSyntaxOnly.
-     * Also generates a corresponding type alias for type safety.
-     */
-    static generateOptionsetConstDeclaration(enumName, propValue, padding) {
-        // Check for x-ms-enum-values format
-        const enumNumericValues = propValue['x-ms-enum-values'];
-        const enumLabels = propValue.enum;
-        const lines = [];
-        enumName = convertToValidIdentifier(enumName);
-        if (enumNumericValues && Array.isArray(enumNumericValues) && enumLabels && Array.isArray(enumLabels)) {
-            // This is the path for dataverse where option sets have numeric values and display labels
+        else {
+            // This is the Dataverse format where x-ms-enum-values contains numeric values
+            const enumNumericValues = enumValues;
             // Generate const object with numeric keys
             lines.push(`${padding}export const ${enumName} = {`);
             // Handle the format where enum contains display names and x-ms-enum-values contains numeric values
@@ -632,1809 +689,1774 @@ export class ModelServiceGenerator {
             // Generate type alias for the numeric values
             lines.push(`${padding}export type ${enumName} = keyof typeof ${enumName};`);
         }
-        else {
-            // This is the path for swaggers where option sets have display labels only
-            const labelStrings = enumLabels.map((label) => {
-                if (!label || (typeof label === 'string' && label.trim() === '')) {
-                    return `''`; // Placeholder for empty labels
-                }
-                else {
-                    return `'${label}'`;
-                }
-            });
-            lines.push(`${padding}export type ${enumName} = ${labelStrings.join('|')};`);
-        }
-        return lines.join('\n');
     }
-    /*
-     * The addInterfaceDeclarationWithPadding function adds the interface declaration to the lines.
-     * It takes the lines to write to, model name, and padding as parameters.
-     */
-    static addInterfaceDeclarationWithPadding(lines, modelName, addInterfaceName, padding) {
-        if (addInterfaceName) {
-            lines.push(`${padding}export interface ${convertToValidIdentifier(modelName)} {`);
-        }
-        else {
-            lines.push(`{`);
-        }
+    else {
+        // This is the path for swaggers where only enum array exists (no x-ms-enum-values)
+        const labelStrings = enumLabels.map((label) => formatEnumLabel(label));
+        lines.push(`${padding}export type ${enumName} = ${labelStrings.join('|')};`);
     }
-    /*
-     * The closeInterfaceDeclarationWithPadding function closes the interface declaration with padding.
-     * It takes the lines to write to and padding as parameters.
-     */
-    static closeInterfaceDeclarationWithPadding(lines, padding) {
-        lines.push(`${padding}}`);
+    return lines.join('\n');
+}
+/*
+ * The addInterfaceDeclarationWithPadding function adds the interface declaration to the lines.
+ * It takes the lines to write to, model name, and padding as parameters.
+ */
+function addInterfaceDeclarationWithPadding(lines, modelName, addInterfaceName, padding) {
+    if (addInterfaceName) {
+        lines.push(`${padding}export interface ${convertToValidIdentifier(modelName)} {`);
     }
-    /*
-     * The getRequiredFields method retrieves the required fields from the definition.
-     * It returns a Set of required field names.
-     */
-    static getRequiredFields(definition) {
-        if ('required' in definition && Array.isArray(definition.required)) {
-            // Convert all entries to string and add to Set
-            return new Set(definition.required.map((r) => String(r)));
-        }
-        return new Set();
+    else {
+        lines.push(`{`);
     }
-    /*
-     * The getPropertiesNode method retrieves the properties node from the definition.
-     * It throws an error if the properties node is not found or is not a valid object.
-     */
-    static getPropertiesNode(definition) {
-        if (!('properties' in definition) ||
-            typeof definition.properties !== 'object' ||
-            definition.properties === null ||
-            Array.isArray(definition.properties)) {
-            throw new Error("The definition does not contain a valid 'properties' node.");
-        }
-        return definition.properties;
+}
+/*
+ * The closeInterfaceDeclarationWithPadding function closes the interface declaration with padding.
+ * It takes the lines to write to and padding as parameters.
+ */
+function closeInterfaceDeclarationWithPadding(lines, padding) {
+    lines.push(`${padding}}`);
+}
+/*
+ * The getRequiredFields method retrieves the required fields from the definition.
+ * It returns a Set of required field names.
+ */
+function getRequiredFields(definition) {
+    if ('required' in definition && Array.isArray(definition.required)) {
+        // Convert all entries to string and add to Set
+        return new Set(definition.required.map((r) => String(r)));
     }
-    /*
-     * The determineTypeScriptType method determines the TypeScript type for a property.
-     * It handles different cases such as arrays, nested properties, references, and optionsets.
-     */
-    static determineTypeScriptType(modelName, propValue, padding, propName) {
-        // Check if this property has optionset data first
-        if (propValue && propName && this.hasOptionsetData(propValue)) {
-            const enumName = this.generateOptionsetEnumName(modelName, propName);
-            return enumName;
-        }
-        if ((propValue === null || propValue === void 0 ? void 0 : propValue.type) === 'array' && typeof propValue.items === 'object' && propValue.items !== null) {
-            return this.determineArrayType(modelName, propValue.items, padding);
-        }
-        else if ((propValue === null || propValue === void 0 ? void 0 : propValue.properties) && typeof propValue.properties === 'object') {
-            return this.generatePropertyLines(modelName, propValue, false, padding + '  ');
-        }
-        else if (typeof (propValue === null || propValue === void 0 ? void 0 : propValue.$ref) === 'string') {
-            return this.extractReferencedType(propValue.$ref);
-        }
-        else {
-            return this.mapJsonTypeToTypeScript(propValue === null || propValue === void 0 ? void 0 : propValue.type);
-        }
+    return new Set();
+}
+/*
+ * The getPropertiesNode method retrieves the properties node from the definition.
+ * It throws an error if the properties node is not found or is not a valid object.
+ */
+function getPropertiesNode(definition) {
+    if (!('properties' in definition) ||
+        typeof definition.properties !== 'object' ||
+        definition.properties === null ||
+        Array.isArray(definition.properties)) {
+        throw new Error("The definition does not contain a valid 'properties' node.");
+    }
+    return definition.properties;
+}
+/*
+ * The determineTypeScriptType method determines the TypeScript type for a property.
+ * It handles different cases such as arrays, nested properties, references, and optionsets.
+ */
+function determineTypeScriptType(modelName, propValue, padding, propName) {
+    // Check if this property has optionset data first
+    if (propValue && propName && hasOptionsetData(propValue)) {
+        const enumName = generateOptionsetEnumName(modelName, propName);
+        return enumName;
     }
-    /*
-     * The determineArrayType method determines the TypeScript type for an array property.
-     * It handles different cases such as nested properties and references.
-     */
-    static determineArrayType(modelName, itemsNode, padding) {
-        if ('properties' in itemsNode && typeof itemsNode.properties === 'object') {
-            const inline = this.generatePropertyLines(modelName, itemsNode, false, padding + ' ');
-            return `${inline}[]`;
-        }
-        else if ('$ref' in itemsNode && typeof itemsNode.$ref === 'string') {
-            return `${this.extractReferencedType(itemsNode.$ref)}[]`;
-        }
-        else {
-            const itemType = ('type' in itemsNode ? itemsNode.type : 'unknown');
-            return this.mapJsonTypeToTypeScript(itemType) + '[]';
-        }
+    if ((propValue === null || propValue === void 0 ? void 0 : propValue.type) === 'array' && typeof propValue.items === 'object' && propValue.items !== null) {
+        return determineArrayType(modelName, propValue.items, padding);
     }
-    /*
-     * The extractReferencedType method extracts the referenced type from the ref value.
-     * It splits the ref value by '/' and returns the last part as the type name.
-     * The result is converted to a valid TypeScript identifier (e.g., spaces become underscores).
-     */
-    static extractReferencedType(refValue) {
-        const parts = refValue.split('/');
-        const typeName = parts[parts.length - 1];
-        return convertToValidIdentifier(this.normalizeGenericTypeName(typeName));
-    }
-    /*
-     * The mapDataverseTypeToTypeScript method maps Dataverse types to TypeScript types.
-     * Based on official Microsoft documentation: https://learn.microsoft.com/en-us/power-apps/maker/data-platform/types-of-fields
-     */
-    static mapDataverseTypeToTypeScript(dataverseType) {
-        const lowerType = dataverseType.toLowerCase();
-        switch (lowerType) {
-            // Text-based types - all map to string
-            case 'string':
-            case 'stringtype':
-            case 'text':
-            case 'textarea':
-            case 'multilinetext':
-            case 'memotype':
-            case 'memo':
-            case 'email':
-            case 'phone':
-            case 'url':
-            case 'tickersymbol':
-            case 'entityname':
-            case 'uniqueidentifier':
-            case 'uniqueidentifiertype':
-                return TypeScriptTypes.STRING;
-            // Choice/Picklist types - return string (option labels)
-            case 'picklist':
-            case 'picklisttype':
-            case 'choice':
-            case 'choicetype':
-            case 'choices':
-            case 'choicestype':
-            case 'multiselectpicklisttype':
-            case 'state':
-            case 'statetype':
-            case 'status':
-            case 'statustype':
-                return TypeScriptTypes.STRING;
-            // Number types
-            case 'integer':
-            case 'integertype':
-            case 'wholenumber':
-            case 'duration':
-            case 'language':
-            case 'timezone':
-                return TypeScriptTypes.NUMBER;
-            case 'bigint':
-            case 'biginttype':
-            case 'big':
-            case 'timestamp':
-                return TypeScriptTypes.NUMBER;
-            case 'decimal':
-            case 'decimaltype':
-            case 'decimalnumber':
-                return TypeScriptTypes.NUMBER;
-            case 'double':
-            case 'doubletype':
-            case 'floatingpointnumber':
-                return TypeScriptTypes.NUMBER;
-            case 'money':
-            case 'moneytype':
-            case 'currency':
-                return TypeScriptTypes.NUMBER;
-            // Boolean type
-            case 'boolean':
-            case 'booleantype':
-            case 'yesno':
-            case 'twooptions':
-                return TypeScriptTypes.BOOLEAN;
-            // Date/Time types
-            case 'datetime':
-            case 'datetimetype':
-            case 'dateonly':
-                return TypeScriptTypes.DATE;
-            // Lookup types - return string (typically GUID or display name)
-            case 'lookup':
-            case 'lookuptype':
-            case 'customer':
-            case 'customertype':
-            case 'owner':
-            case 'ownertype':
-                return TypeScriptTypes.STRING;
-            // Binary/File types - return string (base64 or URL)
-            case 'file':
-            case 'filetype':
-            case 'image':
-            case 'imagetype':
-                return TypeScriptTypes.STRING;
-            // Special types
-            case 'virtual':
-            case 'virtualtype':
-            case 'formula':
-            case 'formulatype':
-                return TypeScriptTypes.STRING;
-            default:
-                return TypeScriptTypes.STRING; // Default Dataverse fields to string
-        }
+    else if ((propValue === null || propValue === void 0 ? void 0 : propValue.properties) && typeof propValue.properties === 'object') {
+        return generatePropertyLines(modelName, propValue, false, padding + '  ');
     }
-    /*
-     * The mapJsonTypeToTypeScript method maps JSON types to TypeScript types.
-     */
-    static mapJsonTypeToTypeScript(jsonType) {
-        switch (jsonType) {
-            case 'string':
-                return TypeScriptTypes.STRING;
-            case 'number':
-            case 'integer':
-                return TypeScriptTypes.NUMBER;
-            case 'boolean':
-                return TypeScriptTypes.BOOLEAN;
-            case 'object':
-                return TypeScriptTypes.OBJECT;
-            default:
-                return TypeScriptTypes.UNKNOWN;
-        }
+    else if (typeof (propValue === null || propValue === void 0 ? void 0 : propValue.$ref) === 'string') {
+        return extractReferencedType(propValue.$ref);
     }
-    /*
-     * The addPropertyComment method adds a comment for the property.
-     */
-    static addPropertyComment(lines, propValue, padding) {
-        if ((propValue === null || propValue === void 0 ? void 0 : propValue.description) && typeof propValue.description === 'string') {
-            lines.push(`${padding}  // ${propValue.description}`);
-        }
+    else {
+        return mapJsonTypeToTypeScript(propValue === null || propValue === void 0 ? void 0 : propValue.type);
     }
-    /*
-     * The generateModelFromParameters method generates TypeScript models from the parameters.
-     */
-    static generateModelFromParameters(modelName, parameterObject) {
-        const lines = [];
-        this.addInterfaceDeclaration(lines, modelName);
-        const propName = this.getParameterName(parameterObject, 'name');
-        const tsType = this.determineParameterType(parameterObject);
-        const optionalMark = this.isParameterRequired(parameterObject) ? '' : '?';
-        const propertyDefinition = `${propName}${optionalMark}: ${tsType}`;
-        lines.push(`  ${propertyDefinition};`);
-        this.closeInterfaceDeclaration(lines);
-        const propertyInfo = new ParameterPropertyInfo(propName, propertyDefinition);
-        return { modelCode: lines.join('\n'), propertyInfo };
-    }
-    /*
-     * The addInterfaceDeclaration method adds the interface declaration to the lines.
-     * It takes the lines to write to and model name as parameters.
-     */
-    static addInterfaceDeclaration(lines, modelName) {
-        lines.push(`export interface ${convertToValidIdentifier(modelName)} {`);
+}
+/*
+ * The determineArrayType method determines the TypeScript type for an array property.
+ * It handles different cases such as nested properties and references.
+ */
+function determineArrayType(modelName, itemsNode, padding) {
+    if ('properties' in itemsNode && typeof itemsNode.properties === 'object') {
+        const inline = generatePropertyLines(modelName, itemsNode, false, padding + ' ');
+        return `${inline}[]`;
     }
-    /*
-     * The closeInterfaceDeclaration method closes the interface declaration.
-     */
-    static closeInterfaceDeclaration(lines) {
-        lines.push('}');
+    else if ('$ref' in itemsNode && typeof itemsNode.$ref === 'string') {
+        return `${extractReferencedType(itemsNode.$ref)}[]`;
     }
-    /*
-     * The determineParameterType method determines the type of the parameter.
-     * It takes the parameter object as input and returns the type as a string.
-     */
-    static determineParameterType(parameterObject) {
-        if ('type' in parameterObject && typeof parameterObject.type === 'string') {
-            return this.mapJsonTypeToTypeScript(parameterObject.type);
-        }
-        return 'unknown';
+    else {
+        const itemType = ('type' in itemsNode ? itemsNode.type : 'unknown');
+        return mapJsonTypeToTypeScript(itemType) + '[]';
     }
-    /*
-     * The isParameterRequired method checks if the parameter is required.
-     * It takes the parameter object as input and returns true if required, otherwise false.
-     */
-    static isParameterRequired(parameterObject) {
-        return ('required' in parameterObject &&
-            (parameterObject.required === true || parameterObject.required === 'true'));
+}
+/*
+ * The extractReferencedType method extracts the referenced type from the ref value.
+ * It splits the ref value by '/' and returns the last part as the type name.
+ * The result is converted to a valid TypeScript identifier (e.g., spaces become underscores).
+ */
+function extractReferencedType(refValue) {
+    const parts = refValue.split('/');
+    const typeName = parts[parts.length - 1];
+    return convertToValidIdentifier(normalizeGenericTypeName(typeName));
+}
+/*
+ * The mapDataverseTypeToTypeScript method maps Dataverse types to TypeScript types.
+ * Based on official Microsoft documentation: https://learn.microsoft.com/en-us/power-apps/maker/data-platform/types-of-fields
+ */
+function mapDataverseTypeToTypeScript(dataverseType) {
+    const lowerType = dataverseType.toLowerCase();
+    switch (lowerType) {
+        // Text-based types - all map to string
+        case 'string':
+        case 'stringtype':
+        case 'text':
+        case 'textarea':
+        case 'multilinetext':
+        case 'memotype':
+        case 'memo':
+        case 'email':
+        case 'phone':
+        case 'url':
+        case 'tickersymbol':
+        case 'entityname':
+        case 'uniqueidentifier':
+        case 'uniqueidentifiertype':
+            return TypeScriptTypes.STRING;
+        // Choice/Picklist types - return string (option labels)
+        case 'picklist':
+        case 'picklisttype':
+        case 'choice':
+        case 'choicetype':
+        case 'choices':
+        case 'choicestype':
+        case 'multiselectpicklisttype':
+        case 'state':
+        case 'statetype':
+        case 'status':
+        case 'statustype':
+            return TypeScriptTypes.STRING;
+        // Number types
+        case 'integer':
+        case 'integertype':
+        case 'wholenumber':
+        case 'duration':
+        case 'language':
+        case 'timezone':
+            return TypeScriptTypes.NUMBER;
+        case 'bigint':
+        case 'biginttype':
+        case 'big':
+        case 'timestamp':
+            return TypeScriptTypes.NUMBER;
+        case 'decimal':
+        case 'decimaltype':
+        case 'decimalnumber':
+            return TypeScriptTypes.NUMBER;
+        case 'double':
+        case 'doubletype':
+        case 'floatingpointnumber':
+            return TypeScriptTypes.NUMBER;
+        case 'money':
+        case 'moneytype':
+        case 'currency':
+            return TypeScriptTypes.NUMBER;
+        // Boolean type
+        case 'boolean':
+        case 'booleantype':
+        case 'yesno':
+        case 'twooptions':
+            return TypeScriptTypes.BOOLEAN;
+        // Date/Time types
+        case 'datetime':
+        case 'datetimetype':
+        case 'dateonly':
+            return TypeScriptTypes.DATE;
+        // Lookup types - return string (typically GUID or display name)
+        case 'lookup':
+        case 'lookuptype':
+        case 'customer':
+        case 'customertype':
+        case 'owner':
+        case 'ownertype':
+            return TypeScriptTypes.STRING;
+        // Binary/File types - return string (base64 or URL)
+        case 'file':
+        case 'filetype':
+        case 'image':
+        case 'imagetype':
+            return TypeScriptTypes.STRING;
+        // Special types
+        case 'virtual':
+        case 'virtualtype':
+        case 'formula':
+        case 'formulatype':
+            return TypeScriptTypes.STRING;
+        default:
+            return TypeScriptTypes.STRING; // Default Dataverse fields to string
     }
-    /*
-     * The generateServiceFromPaths method generates the service class from the paths node.
-     */
-    static generateServiceFromPaths(modelName, dataSourceName, pathsNode, parameterTypes) {
-        const lines = [];
-        this.addCopyrightNotice(lines);
-        const imports = this.collectStandardImports();
-        const operations = this.processPaths(pathsNode, modelName, dataSourceName, imports, parameterTypes);
-        this.addImports(lines, imports);
-        this.addClassDefinition(lines, modelName, dataSourceName, operations);
-        return lines.join('\n');
+}
+/*
+ * The mapJsonTypeToTypeScript method maps JSON types to TypeScript types.
+ */
+function mapJsonTypeToTypeScript(jsonType) {
+    switch (jsonType) {
+        case 'string':
+            return TypeScriptTypes.STRING;
+        case 'number':
+        case 'integer':
+            return TypeScriptTypes.NUMBER;
+        case 'boolean':
+            return TypeScriptTypes.BOOLEAN;
+        case 'object':
+            return TypeScriptTypes.OBJECT;
+        default:
+            return TypeScriptTypes.UNKNOWN;
     }
-    /*
-     * The collectStandardImports method collects the standard imports for the service class.
-     * It returns a Set of import statements.
-     */
-    static collectStandardImports(importType = 'execute') {
-        if (!_a._schemaFolderPath || !_a._outputDir) {
-            throw new Error('collectStandardImports called before generator context was initialized. Ensure run() was invoked.');
-        }
-        const vfs = getVfs();
-        // Services are always emitted under <outputDir>/generated/services
-        const servicesDir = vfs.join(_a._outputDir, this.SERVICES_FOLDER);
-        // path to dataSourcesInfo.ts
-        const dataSourceInfoPath = vfs.join(_a._schemaFolderPath, 'appschemas', 'dataSourcesInfo');
-        let relativePath = path.relative(servicesDir, dataSourceInfoPath).replace(/\\/g, '/');
-        if (!relativePath.startsWith('.') && !relativePath.startsWith('/')) {
-            relativePath = `./${relativePath}`;
-        }
-        // Base imports common to both CRUD & execute contexts
-        const imports = new Set([
-            `import { dataSourcesInfo } from '${relativePath}';`,
-            "import type { IOperationResult } from '@microsoft/power-apps/data';",
-            "import { getClient } from '@microsoft/power-apps/data';",
-        ]);
-        // Reserved for future differentiation if importType impacts imports
-        // Currently identical for 'crud' | 'execute' | 'both'.
-        return imports;
-    }
-    /*
-     * The processPaths method processes the paths node of the Swagger schema.
-     * It extracts the operations and generates the methods for the service class.
-     * It takes the paths node, model name, data source name, and imports set as parameters.
-     * It returns a list of operations as strings.
-     */
-    static processPaths(pathsNode, modelName, dataSourceName, imports, parameterTypes) {
-        const operations = [];
-        for (const pathKey in pathsNode) {
-            if (!Object.prototype.hasOwnProperty.call(pathsNode, pathKey)) {
-                continue;
-            }
-            const pathObject = pathsNode[pathKey];
-            if (typeof pathObject === 'object' && pathObject !== null && !Array.isArray(pathObject)) {
-                const pathObjectTyped = pathObject;
-                for (const operationKey in pathObjectTyped) {
-                    if (!Object.prototype.hasOwnProperty.call(pathObjectTyped, operationKey)) {
-                        continue;
-                    }
-                    const operationObject = pathObjectTyped[operationKey];
-                    if (typeof operationObject === 'object' &&
-                        operationObject !== null &&
-                        !Array.isArray(operationObject)) {
-                        this.processOperation(operationObject, modelName, dataSourceName, imports, operations, parameterTypes);
-                    }
-                }
-            }
-        }
-        return operations;
+}
+/*
+ * The addPropertyComment method adds a comment for the property.
+ */
+function addPropertyComment(lines, propValue, padding) {
+    if ((propValue === null || propValue === void 0 ? void 0 : propValue.description) && typeof propValue.description === 'string') {
+        lines.push(`${padding}  // ${propValue.description}`);
     }
-    /*
-     * The processOperation method processes each operation in the path object.
-     * It extracts the operation ID, summary, description, and parameters.
-     * It generates the method for the service class.
-     */
-    static processOperation(operationObject, modelName, dataSourceName, imports, operations, parameterTypes) {
-        if (!('operationId' in operationObject)) {
-            return;
-        }
-        const operationId = String(operationObject.operationId);
-        const summary = 'summary' in operationObject ? String(operationObject.summary) : '';
-        const description = 'description' in operationObject ? String(operationObject.description) : '';
-        const outputModel = this.determineOutputModel(operationObject, modelName, imports);
-        const { parametersList, parametersProps } = this.collectParameters(operationObject, modelName, imports, parameterTypes);
-        this.generateOperationMethod(operations, operationId, summary, description, parametersList, parametersProps, outputModel, modelName);
-    }
-    /*
-     * The determineOutputModel method determines the output model for the operation.
-     * It takes the operation object, model name, and imports set as parameters.
-     * It returns the output model as a string.
-     */
-    static determineOutputModel(operationObject, modelName, imports) {
-        if ('responses' in operationObject &&
-            typeof operationObject.responses === 'object' &&
-            operationObject.responses !== null) {
-            const responsesObj = operationObject.responses;
-            if (typeof responsesObj === 'object' &&
-                responsesObj !== null &&
-                !Array.isArray(responsesObj) &&
-                '200' in responsesObj) {
-                const responsesObject = responsesObj;
-                const response200Value = responsesObject['200'];
-                if (typeof response200Value === 'object' &&
-                    response200Value !== null &&
-                    !Array.isArray(response200Value)) {
-                    const response200Obj = response200Value;
-                    if ('schema' in response200Obj &&
-                        typeof response200Obj.schema === 'object' &&
-                        response200Obj.schema !== null &&
-                        !Array.isArray(response200Obj.schema)) {
-                        const schemaObj = response200Obj.schema;
-                        return this.extractOutputModelFromSchema(schemaObj, modelName, imports);
-                    }
+}
+/*
+ * The generateModelFromParameters method generates TypeScript models from the parameters.
+ */
+function generateModelFromParameters(modelName, parameterObject) {
+    const lines = [];
+    addInterfaceDeclaration(lines, modelName);
+    const propName = getParameterName(parameterObject, 'name');
+    const tsType = determineParameterType(parameterObject);
+    const optionalMark = isParameterRequired(parameterObject) ? '' : '?';
+    const propertyDefinition = `${propName}${optionalMark}: ${tsType}`;
+    lines.push(`  ${propertyDefinition};`);
+    closeInterfaceDeclaration(lines);
+    const propertyInfo = new ParameterPropertyInfo(propName, propertyDefinition);
+    return { modelCode: lines.join('\n'), propertyInfo };
+}
+/*
+ * The addInterfaceDeclaration method adds the interface declaration to the lines.
+ * It takes the lines to write to and model name as parameters.
+ */
+function addInterfaceDeclaration(lines, modelName) {
+    lines.push(`export interface ${convertToValidIdentifier(modelName)} {`);
+}
+/*
+ * The closeInterfaceDeclaration method closes the interface declaration.
+ */
+function closeInterfaceDeclaration(lines) {
+    lines.push('}');
+}
+/*
+ * The determineParameterType method determines the type of the parameter.
+ * It takes the parameter object as input and returns the type as a string.
+ */
+function determineParameterType(parameterObject) {
+    if ('type' in parameterObject && typeof parameterObject.type === 'string') {
+        return mapJsonTypeToTypeScript(parameterObject.type);
+    }
+    return 'unknown';
+}
+/*
+ * The isParameterRequired method checks if the parameter is required.
+ * It takes the parameter object as input and returns true if required, otherwise false.
+ */
+function isParameterRequired(parameterObject) {
+    return ('required' in parameterObject &&
+        (parameterObject.required === true || parameterObject.required === 'true'));
+}
+/*
+ * The generateServiceFromPaths method generates the service class from the paths node.
+ */
+function generateServiceFromPaths(modelName, dataSourceName, pathsNode, parameterTypes) {
+    const lines = [];
+    addCopyrightNotice(lines);
+    const imports = collectStandardImports();
+    const operations = processPaths(pathsNode, modelName, dataSourceName, imports, parameterTypes);
+    addImports(lines, imports);
+    addClassDefinition(lines, modelName, dataSourceName, operations);
+    return lines.join('\n');
+}
+/*
+ * The collectStandardImports method collects the standard imports for the service class.
+ * It returns a Set of import statements.
+ */
+function collectStandardImports(importType = 'execute') {
+    if (!_schemaFolderPath || !_outputDir) {
+        throw new Error('collectStandardImports called before generator context was initialized. Ensure generateModelService() was invoked.');
+    }
+    const vfs = getVfs();
+    // Services are always emitted under <outputDir>/generated/services
+    const servicesDir = vfs.join(_outputDir, SERVICES_FOLDER);
+    // path to dataSourcesInfo.ts
+    const dataSourceInfoPath = vfs.join(_schemaFolderPath, 'appschemas', 'dataSourcesInfo');
+    let relativePath = path.relative(servicesDir, dataSourceInfoPath).replace(/\\/g, '/');
+    if (!relativePath.startsWith('.') && !relativePath.startsWith('/')) {
+        relativePath = `./${relativePath}`;
+    }
+    // Base imports common to both CRUD & execute contexts
+    const imports = new Set([
+        `import { dataSourcesInfo } from '${relativePath}';`,
+        "import type { IOperationResult } from '@microsoft/power-apps/data';",
+        "import { getClient } from '@microsoft/power-apps/data';",
+    ]);
+    // Reserved for future differentiation if importType impacts imports
+    // Currently identical for 'crud' | 'execute' | 'both'.
+    return imports;
+}
+/*
+ * The processPaths method processes the paths node of the Swagger schema.
+ * It extracts the operations and generates the methods for the service class.
+ * It takes the paths node, model name, data source name, and imports set as parameters.
+ * It returns a list of operations as strings.
+ */
+function processPaths(pathsNode, modelName, dataSourceName, imports, parameterTypes) {
+    const operations = [];
+    for (const pathKey in pathsNode) {
+        if (!Object.prototype.hasOwnProperty.call(pathsNode, pathKey)) {
+            continue;
+        }
+        const pathObject = pathsNode[pathKey];
+        if (typeof pathObject === 'object' && pathObject !== null && !Array.isArray(pathObject)) {
+            const pathObjectTyped = pathObject;
+            for (const operationKey in pathObjectTyped) {
+                if (!Object.prototype.hasOwnProperty.call(pathObjectTyped, operationKey)) {
+                    continue;
+                }
+                const operationObject = pathObjectTyped[operationKey];
+                if (typeof operationObject === 'object' &&
+                    operationObject !== null &&
+                    !Array.isArray(operationObject)) {
+                    processOperation(operationObject, modelName, dataSourceName, imports, operations, parameterTypes);
                 }
             }
         }
-        return 'void';
     }
-    /*
-     * The collectParameters method collects the parameters from the operation object.
-     * It takes the operation object, model name, and imports set as parameters.
-     * It returns an object containing the parameters list and parameters properties.
-     */
-    static collectParameters(operationObject, modelName, imports, parameterTypes) {
-        let parametersList = [];
-        let parametersProps = [];
-        if ('parameters' in operationObject && Array.isArray(operationObject.parameters)) {
-            const paramsArray = operationObject.parameters;
-            const orderedParams = this.getOrderedPropertiesByRequired(paramsArray);
-            for (const property of orderedParams) {
-                // property.Value in C# is property.value in TS - use property.value for the parameter object
-                const result = this.processRequestParameters(property.value, modelName, imports, parametersList, parametersProps, 'name', parameterTypes);
-                parametersList = result[0];
-                parametersProps = result[1];
+    return operations;
+}
+/*
+ * The processOperation method processes each operation in the path object.
+ * It extracts the operation ID, summary, description, and parameters.
+ * It generates the method for the service class.
+ */
+function processOperation(operationObject, modelName, dataSourceName, imports, operations, parameterTypes) {
+    if (!('operationId' in operationObject)) {
+        return;
+    }
+    const operationId = String(operationObject.operationId);
+    const summary = 'summary' in operationObject ? String(operationObject.summary) : '';
+    const description = 'description' in operationObject ? String(operationObject.description) : '';
+    const outputModel = determineOutputModel(operationObject, modelName, imports);
+    const { parametersList, parametersProps } = collectParameters(operationObject, modelName, imports, parameterTypes);
+    generateOperationMethod(operations, operationId, summary, description, parametersList, parametersProps, outputModel, modelName);
+}
+/*
+ * The determineOutputModel method determines the output model for the operation.
+ * It takes the operation object, model name, and imports set as parameters.
+ * It returns the output model as a string.
+ */
+function determineOutputModel(operationObject, modelName, imports) {
+    if ('responses' in operationObject &&
+        typeof operationObject.responses === 'object' &&
+        operationObject.responses !== null) {
+        const responsesObj = operationObject.responses;
+        if (typeof responsesObj === 'object' &&
+            responsesObj !== null &&
+            !Array.isArray(responsesObj) &&
+            '200' in responsesObj) {
+            const responsesObject = responsesObj;
+            const response200Value = responsesObject['200'];
+            if (typeof response200Value === 'object' &&
+                response200Value !== null &&
+                !Array.isArray(response200Value)) {
+                const response200Obj = response200Value;
+                if ('schema' in response200Obj &&
+                    typeof response200Obj.schema === 'object' &&
+                    response200Obj.schema !== null &&
+                    !Array.isArray(response200Obj.schema)) {
+                    const schemaObj = response200Obj.schema;
+                    return extractOutputModelFromSchema(schemaObj, modelName, imports);
+                }
             }
         }
-        return { parametersList, parametersProps };
     }
-    /*
-     * The addImports method adds the import statements to the lines.
-     * It takes the lines to write to and the imports set as parameters.
-     */
-    static addImports(lines, imports) {
-        const sortedImports = Array.from(imports);
-        sortedImports.sort();
-        lines.push(...sortedImports);
-    }
-    /*
-     * The addClassDefinition method adds the class definition to the lines.
-     * It takes the lines to write to, model name, data source name, and operations as parameters.
-     */
-    static addClassDefinition(lines, modelName, dataSourceName, operations) {
-        this.addServiceClassHeader(lines, modelName, dataSourceName);
-        lines.push(...operations);
-        lines.push('}');
+    return 'void';
+}
+/*
+ * The collectParameters method collects the parameters from the operation object.
+ * It takes the operation object, model name, and imports set as parameters.
+ * It returns an object containing the parameters list and parameters properties.
+ */
+function collectParameters(operationObject, modelName, imports, parameterTypes) {
+    let parametersList = [];
+    let parametersProps = [];
+    if ('parameters' in operationObject && Array.isArray(operationObject.parameters)) {
+        const paramsArray = operationObject.parameters;
+        const orderedParams = getOrderedPropertiesByRequired(paramsArray);
+        for (const property of orderedParams) {
+            // property.Value in C# is property.value in TS - use property.value for the parameter object
+            const result = processRequestParameters(property.value, modelName, imports, parametersList, parametersProps, 'name', parameterTypes);
+            parametersList = result[0];
+            parametersProps = result[1];
+        }
+    }
+    return { parametersList, parametersProps };
+}
+/*
+ * The addImports method adds the import statements to the lines.
+ * It takes the lines to write to and the imports set as parameters.
+ */
+function addImports(lines, imports) {
+    const sortedImports = Array.from(imports);
+    sortedImports.sort();
+    lines.push(...sortedImports);
+}
+/*
+ * The addClassDefinition method adds the class definition to the lines.
+ * It takes the lines to write to, model name, data source name, and operations as parameters.
+ */
+function addClassDefinition(lines, modelName, dataSourceName, operations) {
+    addServiceClassHeader(lines, modelName, dataSourceName);
+    lines.push(...operations);
+    lines.push('}');
+    lines.push('');
+}
+/*
+ * The addServiceClassHeader method adds the service class header to the lines.
+ * It takes the lines to write to, model name, and data source name as parameters.
+ */
+function addServiceClassHeader(lines, modelName, dataSourceName, additionalLine = true) {
+    if (additionalLine) {
         lines.push('');
     }
-    /*
-     * The addServiceClassHeader method adds the service class header to the lines.
-     * It takes the lines to write to, model name, and data source name as parameters.
-     */
-    static addServiceClassHeader(lines, modelName, dataSourceName, additionalLine = true) {
-        if (additionalLine) {
-            lines.push('');
-        }
-        lines.push(`export class ${modelName}Service {`);
-        this.addServiceFields(lines, dataSourceName);
-    }
-    /*
-     * The extractOutputModelFromSchema method extracts the output model from the schema object.
-     */
-    static extractOutputModelFromSchema(schemaObj, modelName, imports) {
-        let outputModel = '';
-        if (this.tryExtractArrayOutputModel(schemaObj, modelName, imports, (result) => {
-            outputModel = result;
-        })) {
-            return outputModel;
-        }
-        if (this.tryExtractDirectRefOutputModel(schemaObj, modelName, imports, (result) => {
-            outputModel = result;
-        })) {
-            return outputModel;
-        }
-        const [found, typeOutputModel] = this.tryExtractTypeOutputModel(schemaObj);
-        if (found) {
-            outputModel = typeOutputModel;
-            return outputModel;
-        }
-        return 'void'; // Default to void if no specific type is defined
-    }
-    /*
-     * The tryExtractArrayOutputModel method extracts the array output model from the schema object.
-     * Returns true if type is successfully extracted, otherwise false.
-     */
-    static tryExtractArrayOutputModel(schemaObj, modelName, imports, setOutputModel) {
-        // First case: properties.value.type === 'array' && properties.value.items.$ref
-        if ('properties' in schemaObj &&
-            typeof schemaObj.properties === 'object' &&
-            schemaObj.properties !== null &&
-            !Array.isArray(schemaObj.properties)) {
-            const propertiesObj = schemaObj.properties;
-            if ('value' in propertiesObj &&
-                typeof propertiesObj.value === 'object' &&
-                propertiesObj.value !== null &&
-                !Array.isArray(propertiesObj.value)) {
-                const valueObj = propertiesObj.value;
-                if ('type' in valueObj &&
-                    valueObj.type === 'array' &&
-                    'items' in valueObj &&
-                    typeof valueObj.items === 'object' &&
-                    valueObj.items !== null &&
-                    !Array.isArray(valueObj.items)) {
-                    const itemsObj = valueObj.items;
-                    if ('$ref' in itemsObj && typeof itemsObj.$ref === 'string') {
-                        const refType = this.extractReferencedType(itemsObj.$ref);
-                        setOutputModel(`{ value: ${refType}[] }`);
-                        this.addImport(refType, modelName, imports);
-                        return true;
-                    }
+    lines.push(`export class ${modelName}Service {`);
+    addServiceFields(lines, dataSourceName);
+}
+/*
+ * The extractOutputModelFromSchema method extracts the output model from the schema object.
+ */
+function extractOutputModelFromSchema(schemaObj, modelName, imports) {
+    let outputModel = '';
+    if (tryExtractArrayOutputModel(schemaObj, modelName, imports, (result) => {
+        outputModel = result;
+    })) {
+        return outputModel;
+    }
+    if (tryExtractDirectRefOutputModel(schemaObj, modelName, imports, (result) => {
+        outputModel = result;
+    })) {
+        return outputModel;
+    }
+    const [found, typeOutputModel] = tryExtractTypeOutputModel(schemaObj);
+    if (found) {
+        outputModel = typeOutputModel;
+        return outputModel;
+    }
+    return 'void'; // Default to void if no specific type is defined
+}
+/*
+ * The tryExtractArrayOutputModel method extracts the array output model from the schema object.
+ * Returns true if type is successfully extracted, otherwise false.
+ */
+function tryExtractArrayOutputModel(schemaObj, modelName, imports, setOutputModel) {
+    // First case: properties.value.type === 'array' && properties.value.items.$ref
+    if ('properties' in schemaObj &&
+        typeof schemaObj.properties === 'object' &&
+        schemaObj.properties !== null &&
+        !Array.isArray(schemaObj.properties)) {
+        const propertiesObj = schemaObj.properties;
+        if ('value' in propertiesObj &&
+            typeof propertiesObj.value === 'object' &&
+            propertiesObj.value !== null &&
+            !Array.isArray(propertiesObj.value)) {
+            const valueObj = propertiesObj.value;
+            if ('type' in valueObj &&
+                valueObj.type === 'array' &&
+                'items' in valueObj &&
+                typeof valueObj.items === 'object' &&
+                valueObj.items !== null &&
+                !Array.isArray(valueObj.items)) {
+                const itemsObj = valueObj.items;
+                if ('$ref' in itemsObj && typeof itemsObj.$ref === 'string') {
+                    const refType = extractReferencedType(itemsObj.$ref);
+                    setOutputModel(`{ value: ${refType}[] }`);
+                    addImport(refType, modelName, imports);
+                    return true;
                 }
             }
         }
-        // Second case: type === 'array' && items.$ref
-        if ('type' in schemaObj &&
-            schemaObj.type === 'array' &&
-            'items' in schemaObj &&
-            typeof schemaObj.items === 'object' &&
-            schemaObj.items !== null &&
-            !Array.isArray(schemaObj.items)) {
-            const itemsObj = schemaObj.items;
-            if ('$ref' in itemsObj && typeof itemsObj.$ref === 'string') {
-                const refType = this.extractReferencedType(itemsObj.$ref);
-                setOutputModel(`${refType}[]`);
-                this.addImport(refType, modelName, imports);
-                return true;
-            }
-        }
-        return false;
     }
-    /*
-     * The tryExtractDirectRefOutputModel method extracts the direct reference output model from the schema object.
-     * Returns true if type is successfully extracted, otherwise false.
-     */
-    static tryExtractDirectRefOutputModel(schemaObj, modelName, imports, setOutputModel) {
-        // Case: items.$ref
-        if ('items' in schemaObj &&
-            typeof schemaObj.items === 'object' &&
-            schemaObj.items !== null &&
-            !Array.isArray(schemaObj.items)) {
-            const itemsObj = schemaObj.items;
-            if ('$ref' in itemsObj && typeof itemsObj.$ref === 'string') {
-                const outputModel = this.simplifyGenericTypeName(this.extractReferencedType(itemsObj.$ref));
-                setOutputModel(outputModel);
-                this.addImport(outputModel, modelName, imports);
-                return true;
-            }
-        }
-        // Case: $ref
-        if ('$ref' in schemaObj && typeof schemaObj.$ref === 'string') {
-            const outputModel = this.simplifyGenericTypeName(this.extractReferencedType(schemaObj.$ref));
-            setOutputModel(outputModel);
-            this.addImport(outputModel, modelName, imports);
+    // Second case: type === 'array' && items.$ref
+    if ('type' in schemaObj &&
+        schemaObj.type === 'array' &&
+        'items' in schemaObj &&
+        typeof schemaObj.items === 'object' &&
+        schemaObj.items !== null &&
+        !Array.isArray(schemaObj.items)) {
+        const itemsObj = schemaObj.items;
+        if ('$ref' in itemsObj && typeof itemsObj.$ref === 'string') {
+            const refType = extractReferencedType(itemsObj.$ref);
+            setOutputModel(`${refType}[]`);
+            addImport(refType, modelName, imports);
             return true;
         }
-        return false;
     }
-    /*
-     * The tryExtractTypeOutputModel method extracts the type output model from the schema object.
-     * Returns a tuple: [found: boolean, outputModel: string].
-     */
-    static tryExtractTypeOutputModel(schemaObj) {
-        if ('type' in schemaObj && typeof schemaObj.type === 'string') {
-            return [true, this.mapJsonTypeToTypeScript(schemaObj.type)];
+    return false;
+}
+/*
+ * The tryExtractDirectRefOutputModel method extracts the direct reference output model from the schema object.
+ * Returns true if type is successfully extracted, otherwise false.
+ */
+function tryExtractDirectRefOutputModel(schemaObj, modelName, imports, setOutputModel) {
+    // Case: items.$ref
+    if ('items' in schemaObj &&
+        typeof schemaObj.items === 'object' &&
+        schemaObj.items !== null &&
+        !Array.isArray(schemaObj.items)) {
+        const itemsObj = schemaObj.items;
+        if ('$ref' in itemsObj && typeof itemsObj.$ref === 'string') {
+            const outputModel = simplifyGenericTypeName(extractReferencedType(itemsObj.$ref));
+            setOutputModel(outputModel);
+            addImport(outputModel, modelName, imports);
+            return true;
         }
-        return [false, ''];
-    }
-    /*
-     * The addImport method adds an import statement to the imports set.
-     * Takes the type name, model name, and imports set as parameters.
-     */
-    static addImport(typeName, modelName, imports) {
-        imports.add(`import type { ${typeName} } from '${this.RELATIVE_MODEL_PATH}/${modelName}Model';`);
     }
-    /*
-     * The simplifyGenericTypeName method simplifies the generic type name by removing the generic parameters.
-     */
-    static simplifyGenericTypeName(typeName) {
-        return this.normalizeGenericTypeName(typeName);
+    // Case: $ref
+    if ('$ref' in schemaObj && typeof schemaObj.$ref === 'string') {
+        const outputModel = simplifyGenericTypeName(extractReferencedType(schemaObj.$ref));
+        setOutputModel(outputModel);
+        addImport(outputModel, modelName, imports);
+        return true;
     }
-    /*
-     * The normalizeGenericTypeName method normalizes the generic type name.
-     * It replaces the brackets with underscores and returns the normalized name.
-     */
-    static normalizeGenericTypeName(typeName) {
-        return typeName.replace(/\[/g, '_').replace(/\]/g, '');
+    return false;
+}
+/*
+ * The tryExtractTypeOutputModel method extracts the type output model from the schema object.
+ * Returns a tuple: [found: boolean, outputModel: string].
+ */
+function tryExtractTypeOutputModel(schemaObj) {
+    if ('type' in schemaObj && typeof schemaObj.type === 'string') {
+        return [true, mapJsonTypeToTypeScript(schemaObj.type)];
     }
-    /*
-     * The processRequestParameters method processes the parameters of the operation.
-     * It extracts the parameter name and type from the schema and adds them to the lists.
-     * It takes the parameter object, model name, imports set, parameters list, and parameters properties as parameters.
-     */
-    static processRequestParameters(param, modelName, imports, parametersList, parametersProps, paramNodeName, parameterTypes) {
-        if (typeof param !== 'object' || param === null || Array.isArray(param)) {
-            return [parametersList, parametersProps];
-        }
-        const paramObj = param;
-        const paramName = this.getParameterName(paramObj, paramNodeName);
-        // Skip 'connectionId' parameter
-        if (paramName.toLowerCase() === 'connectionid') {
-            return [parametersList, parametersProps];
-        }
-        if (parameterTypes && parameterTypes[paramName]) {
-            parametersList.push(`${parameterTypes[paramName].propertyDefinition}`);
-            parametersProps.push(`${parameterTypes[paramName].propertyName}`);
-        }
-        else {
-            // Only add to imports if not an override
-            const paramType = this.getParameterType(paramObj, modelName, imports);
-            const optionalMark = this.isParameterRequired(paramObj) ? '' : '?';
-            // Normalize parameter name
-            const normalizedParamName = paramName.replace(/-/g, '_');
-            parametersList.push(`${normalizedParamName}${optionalMark}: ${paramType}`);
-            parametersProps.push(normalizedParamName);
-        }
+    return [false, ''];
+}
+/*
+ * The addImport method adds an import statement to the imports set.
+ * Takes the type name, model name, and imports set as parameters.
+ */
+function addImport(typeName, modelName, imports) {
+    imports.add(`import type { ${typeName} } from '${RELATIVE_MODEL_PATH}/${modelName}Model';`);
+}
+/*
+ * The simplifyGenericTypeName method simplifies the generic type name by removing the generic parameters.
+ */
+function simplifyGenericTypeName(typeName) {
+    return normalizeGenericTypeName(typeName);
+}
+/*
+ * The normalizeGenericTypeName method normalizes the generic type name.
+ * It replaces the brackets with underscores and returns the normalized name.
+ */
+function normalizeGenericTypeName(typeName) {
+    return typeName.replace(/\[/g, '_').replace(/\]/g, '');
+}
+/*
+ * The processRequestParameters method processes the parameters of the operation.
+ * It extracts the parameter name and type from the schema and adds them to the lists.
+ * It takes the parameter object, model name, imports set, parameters list, and parameters properties as parameters.
+ */
+function processRequestParameters(param, modelName, imports, parametersList, parametersProps, paramNodeName, parameterTypes) {
+    if (typeof param !== 'object' || param === null || Array.isArray(param)) {
         return [parametersList, parametersProps];
     }
-    /*
-     * The getParameterName method extracts the name of the parameter from the schema.
-     * It handles the case where the schema is an array or a reference.
-     * It takes the parameter object and node name as parameters.
-     */
-    static getParameterName(paramObj, paramNodeName) {
-        const refNode = paramObj.$ref;
-        if (refNode && typeof refNode === 'string') {
-            const refValue = refNode;
-            if (refValue.toLowerCase().startsWith('#/parameters/')) {
-                const parameterName = refValue.substring('#/parameters/'.length);
-                return parameterName;
-            }
-        }
-        const nameNode = paramObj[paramNodeName];
-        return nameNode ? String(nameNode) : 'param';
-    }
-    /*
-     * The getParameterType method extracts the type of the parameter from the schema.
-     * It handles the case where the schema is an array or a reference.
-     * It takes the parameter object, model name, and imports set as parameters.
-     */
-    static getParameterType(paramObj, modelName, imports) {
-        if ('schema' in paramObj &&
-            typeof paramObj.schema === 'object' &&
-            paramObj.schema !== null &&
-            !Array.isArray(paramObj.schema)) {
-            return this.getSchemaBasedType(paramObj.schema, modelName, imports);
-        }
-        if ('$ref' in paramObj && typeof paramObj.$ref === 'string') {
-            return this.getRefBasedType(paramObj.$ref, modelName, imports);
-        }
-        if ('type' in paramObj && typeof paramObj.type === 'string') {
-            return this.mapJsonTypeToTypeScript(paramObj.type);
-        }
-        return 'unknown';
+    const paramObj = param;
+    const paramName = getParameterName(paramObj, paramNodeName);
+    // Skip 'connectionId' parameter
+    if (paramName.toLowerCase() === 'connectionid') {
+        return [parametersList, parametersProps];
     }
-    /*
-     * The getSchemaBasedType method extracts the type from the schema object.
-     * It handles the case where the schema is an array or a reference.
-     * It takes the schema object, model name, and imports set as parameters.
-     */
-    static getSchemaBasedType(schemaObj, modelName, imports) {
-        if ('$ref' in schemaObj && typeof schemaObj.$ref === 'string') {
-            return this.getRefBasedType(schemaObj.$ref, modelName, imports);
-        }
-        if ('type' in schemaObj && typeof schemaObj.type === 'string') {
-            const typeValue = schemaObj.type;
-            // Handle binary format as string
-            if ('format' in schemaObj && schemaObj.format === 'binary' && typeValue === 'string') {
-                return 'string';
-            }
-            return this.mapJsonTypeToTypeScript(typeValue);
-        }
-        return 'unknown';
+    if (parameterTypes && parameterTypes[paramName]) {
+        parametersList.push(`${parameterTypes[paramName].propertyDefinition}`);
+        parametersProps.push(`${parameterTypes[paramName].propertyName}`);
     }
-    /*
-     * The getRefBasedType method extracts the referenced type from the ref value.
-     * It adds the import statement for the referenced type to the imports set.
-     * It takes the ref value, model name, and imports set as parameters.
-     */
-    static getRefBasedType(refValue, modelName, imports) {
-        const refType = this.extractReferencedType(refValue);
-        this.addImport(refType, modelName, imports);
-        return refType;
-    }
-    /*
-     * The generateOperationMethod method generates a method for the service class.
-     * It takes the operations list, operation ID, summary, description,
-     * parameters list, parameters properties, output model, and data source name as parameters.
-     */
-    static generateOperationMethod(operations, operationId, summary, description, parametersList, parametersProps, outputModel, modelName) {
-        this.addMethodSummary(operations, summary, description);
-        const operationFuncName = this.formatOperationName(operationId);
-        const parameterSignature = this.getParameterSignature(parametersList);
-        const parameterObject = this.getParameterObject(parametersProps);
-        const parametersType = this.getParametersType(parametersList);
-        if (parametersList.length === 0) {
-            this.addMethodWithoutParameters(operations, operationFuncName, outputModel, operationId, modelName);
-        }
-        else {
-            this.addMethodWithParameters(operations, operationFuncName, parameterSignature, parametersType, parameterObject, outputModel, operationId, modelName);
-        }
+    else {
+        // Only add to imports if not an override
+        const paramType = getParameterType(paramObj, modelName, imports);
+        const optionalMark = isParameterRequired(paramObj) ? '' : '?';
+        // Normalize parameter name
+        const normalizedParamName = paramName.replace(/-/g, '_');
+        parametersList.push(`${normalizedParamName}${optionalMark}: ${paramType}`);
+        parametersProps.push(normalizedParamName);
     }
-    /*
-     * The addMethodSummary method adds a summary and description to the method.
-     * It takes the operations list, summary, and description as parameters.
-     */
-    static addMethodSummary(operations, summary, description) {
-        if (summary && summary.trim().length > 0) {
-            operations.push('');
-            operations.push('  /**');
-            operations.push(`   * ${summary}`);
-            if (description && description.trim().length > 0) {
-                operations.push(`   * ${description}`);
-            }
-            operations.push('   */');
-        }
-        else {
-            operations.push('');
+    return [parametersList, parametersProps];
+}
+/*
+ * The getParameterName method extracts the name of the parameter from the schema.
+ * It handles the case where the schema is an array or a reference.
+ * It takes the parameter object and node name as parameters.
+ */
+function getParameterName(paramObj, paramNodeName) {
+    const refNode = paramObj.$ref;
+    if (refNode && typeof refNode === 'string') {
+        const refValue = refNode;
+        if (refValue.toLowerCase().startsWith('#/parameters/')) {
+            const parameterName = refValue.substring('#/parameters/'.length);
+            return parameterName;
         }
     }
-    /*
-     * The formatOperationName method formats the operation name by replacing invalid characters with underscores.
-     * It takes the operation ID as input and returns the formatted operation name.
-     */
-    static formatOperationName(operationId) {
-        return operationId.replace(/[^a-zA-Z0-9_]/g, '_');
-    }
-    /*
-     * The getParameterSignature method generates the parameter signature for the service class.
-     * It takes the parameters list as input and returns the parameter signature as a string.
-     */
-    static getParameterSignature(parametersList) {
-        return parametersList.length > 0 ? parametersList.join(', ') : '';
-    }
-    /*
-     * The getParameterObject method generates the parameter object for the service class.
-     * It takes the parameters properties list as input and returns the parameter object as a string.
-     */
-    static getParameterObject(parametersProps) {
-        return parametersProps.length > 0 ? parametersProps.join(', ') : '';
+    const nameNode = paramObj[paramNodeName];
+    return nameNode ? String(nameNode) : 'param';
+}
+/*
+ * The getParameterType method extracts the type of the parameter from the schema.
+ * It handles the case where the schema is an array or a reference.
+ * It takes the parameter object, model name, and imports set as parameters.
+ */
+function getParameterType(paramObj, modelName, imports) {
+    if ('schema' in paramObj &&
+        typeof paramObj.schema === 'object' &&
+        paramObj.schema !== null &&
+        !Array.isArray(paramObj.schema)) {
+        return getSchemaBasedType(paramObj.schema, modelName, imports);
     }
-    /*
-     * The getParametersType method generates the parameters type for the service class.
-     * It takes the parameters list as input and returns the parameters type as a string.
-     */
-    static getParametersType(parametersList) {
-        return parametersList.length > 0 ? `{ ${parametersList.join(', ')} }` : 'object';
+    if ('$ref' in paramObj && typeof paramObj.$ref === 'string') {
+        return getRefBasedType(paramObj.$ref, modelName, imports);
     }
-    /*
-     * The addMethodWithoutParameters method generates a method without parameters for the service class.
-     * It takes the operations list, operation function name, output model, data source name,
-     * and operation ID as parameters.
-     */
-    static addMethodWithoutParameters(operations, operationFuncName, outputModel, operationId, modelName) {
-        operations.push(`  public static async ${operationFuncName}(): Promise<IOperationResult<${outputModel}>> {`, `    const result = await ${modelName}Service.client.executeAsync<void, ${outputModel}>(`, `      {`, `        connectorOperation: {`, `          tableName: ${getServiceName(modelName)},`, `          operationName: '${operationId}',`, `        },`, `      });`, `    return result;`, `  }`);
+    if ('type' in paramObj && typeof paramObj.type === 'string') {
+        return mapJsonTypeToTypeScript(paramObj.type);
     }
-    /*
-     * The addMethodWithParameters method generates a method with parameters for the service class.
-     * It takes the operations list, operation function name, parameter signature, parameters type,
-     * parameter object, output model, data source name, and operation ID as parameters.
-     */
-    static addMethodWithParameters(operations, operationFuncName, parameterSignature, parametersType, parameterObject, outputModel, operationId, modelName) {
-        operations.push(`  public static async ${operationFuncName}(${parameterSignature}): Promise<IOperationResult<${outputModel}>> {`, `    const params: ${parametersType} = { ${parameterObject} };`, `    const result = await ${modelName}Service.client.executeAsync<${parametersType}, ${outputModel}>(`, `      {`, `        connectorOperation: {`, `          tableName: ${getServiceName(modelName)},`, `          operationName: '${operationId}',`, `          parameters: params`, `        },`, `      });`, `    return result;`, `  }`);
+    return 'unknown';
+}
+/*
+ * The getSchemaBasedType method extracts the type from the schema object.
+ * It handles the case where the schema is an array or a reference.
+ * It takes the schema object, model name, and imports set as parameters.
+ */
+function getSchemaBasedType(schemaObj, modelName, imports) {
+    if ('$ref' in schemaObj && typeof schemaObj.$ref === 'string') {
+        return getRefBasedType(schemaObj.$ref, modelName, imports);
     }
-    /*
-     * The handleSqlStoredProcedure method handles the SQL stored procedure generation.
-     */
-    static async handleSqlStoredProcedure(modelName, dataSourceName, schema, schemaJson, outputDir, vfs) {
-        const { modelCode, responseModelName } = this.generateStoredProcedureModel(modelName, schema);
-        const serviceCode = this.generateStoredProcedureService(modelName, dataSourceName, schema, responseModelName);
-        await this.writeModelFile(outputDir, modelName, modelCode, vfs);
-        await this.writeServiceFile(outputDir, modelName, serviceCode, vfs);
-    }
-    /*
-     * The generateStoredProcedureModel method generates the model code for the stored procedure.
-     * It takes the model name and schema as parameters and returns the generated model code.
-     */
-    static generateStoredProcedureModel(modelName, schema) {
-        const lines = [];
-        this.addCopyrightNotice(lines);
-        // Validate schema
-        if (typeof schema !== 'object' || schema === null || !('schema' in schema)) {
-            throw new Error('Invalid schema format for stored procedure.');
-        }
-        const schemaNode = schema.schema;
-        // Ensure schemaNode is a JsonObject
-        if (typeof schemaNode !== 'object' || schemaNode === null || Array.isArray(schemaNode)) {
-            throw new Error('Invalid schema node format for stored procedure.');
+    if ('type' in schemaObj && typeof schemaObj.type === 'string') {
+        const typeValue = schemaObj.type;
+        // Handle binary format as string
+        if ('format' in schemaObj && schemaObj.format === 'binary' && typeValue === 'string') {
+            return 'string';
         }
-        this.addInputParametersModel(lines, modelName, schemaNode);
-        const responseModelName = this.addOutputParametersModel(lines, modelName, schemaNode);
-        return { modelCode: lines.join('\n'), responseModelName };
+        return mapJsonTypeToTypeScript(typeValue);
     }
-    /*
-     * The addInputParametersModel method generates the input parameters model for the stored procedure.
-     * It takes the lines to write to, model name, and schema node as parameters.
-     */
-    static addInputParametersModel(lines, modelName, schemaNode) {
-        if ('inputparameters' in schemaNode &&
-            typeof schemaNode.inputparameters === 'object' &&
-            schemaNode.inputparameters !== null &&
-            !Array.isArray(schemaNode.inputparameters)) {
-            const requestModelName = `${modelName}Request`;
-            const modelCode = this.generateModelFromSchema(requestModelName, schemaNode.inputparameters);
-            lines.push(modelCode);
-            lines.push(''); // Add a blank line between models
-        }
+    return 'unknown';
+}
+/*
+ * The getRefBasedType method extracts the referenced type from the ref value.
+ * It adds the import statement for the referenced type to the imports set.
+ * It takes the ref value, model name, and imports set as parameters.
+ */
+function getRefBasedType(refValue, modelName, imports) {
+    const refType = extractReferencedType(refValue);
+    addImport(refType, modelName, imports);
+    return refType;
+}
+/*
+ * The generateOperationMethod method generates a method for the service class.
+ * It takes the operations list, operation ID, summary, description,
+ * parameters list, parameters properties, output model, and data source name as parameters.
+ */
+function generateOperationMethod(operations, operationId, summary, description, parametersList, parametersProps, outputModel, modelName) {
+    addMethodSummary(operations, summary, description);
+    const operationFuncName = formatOperationName(operationId);
+    const parameterSignature = getParameterSignature(parametersList);
+    const parameterObject = getParameterObject(parametersProps);
+    const parametersType = getParametersType(parametersList);
+    if (parametersList.length === 0) {
+        addMethodWithoutParameters(operations, operationFuncName, outputModel, operationId, modelName);
+    }
+    else {
+        addMethodWithParameters(operations, operationFuncName, parameterSignature, parametersType, parameterObject, outputModel, operationId, modelName);
     }
-    /*
-     * The addOutputParametersModel method generates the output parameters model for the stored procedure.
-     * It takes the lines to write to, model name, and schema node as parameters.
-     */
-    static addOutputParametersModel(lines, modelName, schemaNode) {
-        if ('procedureresultschema' in schemaNode &&
-            typeof schemaNode.procedureresultschema === 'object' &&
-            schemaNode.procedureresultschema !== null &&
-            !Array.isArray(schemaNode.procedureresultschema)) {
-            const responseModelName = `${modelName}Response`;
-            const modelCode = this.generateModelFromSchema(responseModelName, schemaNode.procedureresultschema);
-            lines.push(modelCode);
-            lines.push(''); // Add a blank line between models
-            return responseModelName;
+}
+/*
+ * The addMethodSummary method adds a summary and description to the method.
+ * It takes the operations list, summary, and description as parameters.
+ */
+function addMethodSummary(operations, summary, description) {
+    if (summary && summary.trim().length > 0) {
+        operations.push('');
+        operations.push('  /**');
+        operations.push(`   * ${summary}`);
+        if (description && description.trim().length > 0) {
+            operations.push(`   * ${description}`);
         }
-        return '';
-    }
-    /*
-     * The generateStoredProcedureService method generates the service code for the stored procedure.
-     * It takes the model name, data source name, schema, and response model name as parameters.
-     */
-    static generateStoredProcedureService(modelName, dataSourceName, schema, responseModelName) {
-        const lines = [];
-        this.addCopyrightNotice(lines);
-        this.addServiceImports(lines, modelName, responseModelName);
-        this.addStoredProcedureServiceClassDefinition(lines, modelName, dataSourceName, schema, responseModelName);
-        return lines.join('\n');
-    }
-    /*
-     * The addServiceImports method adds necessary imports to the service file.
-     * It takes the lines to write to, model name, and response model name as parameters.
-     */
-    static addServiceImports(lines, modelName, responseModelName) {
-        const standardImports = this.collectStandardImports();
-        lines.push(...standardImports); // Add standard imports
-        lines.push(`import type { ${responseModelName} } from '${this.RELATIVE_MODEL_PATH}/${modelName}Model';`);
-        lines.push('');
-    }
-    /*
-     * The addServiceClassDefinition method generates the service class definition.
-     * It takes the lines to write to, model name, data source name, schema, and response model name as parameters.
-     */
-    static addStoredProcedureServiceClassDefinition(lines, modelName, dataSourceName, schema, responseModelName) {
-        this.addServiceClassHeader(lines, modelName, dataSourceName, false);
-        this.addStoredProcedureServiceMethods(lines, modelName, schema, responseModelName);
-        lines.push('}');
-        lines.push('');
+        operations.push('   */');
     }
-    /*
-     * The addStoredProcedureServiceMethods method generates service methods for the stored procedure.
-     * It takes the lines to write to, model name, schema, and response model name as parameters.
-     */
-    static addStoredProcedureServiceMethods(lines, modelName, schema, responseModelName) {
-        if (schema !== null && typeof schema === 'object' && !Array.isArray(schema)) {
-            const schemaObj = schema;
-            const schemaNode = schemaObj.schema;
-            if (typeof schemaNode === 'object' && schemaNode !== null && !Array.isArray(schemaNode)) {
-                const schemaNodeObj = schemaNode;
-                const inputparameters = schemaNodeObj.inputparameters;
-                if (typeof inputparameters === 'object' &&
-                    inputparameters !== null &&
-                    !Array.isArray(inputparameters)) {
-                    let parametersList = [];
-                    let parametersProps = [];
-                    const imports = new Set();
-                    const inputparametersObj = inputparameters;
-                    const inputProperties = inputparametersObj.properties;
-                    if (typeof inputProperties === 'object' &&
-                        inputProperties !== null &&
-                        !Array.isArray(inputProperties)) {
-                        // Collect properties with required status and original index
-                        const orderedProperties = this.getOrderedPropertiesByRequired(inputProperties);
-                        for (let i = 0; i < orderedProperties.length; i++) {
-                            const property = orderedProperties[i];
-                            [parametersList, parametersProps] = this.processRequestParameters(property.value, modelName, imports, parametersList, parametersProps, 'title');
-                        }
-                    }
-                    this.generateOperationMethod(lines, modelName, '', '', parametersList, parametersProps, responseModelName, modelName);
-                }
-            }
-        }
+    else {
+        operations.push('');
     }
-    /*
-     * The getOrderedPropertiesByRequired method sorts the properties by required property and original index.
-     */
-    static getOrderedPropertiesByRequired(propertiesOrArray) {
-        let propertiesObj;
-        if (Array.isArray(propertiesOrArray)) {
-            propertiesObj = {};
-            for (let idx = 0; idx < propertiesOrArray.length; idx++) {
-                propertiesObj[`param_${idx}`] = propertiesOrArray[idx];
-            }
-        }
-        else if (typeof propertiesOrArray === 'object' && propertiesOrArray !== null) {
-            propertiesObj = propertiesOrArray;
-        }
-        else {
-            throw new Error('Input must be an object or array');
-        }
-        const propertyList = [];
-        let index = 0;
-        for (const key in propertiesObj) {
-            if (!Object.prototype.hasOwnProperty.call(propertiesObj, key)) {
-                continue;
-            }
-            const value = propertiesObj[key];
-            let required = false;
-            if (value && typeof value === 'object' && 'required' in value) {
-                required = String(value.required) === 'true';
+}
+/*
+ * The formatOperationName method formats the operation name by replacing invalid characters with underscores.
+ * It takes the operation ID as input and returns the formatted operation name.
+ */
+function formatOperationName(operationId) {
+    return operationId.replace(/[^a-zA-Z0-9_]/g, '_');
+}
+/*
+ * The getParameterSignature method generates the parameter signature for the service class.
+ * It takes the parameters list as input and returns the parameter signature as a string.
+ */
+function getParameterSignature(parametersList) {
+    return parametersList.length > 0 ? parametersList.join(', ') : '';
+}
+/*
+ * The getParameterObject method generates the parameter object for the service class.
+ * It takes the parameters properties list as input and returns the parameter object as a string.
+ */
+function getParameterObject(parametersProps) {
+    return parametersProps.length > 0 ? parametersProps.join(', ') : '';
+}
+/*
+ * The getParametersType method generates the parameters type for the service class.
+ * It takes the parameters list as input and returns the parameters type as a string.
+ */
+function getParametersType(parametersList) {
+    return parametersList.length > 0 ? `{ ${parametersList.join(', ')} }` : 'object';
+}
+/*
+ * The addMethodWithoutParameters method generates a method without parameters for the service class.
+ * It takes the operations list, operation function name, output model, data source name,
+ * and operation ID as parameters.
+ */
+function addMethodWithoutParameters(operations, operationFuncName, outputModel, operationId, modelName) {
+    operations.push(`  public static async ${operationFuncName}(): Promise<IOperationResult<${outputModel}>> {`, `    const result = await ${modelName}Service.client.executeAsync<void, ${outputModel}>(`, `      {`, `        connectorOperation: {`, `          tableName: ${getServiceName(modelName)},`, `          operationName: '${operationId}',`, `        },`, `      });`, `    return result;`, `  }`);
+}
+/*
+ * The addMethodWithParameters method generates a method with parameters for the service class.
+ * It takes the operations list, operation function name, parameter signature, parameters type,
+ * parameter object, output model, data source name, and operation ID as parameters.
+ */
+function addMethodWithParameters(operations, operationFuncName, parameterSignature, parametersType, parameterObject, outputModel, operationId, modelName) {
+    operations.push(`  public static async ${operationFuncName}(${parameterSignature}): Promise<IOperationResult<${outputModel}>> {`, `    const params: ${parametersType} = { ${parameterObject} };`, `    const result = await ${modelName}Service.client.executeAsync<${parametersType}, ${outputModel}>(`, `      {`, `        connectorOperation: {`, `          tableName: ${getServiceName(modelName)},`, `          operationName: '${operationId}',`, `          parameters: params`, `        },`, `      });`, `    return result;`, `  }`);
+}
+/*
+ * The handleSqlStoredProcedure method handles the SQL stored procedure generation.
+ */
+async function handleSqlStoredProcedure(modelName, dataSourceName, schema, schemaJson, outputDir, vfs) {
+    const { modelCode, responseModelName } = generateStoredProcedureModel(modelName, schema);
+    const serviceCode = generateStoredProcedureService(modelName, dataSourceName, schema, responseModelName);
+    await writeModelFile(outputDir, modelName, modelCode, vfs);
+    await writeServiceFile(outputDir, modelName, serviceCode, vfs);
+}
+/*
+ * The generateStoredProcedureModel method generates the model code for the stored procedure.
+ * It takes the model name and schema as parameters and returns the generated model code.
+ */
+function generateStoredProcedureModel(modelName, schema) {
+    const lines = [];
+    addCopyrightNotice(lines);
+    // Validate schema
+    if (typeof schema !== 'object' || schema === null || !('schema' in schema)) {
+        throw new Error('Invalid schema format for stored procedure.');
+    }
+    const schemaNode = schema.schema;
+    // Ensure schemaNode is a JsonObject
+    if (typeof schemaNode !== 'object' || schemaNode === null || Array.isArray(schemaNode)) {
+        throw new Error('Invalid schema node format for stored procedure.');
+    }
+    addInputParametersModel(lines, modelName, schemaNode);
+    const responseModelName = addOutputParametersModel(lines, modelName, schemaNode);
+    return { modelCode: lines.join('\n'), responseModelName };
+}
+/*
+ * The addInputParametersModel method generates the input parameters model for the stored procedure.
+ * It takes the lines to write to, model name, and schema node as parameters.
+ */
+function addInputParametersModel(lines, modelName, schemaNode) {
+    if ('inputparameters' in schemaNode &&
+        typeof schemaNode.inputparameters === 'object' &&
+        schemaNode.inputparameters !== null &&
+        !Array.isArray(schemaNode.inputparameters)) {
+        const requestModelName = `${modelName}Request`;
+        const modelCode = generateModelFromSchema(requestModelName, schemaNode.inputparameters);
+        lines.push(modelCode);
+        lines.push(''); // Add a blank line between models
+    }
+}
+/*
+ * The addOutputParametersModel method generates the output parameters model for the stored procedure.
+ * It takes the lines to write to, model name, and schema node as parameters.
+ */
+function addOutputParametersModel(lines, modelName, schemaNode) {
+    if ('procedureresultschema' in schemaNode &&
+        typeof schemaNode.procedureresultschema === 'object' &&
+        schemaNode.procedureresultschema !== null &&
+        !Array.isArray(schemaNode.procedureresultschema)) {
+        const responseModelName = `${modelName}Response`;
+        const modelCode = generateModelFromSchema(responseModelName, schemaNode.procedureresultschema);
+        lines.push(modelCode);
+        lines.push(''); // Add a blank line between models
+        return responseModelName;
+    }
+    return '';
+}
+/*
+ * The generateStoredProcedureService method generates the service code for the stored procedure.
+ * It takes the model name, data source name, schema, and response model name as parameters.
+ */
+function generateStoredProcedureService(modelName, dataSourceName, schema, responseModelName) {
+    const lines = [];
+    addCopyrightNotice(lines);
+    addServiceImports(lines, modelName, responseModelName);
+    addStoredProcedureServiceClassDefinition(lines, modelName, dataSourceName, schema, responseModelName);
+    return lines.join('\n');
+}
+/*
+ * The addServiceImports method adds necessary imports to the service file.
+ * It takes the lines to write to, model name, and response model name as parameters.
+ */
+function addServiceImports(lines, modelName, responseModelName) {
+    const standardImports = collectStandardImports();
+    lines.push(...standardImports); // Add standard imports
+    lines.push(`import type { ${responseModelName} } from '${RELATIVE_MODEL_PATH}/${modelName}Model';`);
+    lines.push('');
+}
+/*
+ * The addServiceClassDefinition method generates the service class definition.
+ * It takes the lines to write to, model name, data source name, schema, and response model name as parameters.
+ */
+function addStoredProcedureServiceClassDefinition(lines, modelName, dataSourceName, schema, responseModelName) {
+    addServiceClassHeader(lines, modelName, dataSourceName, false);
+    addStoredProcedureServiceMethods(lines, modelName, schema, responseModelName);
+    lines.push('}');
+    lines.push('');
+}
+/*
+ * The addStoredProcedureServiceMethods method generates service methods for the stored procedure.
+ * It takes the lines to write to, model name, schema, and response model name as parameters.
+ */
+function addStoredProcedureServiceMethods(lines, modelName, schema, responseModelName) {
+    if (schema !== null && typeof schema === 'object' && !Array.isArray(schema)) {
+        const schemaObj = schema;
+        const schemaNode = schemaObj.schema;
+        if (typeof schemaNode === 'object' && schemaNode !== null && !Array.isArray(schemaNode)) {
+            const schemaNodeObj = schemaNode;
+            const inputparameters = schemaNodeObj.inputparameters;
+            if (typeof inputparameters === 'object' &&
+                inputparameters !== null &&
+                !Array.isArray(inputparameters)) {
+                let parametersList = [];
+                let parametersProps = [];
+                const imports = new Set();
+                const inputparametersObj = inputparameters;
+                const inputProperties = inputparametersObj.properties;
+                if (typeof inputProperties === 'object' &&
+                    inputProperties !== null &&
+                    !Array.isArray(inputProperties)) {
+                    // Collect properties with required status and original index
+                    const orderedProperties = getOrderedPropertiesByRequired(inputProperties);
+                    for (let i = 0; i < orderedProperties.length; i++) {
+                        const property = orderedProperties[i];
+                        [parametersList, parametersProps] = processRequestParameters(property.value, modelName, imports, parametersList, parametersProps, 'title');
+                    }
+                }
+                generateOperationMethod(lines, modelName, '', '', parametersList, parametersProps, responseModelName, modelName);
             }
-            propertyList.push({ key, value, required, index });
-            index++;
         }
-        // Required first, then original order
-        propertyList.sort((a, b) => {
-            const reqCompare = Number(b.required) - Number(a.required);
-            if (reqCompare !== 0) {
-                return reqCompare;
-            }
-            return a.index - b.index;
-        });
-        return propertyList.map((p) => ({ key: p.key, value: p.value }));
     }
-    /*
-     * The WriteModelFile method writes the generated model code to a file.
-     */
-    static async writeModelFile(outputDir, modelName, modelCode, vfs) {
-        const modelFilePath = vfs.join(outputDir, this.MODELS_FOLDER, `${modelName}Model.ts`);
-        await this.writeToFile(modelFilePath, [modelCode], vfs);
-    }
-    /*
-     * The WriteServiceFile method writes the generated service code to a file.
-     * It takes the output directory, model name, and service code as parameters.
-     */
-    static async writeServiceFile(outputDir, modelName, serviceCode, vfs) {
-        const serviceFilePath = vfs.join(outputDir, this.SERVICES_FOLDER, `${modelName}Service.ts`);
-        await this.writeToFile(serviceFilePath, [serviceCode], vfs);
+}
+/*
+ * The getOrderedPropertiesByRequired method sorts the properties by required property and original index.
+ */
+function getOrderedPropertiesByRequired(propertiesOrArray) {
+    let propertiesObj;
+    if (Array.isArray(propertiesOrArray)) {
+        propertiesObj = {};
+        for (let idx = 0; idx < propertiesOrArray.length; idx++) {
+            propertiesObj[`param_${idx}`] = propertiesOrArray[idx];
+        }
+    }
+    else if (typeof propertiesOrArray === 'object' && propertiesOrArray !== null) {
+        propertiesObj = propertiesOrArray;
+    }
+    else {
+        throw new Error('Input must be an object or array');
+    }
+    const propertyList = [];
+    let index = 0;
+    for (const key in propertiesObj) {
+        if (!Object.prototype.hasOwnProperty.call(propertiesObj, key)) {
+            continue;
+        }
+        const value = propertiesObj[key];
+        let required = false;
+        if (value && typeof value === 'object' && 'required' in value) {
+            required = String(value.required) === 'true';
+        }
+        propertyList.push({ key, value, required, index });
+        index++;
+    }
+    // Required first, then original order
+    propertyList.sort((a, b) => {
+        const reqCompare = Number(b.required) - Number(a.required);
+        if (reqCompare !== 0) {
+            return reqCompare;
+        }
+        return a.index - b.index;
+    });
+    return propertyList.map((p) => ({ key: p.key, value: p.value }));
+}
+/*
+ * The WriteModelFile method writes the generated model code to a file.
+ */
+async function writeModelFile(outputDir, modelName, modelCode, vfs) {
+    const modelFilePath = vfs.join(outputDir, MODELS_FOLDER, `${modelName}Model.ts`);
+    await writeToFile(modelFilePath, [modelCode], vfs);
+}
+/*
+ * The WriteServiceFile method writes the generated service code to a file.
+ * It takes the output directory, model name, and service code as parameters.
+ */
+async function writeServiceFile(outputDir, modelName, serviceCode, vfs) {
+    const serviceFilePath = vfs.join(outputDir, SERVICES_FOLDER, `${modelName}Service.ts`);
+    await writeToFile(serviceFilePath, [serviceCode], vfs);
+}
+/*
+ * The handleStandardSchema method generates TypeScript models and services from any schema type.
+ * It routes to the appropriate handler based on schema type.
+ */
+async function handleStandardSchema(modelName, dataSourceName, schema, schemaJson, outputDir, vfs) {
+    // Check if this is a Dataverse entity schema (has nested schema.items structure)
+    if (isDataverseEntity(schema)) {
+        await handleDataverseSchema(modelName, dataSourceName, schema, outputDir, vfs);
     }
-    /*
-     * The handleStandardSchema method generates TypeScript models and services from any schema type.
-     * It routes to the appropriate handler based on schema type.
-     */
-    static async handleStandardSchema(modelName, dataSourceName, schema, schemaJson, outputDir, vfs) {
-        // Check if this is a Dataverse entity schema (has nested schema.items structure)
-        if (isDataverseEntity(schema)) {
-            await this.handleDataverseSchema(modelName, dataSourceName, schema, outputDir, vfs);
-        }
-        else {
-            await this.handleStandardSchemaOnly(modelName, dataSourceName, schemaJson, outputDir, vfs);
-        }
-        await this.ensureCommonModelFileExists(outputDir, vfs);
+    else {
+        await handleStandardSchemaOnly(modelName, dataSourceName, schemaJson, outputDir, vfs);
     }
-    /*
-     * The handleDataverseSchema method generates TypeScript models and services specifically for Dataverse entities.
-     */
-    static async handleDataverseSchema(modelName, dataSourceName, schema, outputDir, vfs) {
-        const schemaObject = schema;
-        if (typeof schemaObject.schema !== 'object' || schemaObject.schema === null) {
-            throw new Error(`Invalid Dataverse entity schema structure: missing 'schema' property for ${modelName}`);
-        }
-        const schemaProperty = schemaObject.schema;
-        if (typeof schemaProperty.items !== 'object' || schemaProperty.items === null) {
-            throw new Error(`Invalid Dataverse entity schema structure: missing 'schema.items' property for ${modelName}`);
-        }
-        const itemsNode = schemaProperty.items;
-        let primaryKey = 'id'; // default
-        // Extract primary key from Dataverse entity schema inline
-        const properties = itemsNode.properties;
-        if (properties) {
-            for (const [propName, propValue] of Object.entries(properties)) {
-                if (typeof propValue === 'object' && propValue !== null) {
-                    const prop = propValue;
-                    if (prop['x-ms-dataverse-primary-id'] === true || prop['x-ms-keyType'] === 'primary') {
-                        primaryKey = propName;
-                        break;
-                    }
+    await ensureCommonModelFileExists(outputDir, vfs);
+}
+/*
+ * The handleDataverseSchema method generates TypeScript models and services specifically for Dataverse entities.
+ */
+async function handleDataverseSchema(modelName, dataSourceName, schema, outputDir, vfs) {
+    const schemaObject = schema;
+    if (typeof schemaObject.schema !== 'object' || schemaObject.schema === null) {
+        throw new Error(`Invalid Dataverse entity schema structure: missing 'schema' property for ${modelName}`);
+    }
+    const schemaProperty = schemaObject.schema;
+    if (typeof schemaProperty.items !== 'object' || schemaProperty.items === null) {
+        throw new Error(`Invalid Dataverse entity schema structure: missing 'schema.items' property for ${modelName}`);
+    }
+    const itemsNode = schemaProperty.items;
+    let primaryKey = 'id'; // default
+    // Extract primary key from Dataverse entity schema inline
+    const properties = itemsNode.properties;
+    if (properties) {
+        for (const [propName, propValue] of Object.entries(properties)) {
+            if (typeof propValue === 'object' && propValue !== null) {
+                const prop = propValue;
+                if (prop['x-ms-dataverse-primary-id'] === true || prop['x-ms-keyType'] === 'primary') {
+                    primaryKey = propName;
+                    break;
                 }
             }
         }
-        // For Dataverse entities, generate both base and extended interfaces for lookup columns
-        const { baseInterface, extendedInterface } = this.generateDataverseInterfaces(modelName, itemsNode);
-        const hasLookupColumns = !!extendedInterface;
-        if (hasLookupColumns) {
-            // Generate both interfaces when there are lookup columns
-            const combinedModelCode = baseInterface + '\n\n' + extendedInterface;
-            await this.writeModelFile(outputDir, modelName, combinedModelCode, vfs);
-        }
-        else {
-            // Generate single interface when no lookup columns
-            await this.writeModelFile(outputDir, modelName, baseInterface, vfs);
-        }
-        const serviceCode = this.generateDataverseTypeScriptService(modelName, dataSourceName, primaryKey, hasLookupColumns);
-        await this.writeServiceFile(outputDir, modelName, serviceCode, vfs);
     }
-    /*
-     * The handleStandardSchemaOnly method generates TypeScript models and services for standard (non-Dataverse) schemas.
-     */
-    static async handleStandardSchemaOnly(modelName, dataSourceName, schemaJson, outputDir, vfs) {
-        const { modelCode, primaryKey } = this.generateTypeScriptModel(schemaJson, modelName);
-        const serviceCode = this.generateTypeScriptService(modelName, dataSourceName, primaryKey, false);
-        await this.writeModelFile(outputDir, modelName, modelCode, vfs);
-        await this.writeServiceFile(outputDir, modelName, serviceCode, vfs);
+    // For Dataverse entities, generate both base and extended interfaces for lookup columns
+    const { baseInterface, extendedInterface } = generateDataverseInterfaces(modelName, itemsNode);
+    const hasLookupColumns = !!extendedInterface;
+    if (hasLookupColumns) {
+        // Generate both interfaces when there are lookup columns
+        const combinedModelCode = baseInterface + '\n\n' + extendedInterface;
+        await writeModelFile(outputDir, modelName, combinedModelCode, vfs);
     }
-    /**
-     * The handleSharepointSchema method handles SharePoint schema generation.
-     * It generates TypeScript models and services specifically for SharePoint data sources.
-     */
-    static async handleSharepointSchema(modelName, dataSourceName, schema, schemaJson, outputDir, vfs) {
-        // SharePoint-specific processing logic
-        const { modelCode, primaryKey, hasReferenceEntities } = this.generateSharepointTypeScriptModel(schemaJson, modelName);
-        // Generate SharePoint-specific service code
-        const serviceCode = this.generateSharepointService(modelName, dataSourceName, primaryKey, schemaJson, hasReferenceEntities);
-        await this.writeModelFile(outputDir, modelName, modelCode, vfs);
-        await this.writeServiceFile(outputDir, modelName, serviceCode, vfs);
-        await this.ensureCommonModelFileExists(outputDir, vfs);
-    }
-    /**
-     * Generates SharePoint-specific service code.
-     */
-    static generateSharepointService(modelName, dataSourceName, primaryKey, schemaJson, hasReferenceEntities) {
-        const lines = [];
-        this.addCopyrightNotice(lines);
-        this.addSharepointServiceImports(lines, modelName, hasReferenceEntities);
-        this.addSharepointServiceClassDefinition(lines, modelName, dataSourceName, schemaJson, primaryKey, hasReferenceEntities);
-        return lines.join('\n');
+    else {
+        // Generate single interface when no lookup columns
+        await writeModelFile(outputDir, modelName, baseInterface, vfs);
     }
-    /**
-     * Adds the SharePoint service class definition to the generated code.
-     */
-    static addSharepointServiceClassDefinition(lines, modelName, dataSourceName, schemaJson, primaryKey, hasReferenceEntities) {
-        this.addServiceClassHeader(lines, modelName, dataSourceName, true);
-        // Add CRUD methods
-        const methods = [];
-        methods.push(this.generateSharepointCreateMethod(modelName, primaryKey, hasReferenceEntities));
-        methods.push(this.generateSharepointUpdateMethod(modelName, primaryKey, hasReferenceEntities));
-        methods.push(this.generateSharepointDeleteMethod(modelName));
-        methods.push(this.generateSharepointGetMethod(modelName, hasReferenceEntities));
-        methods.push(this.generateSharepointGetAllMethod(modelName, hasReferenceEntities));
-        for (const method of methods) {
-            lines.push('');
-            lines.push(...method);
-        }
-        // Add SharePoint-specific methods
-        this.addGetMethodForReferenceEntities(lines, modelName, dataSourceName, schemaJson);
-        lines.push('}');
+    const serviceCode = generateDataverseTypeScriptService(modelName, dataSourceName, primaryKey, hasLookupColumns);
+    await writeServiceFile(outputDir, modelName, serviceCode, vfs);
+}
+/*
+ * The handleStandardSchemaOnly method generates TypeScript models and services for standard (non-Dataverse) schemas.
+ */
+async function handleStandardSchemaOnly(modelName, dataSourceName, schemaJson, outputDir, vfs) {
+    const { modelCode, primaryKey } = generateTypeScriptModel(schemaJson, modelName);
+    const serviceCode = generateTypeScriptService(modelName, dataSourceName, primaryKey, false);
+    await writeModelFile(outputDir, modelName, modelCode, vfs);
+    await writeServiceFile(outputDir, modelName, serviceCode, vfs);
+}
+/**
+ * The handleSharepointSchema method handles SharePoint schema generation.
+ * It generates TypeScript models and services specifically for SharePoint data sources.
+ */
+async function handleSharepointSchema(modelName, dataSourceName, schema, schemaJson, outputDir, vfs) {
+    // SharePoint-specific processing logic
+    const { modelCode, primaryKey, hasReferenceEntities } = generateSharepointTypeScriptModel(schemaJson, modelName);
+    // Generate SharePoint-specific service code
+    const serviceCode = generateSharepointService(modelName, dataSourceName, primaryKey, schemaJson, hasReferenceEntities);
+    await writeModelFile(outputDir, modelName, modelCode, vfs);
+    await writeServiceFile(outputDir, modelName, serviceCode, vfs);
+    await ensureCommonModelFileExists(outputDir, vfs);
+}
+/**
+ * Generates SharePoint-specific service code.
+ */
+function generateSharepointService(modelName, dataSourceName, primaryKey, schemaJson, hasReferenceEntities) {
+    const lines = [];
+    addCopyrightNotice(lines);
+    addSharepointServiceImports(lines, modelName, hasReferenceEntities);
+    addSharepointServiceClassDefinition(lines, modelName, dataSourceName, schemaJson, primaryKey, hasReferenceEntities);
+    return lines.join('\n');
+}
+/**
+ * Adds the SharePoint service class definition to the generated code.
+ */
+function addSharepointServiceClassDefinition(lines, modelName, dataSourceName, schemaJson, primaryKey, hasReferenceEntities) {
+    addServiceClassHeader(lines, modelName, dataSourceName, true);
+    // Add CRUD methods
+    const methods = [];
+    methods.push(generateSharepointCreateMethod(modelName, primaryKey, hasReferenceEntities));
+    methods.push(generateSharepointUpdateMethod(modelName, primaryKey, hasReferenceEntities));
+    methods.push(generateSharepointDeleteMethod(modelName));
+    methods.push(generateSharepointGetMethod(modelName, hasReferenceEntities));
+    methods.push(generateSharepointGetAllMethod(modelName, hasReferenceEntities));
+    for (const method of methods) {
         lines.push('');
+        lines.push(...method);
     }
-    /**
-     * Adds the SharePoint-specific get method for reference entities.
-     */
-    static addGetMethodForReferenceEntities(lines, modelName, dataSourceName, schemaJson) {
-        if (!schemaJson) {
-            return;
-        }
-        const schema = JSON.parse(schemaJson);
-        const referencedEntities = typeof schema.referencedEntities === 'object' && schema.referencedEntities !== null
-            ? schema.referencedEntities
-            : null;
-        if (referencedEntities) {
-            this.addGetMethodForReferenceEntitiesCore(lines, modelName);
-        }
+    // Add SharePoint-specific methods
+    addGetMethodForReferenceEntities(lines, modelName, dataSourceName, schemaJson);
+    lines.push('}');
+    lines.push('');
+}
+/**
+ * Adds the SharePoint-specific get method for reference entities.
+ */
+function addGetMethodForReferenceEntities(lines, modelName, dataSourceName, schemaJson) {
+    if (!schemaJson) {
+        return;
     }
-    /*
-     * The get method adds get function for sharepoint referenceEntities
-     */
-    static addGetMethodForReferenceEntitiesCore(lines, modelName) {
-        // Add method summary
-        lines.push(`/**`, `* Utility method to get possible values of a referenced entity by its name.`, `*/`, `  public static async getReferencedEntity(search: string, referencedEntityKeyNormalized: string): Promise<IOperationResult<unknown>> {`, `    const params: {search: string} = { search };`, `    const result = await ${modelName}Service.client.executeAsync<{search: string}, unknown>(`, `      {`, `        connectorOperation: {`, `          tableName: ${getServiceName(modelName)},`, `          operationName: 'Get' + referencedEntityKeyNormalized,`, `          parameters: params`, `        }`, `      });`, `    return result;`, `  }`, ``);
+    const schema = JSON.parse(schemaJson);
+    const referencedEntities = typeof schema.referencedEntities === 'object' && schema.referencedEntities !== null
+        ? schema.referencedEntities
+        : null;
+    if (referencedEntities) {
+        addGetMethodForReferenceEntitiesCore(lines, modelName);
     }
-    /*
-     * The ensureCommonModelFileExists method checks if the CommonModels.ts file exists in the specified output directory.
-     * If it does not exist, it creates the file with a copyright notice and common model code.
-     */
-    static async ensureCommonModelFileExists(outputDir, vfs) {
-        // Node.js built-in modules are statically imported at the top of the file
-        const commonModelPath = vfs.join(outputDir, this.MODELS_FOLDER, 'CommonModels.ts');
-        if (!(await vfs.exists(commonModelPath))) {
-            const lines = [];
-            this.addCopyrightNotice(lines);
-            this.addCommonModelCode(lines);
-            await this.writeToFile(commonModelPath, lines, vfs);
-        }
+}
+/*
+ * The get method adds get function for sharepoint referenceEntities
+ */
+function addGetMethodForReferenceEntitiesCore(lines, modelName) {
+    // Add method summary
+    lines.push(`/**`, `* Utility method to get possible values of a referenced entity by its name.`, `*/`, `  public static async getReferencedEntity(search: string, referencedEntityKeyNormalized: string): Promise<IOperationResult<unknown>> {`, `    const params: {search: string} = { search };`, `    const result = await ${modelName}Service.client.executeAsync<{search: string}, unknown>(`, `      {`, `        connectorOperation: {`, `          tableName: ${getServiceName(modelName)},`, `          operationName: 'Get' + referencedEntityKeyNormalized,`, `          parameters: params`, `        }`, `      });`, `    return result;`, `  }`, ``);
+}
+/*
+ * The ensureCommonModelFileExists method checks if the CommonModels.ts file exists in the specified output directory.
+ * If it does not exist, it creates the file with a copyright notice and common model code.
+ */
+async function ensureCommonModelFileExists(outputDir, vfs) {
+    // Node.js built-in modules are statically imported at the top of the file
+    const commonModelPath = vfs.join(outputDir, MODELS_FOLDER, 'CommonModels.ts');
+    if (!(await vfs.exists(commonModelPath))) {
+        const lines = [];
+        addCopyrightNotice(lines);
+        addCommonModelCode(lines);
+        await writeToFile(commonModelPath, lines, vfs);
     }
-    /*
-     * The addCommonModelCode method generates common TypeScript model code for the CommonModels.ts file.
-     * It includes interfaces for IGetOptions and IGetAllOptions.
-     */
-    static addCommonModelCode(lines) {
-        lines.push('export interface IGetOptions {');
-        lines.push('  select?: string[];');
-        lines.push('};');
-        lines.push('');
-        lines.push('export interface IGetAllOptions {');
-        lines.push('  maxPageSize?: number;');
-        lines.push('  select?: string[];');
-        lines.push('  filter?: string;');
-        lines.push('  orderBy?: string[];');
-        lines.push('  top?: number;');
-        lines.push('  skip?: number;');
-        lines.push('  skipToken?: string;');
-        lines.push('}');
-        lines.push('');
+}
+/*
+ * The addCommonModelCode method generates common TypeScript model code for the CommonModels.ts file.
+ * It includes interfaces for IGetOptions and IGetAllOptions.
+ */
+function addCommonModelCode(lines) {
+    lines.push('export interface IGetOptions {');
+    lines.push('  select?: string[];');
+    lines.push('};');
+    lines.push('');
+    lines.push('export interface IGetAllOptions {');
+    lines.push('  maxPageSize?: number;');
+    lines.push('  select?: string[];');
+    lines.push('  filter?: string;');
+    lines.push('  orderBy?: string[];');
+    lines.push('  top?: number;');
+    lines.push('  skip?: number;');
+    lines.push('  skipToken?: string;');
+    lines.push('}');
+    lines.push('');
+}
+/*
+ * The generateTypeScriptModel method generates a TypeScript model from the JSON schema.
+ * It returns the generated model code and the primary key of the model.
+ */
+function generateTypeScriptModel(schemaJson, modelName) {
+    const root = parseSchemaJson(schemaJson);
+    const propertiesNode = getPropertiesNode(root);
+    const requiredFields = getRequiredFieldsFromStandardSchema(root);
+    const lines = [];
+    addCopyrightNotice(lines);
+    const primaryKeyObj = { value: '' };
+    addModelInterfaceDeclaration(lines, modelName, propertiesNode, requiredFields, primaryKeyObj);
+    return { modelCode: lines.join('\n'), primaryKey: primaryKeyObj.value };
+}
+function generateSharepointTypeScriptModel(schemaJson, modelName) {
+    const root = parseSchemaJson(schemaJson);
+    const propertiesNode = getPropertiesNode(root);
+    const requiredFields = getRequiredFieldsFromStandardSchema(root);
+    const lines = [];
+    addCopyrightNotice(lines);
+    const primaryKeyObj = { value: '' };
+    const { hasReferenceEntities } = addSPModelInterfaceDeclaration(lines, modelName, propertiesNode, requiredFields, primaryKeyObj, schemaJson);
+    return { modelCode: lines.join('\n'), primaryKey: primaryKeyObj.value, hasReferenceEntities };
+}
+/*
+ * The parseSchemaJson method parses the JSON schema and retrieves the items node.
+ * It throws an exception if the schema format is invalid.
+ */
+function parseSchemaJson(schemaJson) {
+    const root = JSON.parse(schemaJson);
+    if (!root.schema || !root.schema.items) {
+        throw new Error('Invalid schema format');
     }
-    /*
-     * The generateTypeScriptModel method generates a TypeScript model from the JSON schema.
-     * It returns the generated model code and the primary key of the model.
-     */
-    static generateTypeScriptModel(schemaJson, modelName) {
-        const root = this.parseSchemaJson(schemaJson);
-        const propertiesNode = this.getPropertiesNode(root);
-        const requiredFields = this.getRequiredFieldsFromStandardSchema(root);
-        const lines = [];
-        this.addCopyrightNotice(lines);
-        const primaryKeyObj = { value: '' };
-        this.addModelInterfaceDeclaration(lines, modelName, propertiesNode, requiredFields, primaryKeyObj);
-        return { modelCode: lines.join('\n'), primaryKey: primaryKeyObj.value };
-    }
-    static generateSharepointTypeScriptModel(schemaJson, modelName) {
-        const root = this.parseSchemaJson(schemaJson);
-        const propertiesNode = this.getPropertiesNode(root);
-        const requiredFields = this.getRequiredFieldsFromStandardSchema(root);
-        const lines = [];
-        this.addCopyrightNotice(lines);
-        const primaryKeyObj = { value: '' };
-        const { hasReferenceEntities } = this.addSPModelInterfaceDeclaration(lines, modelName, propertiesNode, requiredFields, primaryKeyObj, schemaJson);
-        return { modelCode: lines.join('\n'), primaryKey: primaryKeyObj.value, hasReferenceEntities };
-    }
-    /*
-     * The parseSchemaJson method parses the JSON schema and retrieves the items node.
-     * It throws an exception if the schema format is invalid.
-     */
-    static parseSchemaJson(schemaJson) {
-        const root = JSON.parse(schemaJson);
-        if (!root.schema || !root.schema.items) {
-            throw new Error('Invalid schema format');
-        }
-        const items = root.schema.items;
-        if (typeof items !== 'object' || items === null || Array.isArray(items)) {
-            throw new Error('Schema items must be a valid object');
-        }
-        return items;
+    const items = root.schema.items;
+    if (typeof items !== 'object' || items === null || Array.isArray(items)) {
+        throw new Error('Schema items must be a valid object');
     }
-    /*
-     * The getRequiredFieldsFromStandardSchema method retrieves the required fields from the JSON schema.
-     * It returns a Set of required field names.
-     */
-    static getRequiredFieldsFromStandardSchema(itemsNode) {
-        if (typeof itemsNode !== 'object' || itemsNode === null || Array.isArray(itemsNode)) {
-            return new Set();
-        }
-        const itemsObj = itemsNode;
-        if (!itemsObj.required || !Array.isArray(itemsObj.required)) {
-            return new Set();
-        }
-        return new Set(itemsObj.required.map((r) => String(r)));
+    return items;
+}
+/*
+ * The getRequiredFieldsFromStandardSchema method retrieves the required fields from the JSON schema.
+ * It returns a Set of required field names.
+ */
+function getRequiredFieldsFromStandardSchema(itemsNode) {
+    if (typeof itemsNode !== 'object' || itemsNode === null || Array.isArray(itemsNode)) {
+        return new Set();
     }
-    /*
-     * The addSPModelInterfaceDeclaration method generates the TypeScript interface declaration for the model particular to Sharepoint.
-     */
-    static addSPModelInterfaceDeclaration(lines, modelName, propertiesNode, requiredFields, primaryKeyObj, schemaJson) {
-        const result = this.addSPReferencedEntityModelInterfaceDeclaration(schemaJson, lines);
-        const referenceEntitiesObjectMapping = result.mapping;
-        // lines are already updated by the method above
-        // We will generate 3 interfaces:
-        // A base one with properties that are not reference entities
-        // A "read" model that extends the base one and adds reference entity properties with an object type (inferred from the referencedEntities section)
-        // A "write" model that extends the base one and adds reference entities with the string/string[] type
-        // All 3 interfaces will be exported
-        const baseInterfaceLines = [];
-        const readInterfaceLines = [];
-        const writeInterfaceLines = [];
-        // This will be true if there is at least one referenced entity
-        // This flag is later used to determine if we need to use multiple interfaces in the service file
-        let hasReferenceEntities = false;
-        baseInterfaceLines.push(`export interface ${modelName}Base {`);
-        readInterfaceLines.push(`export interface ${modelName}Read extends ${modelName}Base {`);
-        writeInterfaceLines.push(`export interface ${modelName}Write extends ${modelName}Base {`);
-        // lines.push(`export interface ${modelName} {`);
-        for (const propName of Object.keys(propertiesNode)) {
-            let propNameNormalized = propName;
-            if (!isValidPropertyName(propName)) {
-                propNameNormalized = `"${propName}"`; // Enclose invalid property names in double quotes
-            }
-            const isRequired = requiredFields.has(propName);
-            const optionalMark = isRequired ? '' : '?';
-            if (propName in referenceEntitiesObjectMapping) {
-                if (isSharepointChoiceColumn(propertiesNode[propName])) {
-                    // Note: SharePoint choice/multi-choice columns are intentionally mapped to string/string[]
-                    // instead of the schema's { Value: string } object. This simplifies the SDK's public
-                    // surface and prevents recurring errors in AI agents (especially App Builder) that
-                    // frequently mishandled the complex object wrapper.
-                    if (propertiesNode[propName].type === 'array') {
-                        writeInterfaceLines.push(`  ${propNameNormalized}${optionalMark}: string[];`);
-                    }
-                    else {
-                        writeInterfaceLines.push(`  ${propNameNormalized}${optionalMark}: string;`);
-                    }
+    const itemsObj = itemsNode;
+    if (!itemsObj.required || !Array.isArray(itemsObj.required)) {
+        return new Set();
+    }
+    return new Set(itemsObj.required.map((r) => String(r)));
+}
+/*
+ * The addSPModelInterfaceDeclaration method generates the TypeScript interface declaration for the model particular to Sharepoint.
+ */
+function addSPModelInterfaceDeclaration(lines, modelName, propertiesNode, requiredFields, primaryKeyObj, schemaJson) {
+    const result = addSPReferencedEntityModelInterfaceDeclaration(schemaJson, lines);
+    const referenceEntitiesObjectMapping = result.mapping;
+    // lines are already updated by the method above
+    // We will generate 3 interfaces:
+    // A base one with properties that are not reference entities
+    // A "read" model that extends the base one and adds reference entity properties with an object type (inferred from the referencedEntities section)
+    // A "write" model that extends the base one and adds reference entities with the string/string[] type
+    // All 3 interfaces will be exported
+    const baseInterfaceLines = [];
+    const readInterfaceLines = [];
+    const writeInterfaceLines = [];
+    // This will be true if there is at least one referenced entity
+    // This flag is later used to determine if we need to use multiple interfaces in the service file
+    let hasReferenceEntities = false;
+    baseInterfaceLines.push(`export interface ${modelName}Base {`);
+    readInterfaceLines.push(`export interface ${modelName}Read extends ${modelName}Base {`);
+    writeInterfaceLines.push(`export interface ${modelName}Write extends ${modelName}Base {`);
+    // lines.push(`export interface ${modelName} {`);
+    for (const propName of Object.keys(propertiesNode)) {
+        let propNameNormalized = propName;
+        if (!isValidPropertyName(propName)) {
+            propNameNormalized = `"${propName}"`; // Enclose invalid property names in double quotes
+        }
+        const isRequired = requiredFields.has(propName);
+        const optionalMark = isRequired ? '' : '?';
+        if (propName in referenceEntitiesObjectMapping) {
+            if (isSharepointChoiceColumn(propertiesNode[propName])) {
+                // Note: SharePoint choice/multi-choice columns are intentionally mapped to string/string[]
+                // instead of the schema's { Value: string } object. This simplifies the SDK's public
+                // surface and prevents recurring errors in AI agents (especially App Builder) that
+                // frequently mishandled the complex object wrapper.
+                if (propertiesNode[propName].type === 'array') {
+                    writeInterfaceLines.push(`  ${propNameNormalized}${optionalMark}: string[];`);
                 }
                 else {
-                    writeInterfaceLines.push(`  ${propNameNormalized}${optionalMark}: ${referenceEntitiesObjectMapping[propName]};`);
+                    writeInterfaceLines.push(`  ${propNameNormalized}${optionalMark}: string;`);
                 }
-                readInterfaceLines.push(`  ${propNameNormalized}${optionalMark}: ${referenceEntitiesObjectMapping[propName]};`);
-                hasReferenceEntities = true;
+            }
+            else {
+                writeInterfaceLines.push(`  ${propNameNormalized}${optionalMark}: ${referenceEntitiesObjectMapping[propName]};`);
+            }
+            readInterfaceLines.push(`  ${propNameNormalized}${optionalMark}: ${referenceEntitiesObjectMapping[propName]};`);
+            hasReferenceEntities = true;
+            continue;
+        }
+        addPropertyDeclaration(baseInterfaceLines, propName, propertiesNode[propName], requiredFields, primaryKeyObj);
+    }
+    baseInterfaceLines.push('}');
+    baseInterfaceLines.push('');
+    lines.push(...baseInterfaceLines);
+    if (hasReferenceEntities) {
+        readInterfaceLines.push('}');
+        readInterfaceLines.push('');
+        lines.push(...readInterfaceLines);
+    }
+    if (hasReferenceEntities) {
+        writeInterfaceLines.push('}');
+        writeInterfaceLines.push('');
+        lines.push(...writeInterfaceLines);
+    }
+    return { referenceEntitiesObjectMapping, lines, hasReferenceEntities };
+}
+function addSPReferencedEntityModelInterfaceDeclaration(schemaJson, lines) {
+    const referenceEntitiesObjectMapping = {};
+    const schema = JSON.parse(schemaJson);
+    const root = parseSchemaJson(schemaJson);
+    const propertiesNode = getPropertiesNode(root);
+    const referencedEntities = typeof schema.referencedEntities === 'object' && schema.referencedEntities !== null
+        ? schema.referencedEntities
+        : null;
+    if (referencedEntities) {
+        for (const referencedEntityKey in referencedEntities) {
+            if (!Object.prototype.hasOwnProperty.call(referencedEntities, referencedEntityKey)) {
                 continue;
             }
-            this.addPropertyDeclaration(baseInterfaceLines, propName, propertiesNode[propName], requiredFields, primaryKeyObj);
-        }
-        baseInterfaceLines.push('}');
-        baseInterfaceLines.push('');
-        lines.push(...baseInterfaceLines);
-        if (hasReferenceEntities) {
-            readInterfaceLines.push('}');
-            readInterfaceLines.push('');
-            lines.push(...readInterfaceLines);
-        }
-        if (hasReferenceEntities) {
-            writeInterfaceLines.push('}');
-            writeInterfaceLines.push('');
-            lines.push(...writeInterfaceLines);
+            referenceEntitiesObjectMapping[referencedEntityKey] = referencedEntityKey + 'Value';
+            if (!(referencedEntityKey in propertiesNode)) {
+                continue;
+            }
+            lines.push(`export interface ${referenceEntitiesObjectMapping[referencedEntityKey]} {`);
+            // Add actual declaration of the referenced entity
+            addInnerPropertyDeclaration(lines, propertiesNode, referencedEntityKey);
+            lines.push('}');
+            lines.push('');
         }
-        return { referenceEntitiesObjectMapping, lines, hasReferenceEntities };
-    }
-    static addSPReferencedEntityModelInterfaceDeclaration(schemaJson, lines) {
-        const referenceEntitiesObjectMapping = {};
-        const schema = JSON.parse(schemaJson);
-        const root = this.parseSchemaJson(schemaJson);
-        const propertiesNode = this.getPropertiesNode(root);
-        const referencedEntities = typeof schema.referencedEntities === 'object' && schema.referencedEntities !== null
-            ? schema.referencedEntities
-            : null;
-        if (referencedEntities) {
-            for (const referencedEntityKey in referencedEntities) {
-                if (!Object.prototype.hasOwnProperty.call(referencedEntities, referencedEntityKey)) {
+    }
+    return {
+        mapping: referenceEntitiesObjectMapping,
+        lines,
+    };
+}
+function addInnerPropertyDeclaration(lines, propertiesNode, referencedEntityKey) {
+    const propertyValue = propertiesNode[referencedEntityKey];
+    if (propertyValue !== null && typeof propertyValue === 'object' && !Array.isArray(propertyValue)) {
+        const propObj = propertyValue;
+        if (propObj.properties && typeof propObj.properties === 'object' && !Array.isArray(propObj.properties)) {
+            const properties = propObj.properties;
+            for (const prop in properties) {
+                if (!Object.prototype.hasOwnProperty.call(properties, prop)) {
                     continue;
                 }
-                referenceEntitiesObjectMapping[referencedEntityKey] = referencedEntityKey + 'Value';
-                if (!(referencedEntityKey in propertiesNode)) {
-                    continue;
+                const propValue = properties[prop];
+                if (propValue !== null && typeof propValue === 'object' && !Array.isArray(propValue)) {
+                    const propValueObj = propValue;
+                    const normalizedProp = convertToValidIdentifier(prop);
+                    lines.push(`  ${normalizedProp}: ${mapJsonTypeToTypeScript(propValueObj.type)};`);
                 }
-                lines.push(`export interface ${referenceEntitiesObjectMapping[referencedEntityKey]} {`);
-                // Add actual declaration of the referenced entity
-                this.addInnerPropertyDeclaration(lines, propertiesNode, referencedEntityKey);
-                lines.push('}');
-                lines.push('');
             }
         }
-        return {
-            mapping: referenceEntitiesObjectMapping,
-            lines,
-        };
-    }
-    static addInnerPropertyDeclaration(lines, propertiesNode, referencedEntityKey) {
-        const propertyValue = propertiesNode[referencedEntityKey];
-        if (propertyValue !== null && typeof propertyValue === 'object' && !Array.isArray(propertyValue)) {
-            const propObj = propertyValue;
-            if (propObj.properties &&
-                typeof propObj.properties === 'object' &&
-                !Array.isArray(propObj.properties)) {
-                const properties = propObj.properties;
-                for (const prop in properties) {
-                    if (!Object.prototype.hasOwnProperty.call(properties, prop)) {
+        else if ('items' in propObj && typeof propObj.items === 'object' && propObj.items !== null) {
+            const items = propObj.items;
+            if ('properties' in items && typeof items.properties === 'object' && items.properties !== null) {
+                const itemProperties = items.properties;
+                for (const itemProp in itemProperties) {
+                    if (!Object.prototype.hasOwnProperty.call(itemProperties, itemProp)) {
                         continue;
                     }
-                    const propValue = properties[prop];
-                    if (propValue !== null && typeof propValue === 'object' && !Array.isArray(propValue)) {
-                        const propValueObj = propValue;
-                        const normalizedProp = convertToValidIdentifier(prop);
-                        lines.push(`  ${normalizedProp}: ${this.mapJsonTypeToTypeScript(propValueObj.type)};`);
+                    const itemPropValue = itemProperties[itemProp];
+                    if (itemPropValue !== null && typeof itemPropValue === 'object' && !Array.isArray(itemPropValue)) {
+                        const itemPropValueObj = itemPropValue;
+                        const normalizedItemProp = convertToValidIdentifier(itemProp);
+                        lines.push(`  ${normalizedItemProp}: ${mapJsonTypeToTypeScript(itemPropValueObj.type)};`);
                     }
                 }
             }
-            else if ('items' in propObj && typeof propObj.items === 'object' && propObj.items !== null) {
-                const items = propObj.items;
-                if ('properties' in items && typeof items.properties === 'object' && items.properties !== null) {
-                    const itemProperties = items.properties;
-                    for (const itemProp in itemProperties) {
-                        if (!Object.prototype.hasOwnProperty.call(itemProperties, itemProp)) {
-                            continue;
-                        }
-                        const itemPropValue = itemProperties[itemProp];
-                        if (itemPropValue !== null &&
-                            typeof itemPropValue === 'object' &&
-                            !Array.isArray(itemPropValue)) {
-                            const itemPropValueObj = itemPropValue;
-                            const normalizedItemProp = convertToValidIdentifier(itemProp);
-                            lines.push(`  ${normalizedItemProp}: ${this.mapJsonTypeToTypeScript(itemPropValueObj.type)};`);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    /*
-     * The addModelInterfaceDeclaration method generates the TypeScript interface declaration for the model.
-     */
-    static addModelInterfaceDeclaration(lines, modelName, propertiesNode, requiredFields, primaryKey) {
-        lines.push(`export interface ${convertToValidIdentifier(modelName)} {`);
-        primaryKey.value = '';
-        // propertiesNode is an object with keys as property names.
-        for (const propName of Object.keys(propertiesNode)) {
-            this.addPropertyDeclaration(lines, propName, propertiesNode[propName], requiredFields, primaryKey);
-        }
-        lines.push('}');
-        lines.push('');
-    }
-    /*
-     * The addPropertyDeclaration method generates the TypeScript property declaration for a given JSON property.
-     * It checks if the property name is valid, maps the JSON type to TypeScript type,
-     * and adds the property to the lines list.
-     */
-    static addPropertyDeclaration(lines, propertyName, propertyValue, requiredFields, primaryKey) {
-        let propName = propertyName;
-        // Extract type information
-        let propType = 'unknown';
-        let dataverseType;
-        if (propertyValue !== null && typeof propertyValue === 'object' && !Array.isArray(propertyValue)) {
-            const propObj = propertyValue;
-            // Check for Dataverse-specific type first
-            if ('x-ms-dataverse-type' in propObj && typeof propObj['x-ms-dataverse-type'] === 'string') {
-                dataverseType = propObj['x-ms-dataverse-type'];
-                // Map Dataverse type to TypeScript type
-                propType = this.mapDataverseTypeToTypeScript(dataverseType);
-            }
-            else if ('type' in propObj && typeof propObj.type === 'string') {
-                // Map standard JSON type to TypeScript type
-                propType = this.determineTypeScriptType(propertyName, propObj, '', propName);
-            }
-        }
-        const keyType = typeof propertyValue === 'object' &&
-            propertyValue !== null &&
-            !Array.isArray(propertyValue) &&
-            'x-ms-keyType' in propertyValue
-            ? propertyValue['x-ms-keyType']
-            : '';
-        if (keyType === 'primary') {
-            primaryKey.value = propName;
-        }
-        // Check if the property name is valid
-        if (!isValidPropertyName(propName)) {
-            propName = `"${propName}"`; // Enclose invalid property names in double quotes
         }
-        const isRequired = requiredFields.has(propertyName);
-        const optionalMark = isRequired ? '' : '?';
-        lines.push(`  ${propName}${optionalMark}: ${propType};`);
-    }
-    /*
-     * The generateTypeScriptService method generates a TypeScript service class for the model.
-     * It includes methods for CRUD operations and uses the Power SDK for data access.
-     */
-    static generateTypeScriptService(modelName, dataSourceName, primaryKey, isADataverseEntity) {
-        const lines = [];
-        this.addCopyrightNotice(lines);
-        this.addStandardServiceImports(lines, modelName, isADataverseEntity, false);
-        this.addServiceClassDefinition(lines, modelName, dataSourceName, primaryKey, isADataverseEntity);
-        return lines.join('\n');
     }
-    /*
-     * The generateDataverseTypeScriptService method generates a TypeScript service class specifically for Dataverse entities.
-     * It handles lookup columns by using base interface for Create/Update and extended interface for Get/GetAll operations.
-     */
-    static generateDataverseTypeScriptService(modelName, dataSourceName, primaryKey, hasLookupColumns) {
-        const lines = [];
-        this.addCopyrightNotice(lines);
-        this.addDataverseServiceImports(lines, modelName, hasLookupColumns);
-        this.addDataverseServiceClassDefinition(lines, modelName, dataSourceName, primaryKey, hasLookupColumns);
-        return lines.join('\n');
-    }
-    /*
-     * The addStandardServiceImports method adds the necessary imports for the service class.
-     */
-    static addStandardServiceImports(lines, modelName, isADataverseEntity, additionalLine = true) {
-        const imports = [...this.collectStandardImports('crud')];
-        imports.push(`import type { IGetOptions, IGetAllOptions } from '${this.RELATIVE_MODEL_PATH}/CommonModels';`, `import type { ${modelName} } from '${this.RELATIVE_MODEL_PATH}/${modelName}Model';`);
-        if (isADataverseEntity) {
-            imports.push("import type { GetEntityMetadataOptions, EntityMetadata } from '@microsoft/power-apps/data/metadata/dataverse';");
-        }
-        lines.push(...imports.sort());
-        if (additionalLine) {
-            lines.push('');
-        }
-    }
-    /*
-     * The addDataverseServiceImports method adds the necessary imports for Dataverse service classes with lookup columns.
-     */
-    static addDataverseServiceImports(lines, modelName, hasLookupColumns) {
-        const imports = [...this.collectStandardImports('crud')];
-        imports.push(`import type { IGetOptions, IGetAllOptions } from '${this.RELATIVE_MODEL_PATH}/CommonModels';`);
-        if (hasLookupColumns) {
-            // Import both base and extended interfaces
-            imports.push(`import type { ${modelName}Base, ${modelName} } from '${this.RELATIVE_MODEL_PATH}/${modelName}Model';`);
-        }
-        else {
-            // Import single interface
-            imports.push(`import type { ${modelName}Base } from '${this.RELATIVE_MODEL_PATH}/${modelName}Model';`);
-        }
+}
+/*
+ * The addModelInterfaceDeclaration method generates the TypeScript interface declaration for the model.
+ */
+function addModelInterfaceDeclaration(lines, modelName, propertiesNode, requiredFields, primaryKey) {
+    lines.push(`export interface ${convertToValidIdentifier(modelName)} {`);
+    primaryKey.value = '';
+    // propertiesNode is an object with keys as property names.
+    for (const propName of Object.keys(propertiesNode)) {
+        addPropertyDeclaration(lines, propName, propertiesNode[propName], requiredFields, primaryKey);
+    }
+    lines.push('}');
+    lines.push('');
+}
+/*
+ * The addPropertyDeclaration method generates the TypeScript property declaration for a given JSON property.
+ * It checks if the property name is valid, maps the JSON type to TypeScript type,
+ * and adds the property to the lines list.
+ */
+function addPropertyDeclaration(lines, propertyName, propertyValue, requiredFields, primaryKey) {
+    let propName = propertyName;
+    // Extract type information
+    let propType = 'unknown';
+    let dataverseType;
+    if (propertyValue !== null && typeof propertyValue === 'object' && !Array.isArray(propertyValue)) {
+        const propObj = propertyValue;
+        // Check for Dataverse-specific type first
+        if ('x-ms-dataverse-type' in propObj && typeof propObj['x-ms-dataverse-type'] === 'string') {
+            dataverseType = propObj['x-ms-dataverse-type'];
+            // Map Dataverse type to TypeScript type
+            propType = mapDataverseTypeToTypeScript(dataverseType);
+        }
+        else if ('type' in propObj && typeof propObj.type === 'string') {
+            // Map standard JSON type to TypeScript type
+            propType = determineTypeScriptType(propertyName, propObj, '', propName);
+        }
+    }
+    const keyType = typeof propertyValue === 'object' &&
+        propertyValue !== null &&
+        !Array.isArray(propertyValue) &&
+        'x-ms-keyType' in propertyValue
+        ? propertyValue['x-ms-keyType']
+        : '';
+    if (keyType === 'primary') {
+        primaryKey.value = propName;
+    }
+    // Check if the property name is valid
+    if (!isValidPropertyName(propName)) {
+        propName = `"${propName}"`; // Enclose invalid property names in double quotes
+    }
+    const isRequired = requiredFields.has(propertyName);
+    const optionalMark = isRequired ? '' : '?';
+    lines.push(`  ${propName}${optionalMark}: ${propType};`);
+}
+/*
+ * The generateTypeScriptService method generates a TypeScript service class for the model.
+ * It includes methods for CRUD operations and uses the Power SDK for data access.
+ */
+function generateTypeScriptService(modelName, dataSourceName, primaryKey, isADataverseEntity) {
+    const lines = [];
+    addCopyrightNotice(lines);
+    addStandardServiceImports(lines, modelName, isADataverseEntity, false);
+    addServiceClassDefinition(lines, modelName, dataSourceName, primaryKey, isADataverseEntity);
+    return lines.join('\n');
+}
+/*
+ * The generateDataverseTypeScriptService method generates a TypeScript service class specifically for Dataverse entities.
+ * It handles lookup columns by using base interface for Create/Update and extended interface for Get/GetAll operations.
+ */
+function generateDataverseTypeScriptService(modelName, dataSourceName, primaryKey, hasLookupColumns) {
+    const lines = [];
+    addCopyrightNotice(lines);
+    addDataverseServiceImports(lines, modelName, hasLookupColumns);
+    addDataverseServiceClassDefinition(lines, modelName, dataSourceName, primaryKey, hasLookupColumns);
+    return lines.join('\n');
+}
+/*
+ * The addStandardServiceImports method adds the necessary imports for the service class.
+ */
+function addStandardServiceImports(lines, modelName, isADataverseEntity, additionalLine = true) {
+    const imports = [...collectStandardImports('crud')];
+    imports.push(`import type { IGetOptions, IGetAllOptions } from '${RELATIVE_MODEL_PATH}/CommonModels';`, `import type { ${modelName} } from '${RELATIVE_MODEL_PATH}/${modelName}Model';`);
+    if (isADataverseEntity) {
         imports.push("import type { GetEntityMetadataOptions, EntityMetadata } from '@microsoft/power-apps/data/metadata/dataverse';");
-        lines.push(...imports.sort());
-        lines.push('');
     }
-    static addSharepointServiceImports(lines, modelName, hasReferenceEntities) {
-        const imports = [...this.collectStandardImports('crud')];
-        imports.push(`import type { IGetOptions, IGetAllOptions } from '${this.RELATIVE_MODEL_PATH}/CommonModels';`);
-        if (hasReferenceEntities) {
-            // Import both base and read/write interfaces
-            imports.push(`import type { ${modelName}Read, ${modelName}Write } from '${this.RELATIVE_MODEL_PATH}/${modelName}Model';`);
-        }
-        else {
-            // Import single interface
-            imports.push(`import type { ${modelName}Base } from '${this.RELATIVE_MODEL_PATH}/${modelName}Model';`);
-        }
-        lines.push(...imports.sort());
+    lines.push(...imports.sort());
+    if (additionalLine) {
         lines.push('');
     }
-    /*
-     * The addServiceFields method adds fields to the service class.
-     * It includes the Power SDK instance and a static instance of the service.
-     */
-    static addServiceFields(lines, dataSourceName) {
-        lines.push(`  private static readonly dataSourceName = '${dataSourceName.toLowerCase()}';`);
-        lines.push(``);
-        lines.push(`  private static readonly client = getClient(dataSourcesInfo);`);
-    }
-    /*
-     * The AddServiceClassDefinition method generates the service class definition.
-     * It takes the lines to write to, model name, data source name, schema, and response model name as parameters.
-     */
-    static addServiceClassDefinition(lines, modelName, dataSourceName, primaryKey, isADataverseEntity) {
-        this.addServiceClassHeader(lines, modelName, dataSourceName, true);
-        this.addServiceMethods(lines, modelName, dataSourceName, primaryKey, isADataverseEntity);
-        lines.push('}');
+}
+/*
+ * The addDataverseServiceImports method adds the necessary imports for Dataverse service classes with lookup columns.
+ */
+function addDataverseServiceImports(lines, modelName, hasLookupColumns) {
+    const imports = [...collectStandardImports('crud')];
+    imports.push(`import type { IGetOptions, IGetAllOptions } from '${RELATIVE_MODEL_PATH}/CommonModels';`);
+    if (hasLookupColumns) {
+        // Import both base and extended interfaces
+        imports.push(`import type { ${modelName}Base, ${modelName} } from '${RELATIVE_MODEL_PATH}/${modelName}Model';`);
+    }
+    else {
+        // Import single interface
+        imports.push(`import type { ${modelName}Base } from '${RELATIVE_MODEL_PATH}/${modelName}Model';`);
+    }
+    imports.push("import type { GetEntityMetadataOptions, EntityMetadata } from '@microsoft/power-apps/data/metadata/dataverse';");
+    lines.push(...imports.sort());
+    lines.push('');
+}
+function addSharepointServiceImports(lines, modelName, hasReferenceEntities) {
+    const imports = [...collectStandardImports('crud')];
+    imports.push(`import type { IGetOptions, IGetAllOptions } from '${RELATIVE_MODEL_PATH}/CommonModels';`);
+    if (hasReferenceEntities) {
+        // Import both base and read/write interfaces
+        imports.push(`import type { ${modelName}Read, ${modelName}Write } from '${RELATIVE_MODEL_PATH}/${modelName}Model';`);
+    }
+    else {
+        // Import single interface
+        imports.push(`import type { ${modelName}Base } from '${RELATIVE_MODEL_PATH}/${modelName}Model';`);
+    }
+    lines.push(...imports.sort());
+    lines.push('');
+}
+/*
+ * The addServiceFields method adds fields to the service class.
+ * It includes the Power SDK instance and a static instance of the service.
+ */
+function addServiceFields(lines, dataSourceName) {
+    lines.push(`  private static readonly dataSourceName = '${dataSourceName.toLowerCase()}';`);
+    lines.push(``);
+    lines.push(`  private static readonly client = getClient(dataSourcesInfo);`);
+}
+/*
+ * The AddServiceClassDefinition method generates the service class definition.
+ * It takes the lines to write to, model name, data source name, schema, and response model name as parameters.
+ */
+function addServiceClassDefinition(lines, modelName, dataSourceName, primaryKey, isADataverseEntity) {
+    addServiceClassHeader(lines, modelName, dataSourceName, true);
+    addServiceMethods(lines, modelName, dataSourceName, primaryKey, isADataverseEntity);
+    lines.push('}');
+    lines.push('');
+}
+/*
+ * The addDataverseServiceClassDefinition method generates the service class definition for Dataverse entities with lookup columns.
+ */
+function addDataverseServiceClassDefinition(lines, modelName, dataSourceName, primaryKey, hasLookupColumns) {
+    addServiceClassHeader(lines, modelName, dataSourceName, true);
+    addDataverseServiceMethods(lines, modelName, dataSourceName, primaryKey, hasLookupColumns);
+    lines.push('}');
+    lines.push('');
+}
+/*
+ * The addServiceMethods method generates the CRUD methods for the service class.
+ * It includes create, update, delete, get, and getAll methods.
+ */
+function addServiceMethods(lines, modelName, dataSourceName, primaryKey, isADataverseEntity) {
+    const methods = [];
+    methods.push(generateCreateMethod(modelName, primaryKey));
+    methods.push(generateUpdateMethod(modelName, primaryKey));
+    methods.push(generateDeleteMethod(modelName));
+    methods.push(generateGetMethod(modelName));
+    methods.push(generateGetAllMethod(modelName));
+    if (isADataverseEntity) {
+        methods.push(generateGetMetadataMethod(modelName));
+    }
+    for (const method of methods) {
         lines.push('');
+        lines.push(...method);
     }
-    /*
-     * The addDataverseServiceClassDefinition method generates the service class definition for Dataverse entities with lookup columns.
-     */
-    static addDataverseServiceClassDefinition(lines, modelName, dataSourceName, primaryKey, hasLookupColumns) {
-        this.addServiceClassHeader(lines, modelName, dataSourceName, true);
-        this.addDataverseServiceMethods(lines, modelName, dataSourceName, primaryKey, hasLookupColumns);
-        lines.push('}');
+}
+/*
+ * The addDataverseServiceMethods method generates the CRUD methods for Dataverse service classes with lookup columns.
+ * Uses base interface for Create/Update and extended interface for Get/GetAll operations.
+ */
+function addDataverseServiceMethods(lines, modelName, dataSourceName, primaryKey, hasLookupColumns) {
+    const methods = [];
+    methods.push(generateDataverseCreateMethod(modelName, primaryKey, hasLookupColumns));
+    methods.push(generateDataverseUpdateMethod(modelName, primaryKey, hasLookupColumns));
+    methods.push(generateDeleteMethod(modelName));
+    methods.push(generateDataverseGetMethod(modelName, hasLookupColumns));
+    methods.push(generateDataverseGetAllMethod(modelName, hasLookupColumns));
+    methods.push(generateDataverseGetMetadataMethod(modelName, hasLookupColumns));
+    for (const method of methods) {
         lines.push('');
+        lines.push(...method);
     }
-    /*
-     * The addServiceMethods method generates the CRUD methods for the service class.
-     * It includes create, update, delete, get, and getAll methods.
-     */
-    static addServiceMethods(lines, modelName, dataSourceName, primaryKey, isADataverseEntity) {
-        const methods = [];
-        methods.push(this.generateCreateMethod(modelName, primaryKey));
-        methods.push(this.generateUpdateMethod(modelName, primaryKey));
-        methods.push(this.generateDeleteMethod(modelName));
-        methods.push(this.generateGetMethod(modelName));
-        methods.push(this.generateGetAllMethod(modelName));
-        if (isADataverseEntity) {
-            methods.push(this.generateGetMetadataMethod(modelName));
-        }
-        for (const method of methods) {
-            lines.push('');
-            lines.push(...method);
-        }
-    }
-    /*
-     * The addDataverseServiceMethods method generates the CRUD methods for Dataverse service classes with lookup columns.
-     * Uses base interface for Create/Update and extended interface for Get/GetAll operations.
-     */
-    static addDataverseServiceMethods(lines, modelName, dataSourceName, primaryKey, hasLookupColumns) {
-        const methods = [];
-        methods.push(this.generateDataverseCreateMethod(modelName, primaryKey, hasLookupColumns));
-        methods.push(this.generateDataverseUpdateMethod(modelName, primaryKey, hasLookupColumns));
-        methods.push(this.generateDeleteMethod(modelName));
-        methods.push(this.generateDataverseGetMethod(modelName, hasLookupColumns));
-        methods.push(this.generateDataverseGetAllMethod(modelName, hasLookupColumns));
-        methods.push(this.generateDataverseGetMetadataMethod(modelName, hasLookupColumns));
-        for (const method of methods) {
-            lines.push('');
-            lines.push(...method);
-        }
-    }
-    /*
-     * The create method adds a new record to the data source.
-     */
-    static generateCreateMethod(modelName, primaryKey) {
-        const datatypeForCreate = primaryKey !== '' ? `Omit<${modelName}, '${primaryKey}'>` : modelName;
-        return [
-            `  public static async create(record: ${datatypeForCreate}): Promise<IOperationResult<${modelName}>> {`,
-            `    const result = await ${modelName}Service.client.createRecordAsync<${datatypeForCreate}, ${modelName}>(`,
-            `      ${getServiceName(modelName)},`,
-            `      record`,
-            `    );`,
-            `    return result;`,
-            `  }`,
-        ];
-    }
-    /*
-     * The update method modifies an existing record.
-     */
-    static generateUpdateMethod(modelName, primaryKey) {
-        const datatypeForUpdate = primaryKey !== '' ? `Partial<Omit<${modelName}, '${primaryKey}'>>` : modelName;
-        return [
-            `  public static async update(id: string, changedFields: ${datatypeForUpdate}): Promise<IOperationResult<${modelName}>> {`,
-            `    const result = await ${modelName}Service.client.updateRecordAsync<${datatypeForUpdate}, ${modelName}>(`,
-            `      ${getServiceName(modelName)},`,
-            `      id.toString(),`,
-            `      changedFields`,
-            `    );`,
-            `    return result;`,
-            `  }`,
-        ];
-    }
-    /*
-     * The delete method removes a record by its ID.
-     */
-    static generateDeleteMethod(modelName) {
-        return [
-            `  public static async delete(id: string): Promise<void> {`,
-            `    await ${modelName}Service.client.deleteRecordAsync(`,
-            `      ${getServiceName(modelName)},`,
-            `      id.toString());`,
-            `  }`,
-        ];
-    }
-    /*
-     * The get method retrieves a record by its ID.
-     */
-    static generateGetMethod(modelName) {
-        return [
-            `  public static async get(id: string, options?: IGetOptions): Promise<IOperationResult<${modelName}>> {`,
-            `    const result = await ${modelName}Service.client.retrieveRecordAsync<${modelName}>(`,
-            `      ${getServiceName(modelName)},`,
-            `      id.toString(),`,
-            `      options`,
-            `    );`,
-            `    return result;`,
-            `  }`,
-        ];
-    }
-    /*
-     * The getAll method retrieves all records of the specified model.
-     */
-    static generateGetAllMethod(modelName) {
-        return [
-            `  public static async getAll(options?: IGetAllOptions): Promise<IOperationResult<${modelName}[]>> {`,
-            `    const result = await ${modelName}Service.client.retrieveMultipleRecordsAsync<${modelName}>(`,
-            `      ${getServiceName(modelName)},`,
-            `      options`,
-            `    );`,
-            `    return result;`,
-            `  }`,
-        ];
-    }
-    static generateGetMetadataMethod(modelName) {
-        return [
-            `  public static getMetadata(`,
-            `    options: GetEntityMetadataOptions<${modelName}> = {}`,
-            `  ): Promise<IOperationResult<Partial<EntityMetadata>>> {`,
-            `    return ${modelName}Service.client.executeAsync({`,
-            `      dataverseRequest: {`,
-            `        action: "getEntityMetadata",`,
-            `        parameters: {`,
-            `          tableName: ${getServiceName(modelName)},`,
-            `          options: options as GetEntityMetadataOptions,`,
-            `        },`,
-            `      },`,
-            `    });`,
-            `  }`,
-        ];
-    }
-    /*
-     * The create method adds a new record to the data source.
-     */
-    static generateSharepointCreateMethod(modelName, primaryKey, hasReferenceEntities) {
-        /**
-         * if hasReferenceEntities is true take in modelNameWrite-primaryKey as input and return modelNameRead
-         * else take in modelNameBase-primaryKey as input and return modelNameBase
-         */
-        const datatypeForCreate = primaryKey !== ''
-            ? `Omit<${hasReferenceEntities ? `${modelName}Write` : `${modelName}Base`}, '${primaryKey}'>`
-            : hasReferenceEntities
-                ? `${modelName}Write`
-                : `${modelName}Base`;
-        const returnType = hasReferenceEntities ? `${modelName}Read` : `${modelName}Base`;
-        return [
-            `  public static async create(record: ${datatypeForCreate}): Promise<IOperationResult<${returnType}>> {`,
-            `    const result = await ${modelName}Service.client.createRecordAsync<${datatypeForCreate}, ${returnType}>(`,
-            `      ${getServiceName(modelName)},`,
-            `      record`,
-            `    );`,
-            `    return result;`,
-            `  }`,
-        ];
-    }
-    /*
-     * The update method modifies an existing record.
-     */
-    static generateSharepointUpdateMethod(modelName, primaryKey, hasReferenceEntities) {
-        /**
-         * if hasReferenceEntities is true take in modelNameWrite-primaryKey as input and return modelNameRead
-         * else take in modelNameBase-primaryKey as input and return modelNameBase
-         */
-        const datatypeForUpdate = primaryKey !== ''
-            ? `Partial<Omit<${hasReferenceEntities ? `${modelName}Write` : `${modelName}Base`}, '${primaryKey}'>>`
-            : hasReferenceEntities
-                ? `${modelName}Write`
-                : `${modelName}Base`;
-        const returnType = hasReferenceEntities ? `${modelName}Read` : `${modelName}Base`;
-        return [
-            `  public static async update(id: string, changedFields: ${datatypeForUpdate}): Promise<IOperationResult<${returnType}>> {`,
-            `    const result = await ${modelName}Service.client.updateRecordAsync<${datatypeForUpdate}, ${returnType}>(`,
-            `      ${getServiceName(modelName)},`,
-            `      id.toString(),`,
-            `      changedFields`,
-            `    );`,
-            `    return result;`,
-            `  }`,
-        ];
-    }
-    /*
-     * The delete method removes a record by its ID.
-     */
-    static generateSharepointDeleteMethod(modelName) {
-        return [
-            `  public static async delete(id: string): Promise<void> {`,
-            `    await ${modelName}Service.client.deleteRecordAsync(`,
-            `      ${getServiceName(modelName)},`,
-            `      id.toString());`,
-            `  }`,
-        ];
-    }
-    /*
-     * The get method retrieves a record by its ID.
-     */
-    static generateSharepointGetMethod(modelName, hasReferenceEntities) {
-        /**
-         * if referenceEntities is true return modelNameRead
-         * else return modelNameBase
-         */
-        const returnType = hasReferenceEntities ? `${modelName}Read` : `${modelName}Base`;
-        /**
-         */
-        return [
-            `  public static async get(id: string, options?: IGetOptions): Promise<IOperationResult<${returnType}>> {`,
-            `    const result = await ${modelName}Service.client.retrieveRecordAsync<${returnType}>(`,
-            `      ${getServiceName(modelName)},`,
-            `      id.toString(),`,
-            `      options`,
-            `    );`,
-            `    return result;`,
-            `  }`,
-        ];
-    }
-    /*
-     * The getAll method retrieves all records of the specified model.
-     */
-    static generateSharepointGetAllMethod(modelName, hasReferenceEntities) {
-        const returnType = hasReferenceEntities ? `${modelName}Read` : `${modelName}Base`;
-        return [
-            `  public static async getAll(options?: IGetAllOptions): Promise<IOperationResult<${returnType}[]>> {`,
-            `    const result = await ${modelName}Service.client.retrieveMultipleRecordsAsync<${returnType}>(`,
-            `      ${getServiceName(modelName)},`,
-            `      options`,
-            `    );`,
-            `    return result;`,
-            `  }`,
-        ];
-    }
-    /*
-     * The generateDataverseCreateMethod method adds a new record using the base interface for Dataverse entities.
-     */
-    static generateDataverseCreateMethod(modelName, primaryKey, hasLookupColumns) {
-        const baseInterfaceName = hasLookupColumns ? `${modelName}Base` : modelName;
-        const extendedInterfaceName = modelName;
-        const datatypeForCreate = primaryKey !== '' ? `Omit<${baseInterfaceName}, '${primaryKey}'>` : baseInterfaceName;
-        return [
-            `  public static async create(record: ${datatypeForCreate}): Promise<IOperationResult<${extendedInterfaceName}>> {`,
-            `    const result = await ${modelName}Service.client.createRecordAsync<${datatypeForCreate}, ${extendedInterfaceName}>(`,
-            `      ${getServiceName(modelName)},`,
-            `      record`,
-            `    );`,
-            `    return result;`,
-            `  }`,
-        ];
-    }
-    /*
-     * The generateDataverseUpdateMethod method modifies an existing record using the base interface for Dataverse entities.
-     */
-    static generateDataverseUpdateMethod(modelName, primaryKey, hasLookupColumns) {
-        const baseInterfaceName = hasLookupColumns ? `${modelName}Base` : modelName;
-        const extendedInterfaceName = modelName;
-        const datatypeForUpdate = primaryKey !== '' ? `Partial<Omit<${baseInterfaceName}, '${primaryKey}'>>` : baseInterfaceName;
-        return [
-            `  public static async update(id: string, changedFields: ${datatypeForUpdate}): Promise<IOperationResult<${extendedInterfaceName}>> {`,
-            `    const result = await ${modelName}Service.client.updateRecordAsync<${datatypeForUpdate}, ${extendedInterfaceName}>(`,
-            `      ${getServiceName(modelName)},`,
-            `      id.toString(),`,
-            `      changedFields`,
-            `    );`,
-            `    return result;`,
-            `  }`,
-        ];
-    }
-    /*
-     * The generateDataverseGetMethod method retrieves a record by its ID using the extended interface for Dataverse entities.
-     */
-    static generateDataverseGetMethod(modelName, hasLookupColumns) {
-        const extendedInterfaceName = modelName;
-        return [
-            `  public static async get(id: string, options?: IGetOptions): Promise<IOperationResult<${extendedInterfaceName}>> {`,
-            `    const result = await ${modelName}Service.client.retrieveRecordAsync<${extendedInterfaceName}>(`,
-            `      ${getServiceName(modelName)},`,
-            `      id.toString(),`,
-            `      options`,
-            `    );`,
-            `    return result;`,
-            `  }`,
-        ];
-    }
-    /*
-     * The generateDataverseGetAllMethod method retrieves all records using the extended interface for Dataverse entities.
-     */
-    static generateDataverseGetAllMethod(modelName, hasLookupColumns) {
-        const extendedInterfaceName = modelName;
-        return [
-            `  public static async getAll(options?: IGetAllOptions): Promise<IOperationResult<${extendedInterfaceName}[]>> {`,
-            `    const result = await ${modelName}Service.client.retrieveMultipleRecordsAsync<${extendedInterfaceName}>(`,
-            `      ${getServiceName(modelName)},`,
-            `      options`,
-            `    );`,
-            `    return result;`,
-            `  }`,
-        ];
-    }
-    /*
-     * The generateDataverseGetMetadataMethod method gets metadata using the extended interface for Dataverse entities.
+}
+/*
+ * The create method adds a new record to the data source.
+ */
+function generateCreateMethod(modelName, primaryKey) {
+    const datatypeForCreate = primaryKey !== '' ? `Omit<${modelName}, '${primaryKey}'>` : modelName;
+    return [
+        `  public static async create(record: ${datatypeForCreate}): Promise<IOperationResult<${modelName}>> {`,
+        `    const result = await ${modelName}Service.client.createRecordAsync<${datatypeForCreate}, ${modelName}>(`,
+        `      ${getServiceName(modelName)},`,
+        `      record`,
+        `    );`,
+        `    return result;`,
+        `  }`,
+    ];
+}
+/*
+ * The update method modifies an existing record.
+ */
+function generateUpdateMethod(modelName, primaryKey) {
+    const datatypeForUpdate = primaryKey !== '' ? `Partial<Omit<${modelName}, '${primaryKey}'>>` : modelName;
+    return [
+        `  public static async update(id: string, changedFields: ${datatypeForUpdate}): Promise<IOperationResult<${modelName}>> {`,
+        `    const result = await ${modelName}Service.client.updateRecordAsync<${datatypeForUpdate}, ${modelName}>(`,
+        `      ${getServiceName(modelName)},`,
+        `      id.toString(),`,
+        `      changedFields`,
+        `    );`,
+        `    return result;`,
+        `  }`,
+    ];
+}
+/*
+ * The delete method removes a record by its ID.
+ */
+function generateDeleteMethod(modelName) {
+    return [
+        `  public static async delete(id: string): Promise<void> {`,
+        `    await ${modelName}Service.client.deleteRecordAsync(`,
+        `      ${getServiceName(modelName)},`,
+        `      id.toString());`,
+        `  }`,
+    ];
+}
+/*
+ * The get method retrieves a record by its ID.
+ */
+function generateGetMethod(modelName) {
+    return [
+        `  public static async get(id: string, options?: IGetOptions): Promise<IOperationResult<${modelName}>> {`,
+        `    const result = await ${modelName}Service.client.retrieveRecordAsync<${modelName}>(`,
+        `      ${getServiceName(modelName)},`,
+        `      id.toString(),`,
+        `      options`,
+        `    );`,
+        `    return result;`,
+        `  }`,
+    ];
+}
+/*
+ * The getAll method retrieves all records of the specified model.
+ */
+function generateGetAllMethod(modelName) {
+    return [
+        `  public static async getAll(options?: IGetAllOptions): Promise<IOperationResult<${modelName}[]>> {`,
+        `    const result = await ${modelName}Service.client.retrieveMultipleRecordsAsync<${modelName}>(`,
+        `      ${getServiceName(modelName)},`,
+        `      options`,
+        `    );`,
+        `    return result;`,
+        `  }`,
+    ];
+}
+function generateGetMetadataMethod(modelName) {
+    return [
+        `  public static getMetadata(`,
+        `    options: GetEntityMetadataOptions<${modelName}> = {}`,
+        `  ): Promise<IOperationResult<Partial<EntityMetadata>>> {`,
+        `    return ${modelName}Service.client.executeAsync({`,
+        `      dataverseRequest: {`,
+        `        action: "getEntityMetadata",`,
+        `        parameters: {`,
+        `          tableName: ${getServiceName(modelName)},`,
+        `          options: options as GetEntityMetadataOptions,`,
+        `        },`,
+        `      },`,
+        `    });`,
+        `  }`,
+    ];
+}
+/*
+ * The create method adds a new record to the data source.
+ */
+function generateSharepointCreateMethod(modelName, primaryKey, hasReferenceEntities) {
+    /**
+     * if hasReferenceEntities is true take in modelNameWrite-primaryKey as input and return modelNameRead
+     * else take in modelNameBase-primaryKey as input and return modelNameBase
+     */
+    const datatypeForCreate = primaryKey !== ''
+        ? `Omit<${hasReferenceEntities ? `${modelName}Write` : `${modelName}Base`}, '${primaryKey}'>`
+        : hasReferenceEntities
+            ? `${modelName}Write`
+            : `${modelName}Base`;
+    const returnType = hasReferenceEntities ? `${modelName}Read` : `${modelName}Base`;
+    return [
+        `  public static async create(record: ${datatypeForCreate}): Promise<IOperationResult<${returnType}>> {`,
+        `    const result = await ${modelName}Service.client.createRecordAsync<${datatypeForCreate}, ${returnType}>(`,
+        `      ${getServiceName(modelName)},`,
+        `      record`,
+        `    );`,
+        `    return result;`,
+        `  }`,
+    ];
+}
+/*
+ * The update method modifies an existing record.
+ */
+function generateSharepointUpdateMethod(modelName, primaryKey, hasReferenceEntities) {
+    /**
+     * if hasReferenceEntities is true take in modelNameWrite-primaryKey as input and return modelNameRead
+     * else take in modelNameBase-primaryKey as input and return modelNameBase
+     */
+    const datatypeForUpdate = primaryKey !== ''
+        ? `Partial<Omit<${hasReferenceEntities ? `${modelName}Write` : `${modelName}Base`}, '${primaryKey}'>>`
+        : hasReferenceEntities
+            ? `${modelName}Write`
+            : `${modelName}Base`;
+    const returnType = hasReferenceEntities ? `${modelName}Read` : `${modelName}Base`;
+    return [
+        `  public static async update(id: string, changedFields: ${datatypeForUpdate}): Promise<IOperationResult<${returnType}>> {`,
+        `    const result = await ${modelName}Service.client.updateRecordAsync<${datatypeForUpdate}, ${returnType}>(`,
+        `      ${getServiceName(modelName)},`,
+        `      id.toString(),`,
+        `      changedFields`,
+        `    );`,
+        `    return result;`,
+        `  }`,
+    ];
+}
+/*
+ * The delete method removes a record by its ID.
+ */
+function generateSharepointDeleteMethod(modelName) {
+    return [
+        `  public static async delete(id: string): Promise<void> {`,
+        `    await ${modelName}Service.client.deleteRecordAsync(`,
+        `      ${getServiceName(modelName)},`,
+        `      id.toString());`,
+        `  }`,
+    ];
+}
+/*
+ * The get method retrieves a record by its ID.
+ */
+function generateSharepointGetMethod(modelName, hasReferenceEntities) {
+    /**
+     * if referenceEntities is true return modelNameRead
+     * else return modelNameBase
      */
-    static generateDataverseGetMetadataMethod(modelName, hasLookupColumns) {
-        const extendedInterfaceName = modelName;
-        return [
-            `  public static getMetadata(`,
-            `    options: GetEntityMetadataOptions<${extendedInterfaceName}> = {}`,
-            `  ): Promise<IOperationResult<Partial<EntityMetadata>>> {`,
-            `    return ${modelName}Service.client.executeAsync({`,
-            `      dataverseRequest: {`,
-            `        action: "getEntityMetadata",`,
-            `        parameters: {`,
-            `          tableName: ${getServiceName(modelName)},`,
-            `          options: options as GetEntityMetadataOptions,`,
-            `        },`,
-            `      },`,
-            `    });`,
-            `  }`,
-        ];
-    }
+    const returnType = hasReferenceEntities ? `${modelName}Read` : `${modelName}Base`;
     /**
-     * The generateIndexFile method creates an index.ts file that exports all models and services.
      */
-    static async generateIndexFile(outputDir, vfs) {
-        const indexPath = vfs.join(outputDir, this.GENERATED_FOLDER, 'index.ts');
-        const lines = [];
-        // Add copyright notice
-        this.addCopyrightNotice(lines);
-        // Export all models from generated/models
-        const modelsDir = vfs.join(outputDir, this.MODELS_FOLDER);
-        if (await vfs.exists(modelsDir)) {
-            const modelFiles = (await vfs.readdir(modelsDir)).filter((file) => file.endsWith('.ts'));
-            if (modelFiles.length > 0) {
-                lines.push('// Models');
-                for (const file of modelFiles) {
-                    const fileName = file.replace('.ts', '');
-                    lines.push(`export * as ${fileName} from './models/${fileName}';`);
-                }
-                lines.push('');
-            }
-        }
-        // Export all services from generated/services
-        const servicesDir = vfs.join(outputDir, this.SERVICES_FOLDER);
-        if (await vfs.exists(servicesDir)) {
-            const serviceFiles = (await vfs.readdir(servicesDir)).filter((file) => file.endsWith('.ts'));
-            if (serviceFiles.length > 0) {
-                lines.push('// Services');
-                for (const file of serviceFiles) {
-                    const fileName = file.replace('.ts', '');
-                    lines.push(`export * from './services/${fileName}';`);
-                }
-                lines.push('');
+    return [
+        `  public static async get(id: string, options?: IGetOptions): Promise<IOperationResult<${returnType}>> {`,
+        `    const result = await ${modelName}Service.client.retrieveRecordAsync<${returnType}>(`,
+        `      ${getServiceName(modelName)},`,
+        `      id.toString(),`,
+        `      options`,
+        `    );`,
+        `    return result;`,
+        `  }`,
+    ];
+}
+/*
+ * The getAll method retrieves all records of the specified model.
+ */
+function generateSharepointGetAllMethod(modelName, hasReferenceEntities) {
+    const returnType = hasReferenceEntities ? `${modelName}Read` : `${modelName}Base`;
+    return [
+        `  public static async getAll(options?: IGetAllOptions): Promise<IOperationResult<${returnType}[]>> {`,
+        `    const result = await ${modelName}Service.client.retrieveMultipleRecordsAsync<${returnType}>(`,
+        `      ${getServiceName(modelName)},`,
+        `      options`,
+        `    );`,
+        `    return result;`,
+        `  }`,
+    ];
+}
+/*
+ * The generateDataverseCreateMethod method adds a new record using the base interface for Dataverse entities.
+ */
+function generateDataverseCreateMethod(modelName, primaryKey, hasLookupColumns) {
+    const baseInterfaceName = hasLookupColumns ? `${modelName}Base` : modelName;
+    const extendedInterfaceName = modelName;
+    const datatypeForCreate = primaryKey !== '' ? `Omit<${baseInterfaceName}, '${primaryKey}'>` : baseInterfaceName;
+    return [
+        `  public static async create(record: ${datatypeForCreate}): Promise<IOperationResult<${extendedInterfaceName}>> {`,
+        `    const result = await ${modelName}Service.client.createRecordAsync<${datatypeForCreate}, ${extendedInterfaceName}>(`,
+        `      ${getServiceName(modelName)},`,
+        `      record`,
+        `    );`,
+        `    return result;`,
+        `  }`,
+    ];
+}
+/*
+ * The generateDataverseUpdateMethod method modifies an existing record using the base interface for Dataverse entities.
+ */
+function generateDataverseUpdateMethod(modelName, primaryKey, hasLookupColumns) {
+    const baseInterfaceName = hasLookupColumns ? `${modelName}Base` : modelName;
+    const extendedInterfaceName = modelName;
+    const datatypeForUpdate = primaryKey !== '' ? `Partial<Omit<${baseInterfaceName}, '${primaryKey}'>>` : baseInterfaceName;
+    return [
+        `  public static async update(id: string, changedFields: ${datatypeForUpdate}): Promise<IOperationResult<${extendedInterfaceName}>> {`,
+        `    const result = await ${modelName}Service.client.updateRecordAsync<${datatypeForUpdate}, ${extendedInterfaceName}>(`,
+        `      ${getServiceName(modelName)},`,
+        `      id.toString(),`,
+        `      changedFields`,
+        `    );`,
+        `    return result;`,
+        `  }`,
+    ];
+}
+/*
+ * The generateDataverseGetMethod method retrieves a record by its ID using the extended interface for Dataverse entities.
+ */
+function generateDataverseGetMethod(modelName, hasLookupColumns) {
+    const extendedInterfaceName = modelName;
+    return [
+        `  public static async get(id: string, options?: IGetOptions): Promise<IOperationResult<${extendedInterfaceName}>> {`,
+        `    const result = await ${modelName}Service.client.retrieveRecordAsync<${extendedInterfaceName}>(`,
+        `      ${getServiceName(modelName)},`,
+        `      id.toString(),`,
+        `      options`,
+        `    );`,
+        `    return result;`,
+        `  }`,
+    ];
+}
+/*
+ * The generateDataverseGetAllMethod method retrieves all records using the extended interface for Dataverse entities.
+ */
+function generateDataverseGetAllMethod(modelName, hasLookupColumns) {
+    const extendedInterfaceName = modelName;
+    return [
+        `  public static async getAll(options?: IGetAllOptions): Promise<IOperationResult<${extendedInterfaceName}[]>> {`,
+        `    const result = await ${modelName}Service.client.retrieveMultipleRecordsAsync<${extendedInterfaceName}>(`,
+        `      ${getServiceName(modelName)},`,
+        `      options`,
+        `    );`,
+        `    return result;`,
+        `  }`,
+    ];
+}
+/*
+ * The generateDataverseGetMetadataMethod method gets metadata using the extended interface for Dataverse entities.
+ */
+function generateDataverseGetMetadataMethod(modelName, hasLookupColumns) {
+    const extendedInterfaceName = modelName;
+    return [
+        `  public static getMetadata(`,
+        `    options: GetEntityMetadataOptions<${extendedInterfaceName}> = {}`,
+        `  ): Promise<IOperationResult<Partial<EntityMetadata>>> {`,
+        `    return ${modelName}Service.client.executeAsync({`,
+        `      dataverseRequest: {`,
+        `        action: "getEntityMetadata",`,
+        `        parameters: {`,
+        `          tableName: ${getServiceName(modelName)},`,
+        `          options: options as GetEntityMetadataOptions,`,
+        `        },`,
+        `      },`,
+        `    });`,
+        `  }`,
+    ];
+}
+/**
+ * The generateIndexFile method creates an index.ts file that exports all models and services.
+ */
+async function generateIndexFile(outputDir, vfs) {
+    const indexPath = vfs.join(outputDir, GENERATED_FOLDER, 'index.ts');
+    const lines = [];
+    // Add copyright notice
+    addCopyrightNotice(lines);
+    // Export all models from generated/models
+    const modelsDir = vfs.join(outputDir, MODELS_FOLDER);
+    if (await vfs.exists(modelsDir)) {
+        const modelFiles = (await vfs.readdir(modelsDir)).filter((file) => file.endsWith('.ts'));
+        if (modelFiles.length > 0) {
+            lines.push('// Models');
+            for (const file of modelFiles) {
+                const fileName = file.replace('.ts', '');
+                lines.push(`export * as ${fileName} from './models/${fileName}';`);
             }
+            lines.push('');
         }
-        // Write the index file
-        await this.writeToFile(indexPath, lines, vfs);
     }
-    /**
-     * Clears and regenerates the model and service files.
-     * @param {string} schemaFolderPath
-     * @param {string} outputDir
-     */
-    static async clearAndRegenerate(schemaFolderPath, outputDir, vfs, logger) {
-        const modelsDir = vfs.join(outputDir, _a.MODELS_FOLDER);
-        const servicesDir = vfs.join(outputDir, _a.SERVICES_FOLDER);
-        // Delete Models directory if it exists
-        if (await vfs.exists(modelsDir)) {
-            await vfs.rmdir(modelsDir);
-        }
-        // Delete Services directory if it exists
-        if (await vfs.exists(servicesDir)) {
-            await vfs.rmdir(servicesDir);
+    // Export all services from generated/services
+    const servicesDir = vfs.join(outputDir, SERVICES_FOLDER);
+    if (await vfs.exists(servicesDir)) {
+        const serviceFiles = (await vfs.readdir(servicesDir)).filter((file) => file.endsWith('.ts'));
+        if (serviceFiles.length > 0) {
+            lines.push('// Services');
+            for (const file of serviceFiles) {
+                const fileName = file.replace('.ts', '');
+                lines.push(`export * from './services/${fileName}';`);
+            }
+            lines.push('');
         }
-        await _a.run([schemaFolderPath, outputDir], logger);
     }
+    // Write the index file
+    await writeToFile(indexPath, lines, vfs);
 }
-_a = ModelServiceGenerator;
-// Configuration constants for output folders
-ModelServiceGenerator.GENERATED_FOLDER = 'generated';
-ModelServiceGenerator.MODELS_FOLDER = `${_a.GENERATED_FOLDER}/models`;
-ModelServiceGenerator.SERVICES_FOLDER = `${_a.GENERATED_FOLDER}/services`;
-ModelServiceGenerator.RELATIVE_MODEL_PATH = '../models';
 /**
  * Check if the propertyNode is a sharepoint choice or multi select choice
  *
@@ -2442,14 +2464,14 @@ ModelServiceGenerator.RELATIVE_MODEL_PATH = '../models';
  * @returns {boolean}
  */
 function isSharepointChoiceColumn(propNode) {
-    var _b;
+    var _a;
     try {
         if (!propNode || typeof propNode !== 'object' || Array.isArray(propNode)) {
             return false;
         }
         else if ((propNode === null || propNode === void 0 ? void 0 : propNode['x-ms-capabilities']) !== undefined) {
             const capabilities = propNode['x-ms-capabilities'];
-            if (((_b = capabilities === null || capabilities === void 0 ? void 0 : capabilities['x-ms-sp']) === null || _b === void 0 ? void 0 : _b.IsChoice) === true) {
+            if (((_a = capabilities === null || capabilities === void 0 ? void 0 : capabilities['x-ms-sp']) === null || _a === void 0 ? void 0 : _a.IsChoice) === true) {
                 return true;
             }
         }