@simpleapps-com/augur-api 0.3.3 → 0.4.1

package/dist/cjs/services/p21-apis/client.js

@@ -2,19 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.P21ApisClient = void 0;
 const base_client_1 = require("../../core/base-client");
-// Create flexible response schemas using the STANDARD 8-field response format
-// All APIs must use this format - no response validation per OpenAPI spec requirements
-// Note: Specific response schemas are used for type safety
 const schemas_1 = require("./schemas");
 /**
- * P21 APIs Client
- * @description Client for interacting with P21 transactional API endpoints for entity data refresh and CRUD operations on categories, companies, purchase order receipts, users, and web display types within the Prophet 21 ERP system
+ * P21 APIs Client - OpenAPI Path Mirroring Implementation
+ * @description Client for interacting with P21 transactional API endpoints for entity data refresh and CRUD operations on categories, companies, purchase order receipts, users, and web display types within the Prophet 21 ERP system. Follows strict OpenAPI path mirroring pattern.
+ *
  * @fullPath api.p21Apis
  * @service p21-apis
  * @domain transactional-erp-operations
  * @discoverable true
  * @searchTerms ["p21-apis", "prophet 21", "ERP", "transactional operations", "entity refresh", "categories", "companies", "users", "web display types", "purchase orders", "data synchronization"]
- * @relatedEndpoints ["api.p21Apis.entityContacts", "api.p21Apis.entityCustomers", "api.p21Apis.transCategory", "api.p21Apis.transCompany", "api.p21Apis.transUser", "api.p21Apis.transWebDisplayType", "api.p21Apis.transPurchaseOrderReceipt"]
+ * @relatedEndpoints ["api.p21Core.company.list", "api.orders.poHdr.list", "api.items.categories.list", "api.customers.customer.list"]
  * @commonPatterns ["ERP data synchronization", "Entity refresh operations", "Transaction CRUD operations", "Category management", "Company data operations", "User management", "Web display configuration"]
  * @workflow ["erp-transactions", "data-refresh", "entity-management", "category-operations", "company-management", "user-administration", "web-display-setup"]
  * @prerequisites ["Valid P21 system access", "ERP authentication", "Site ID configuration", "Transactional operation permissions"]
@@ -23,34 +21,29 @@ const schemas_1 = require("./schemas");
  * @functionalArea "transactional-erp-operations"
  * @caching "Real-time operations - no caching for transactional endpoints, cache health check for 5 minutes"
  * @performance "Supports transactional operations with P21 ERP backend, optimized for individual entity operations"
+ *
  * @example
  * ```typescript
- * import { HTTPClient } from '@augur/api-client/core';
- * import { P21ApisClient } from '@augur/api-client/services/p21-apis';
+ * const api = new AugurAPI({ bearerToken: 'token', siteId: 'site' });
  *
- * const client = new P21ApisClient(new HTTPClient({ baseURL: 'https://p21-apis.augur-api.com' }));
+ * // OpenAPI Path Mirroring Examples:
+ * // /entity-contacts/refresh → api.p21Apis.entityContacts.refresh.get()
+ * const contactsRefresh = await api.p21Apis.entityContacts.refresh.get();
  *
- * // Refresh entity data
- * const contactsRefresh = await client.entityContacts.refresh({ 'x-site-id': 'SITE123' });
- * console.log(contactsRefresh.data); // Refresh result
+ * // /health-check → api.p21Apis.healthCheck.get()
+ * const health = await api.p21Apis.healthCheck.get();
  *
- * // Create new category
- * const newCategory = await client.transCategory.create({ 'x-site-id': 'SITE123' });
- * console.log(newCategory.data); // Category creation result
+ * // /trans-category → api.p21Apis.transCategory.create()
+ * const newCategory = await api.p21Apis.transCategory.create();
  *
- * // Get category details
- * const category = await client.transCategory.get({ categoryUid: 123, 'x-site-id': 'SITE123' });
- * console.log(category.data); // Category details
+ * // /trans-category/{categoryUid} → api.p21Apis.transCategory.get(categoryUid)
+ * const category = await api.p21Apis.transCategory.get(123);
  *
- * // Update company information
- * const updatedCompany = await client.transCompany.update({ companyUid: 456, 'x-site-id': 'SITE123' });
+ * // /trans-web-display-type/defaults → api.p21Apis.transWebDisplayType.defaults.get()
+ * const defaults = await api.p21Apis.transWebDisplayType.defaults.get();
  * ```
  */
 class P21ApisClient extends base_client_1.BaseServiceClient {
-    // Ensure schemas are referenced to avoid unused import warnings
-    get schemaRefs() {
-        return this._schemaRefs;
-    }
     /**
      * Create a new P21ApisClient instance
      * @param http Configured HTTPClient instance with authentication
@@ -58,195 +51,142 @@ class P21ApisClient extends base_client_1.BaseServiceClient {
      */
     constructor(http, baseUrl = 'https://p21-apis.augur-api.com') {
         super('p21-apis', http, baseUrl);
-        // Schema references for 100% coverage - ensuring all exports are imported
-        this._schemaRefs = {
-            EntityContactsRefreshParamsSchema: schemas_1.EntityContactsRefreshParamsSchema,
-            EntityCustomersRefreshParamsSchema: schemas_1.EntityCustomersRefreshParamsSchema,
-            HealthCheckParamsSchema: schemas_1.HealthCheckParamsSchema,
-            TransCategoryParamsSchema: schemas_1.TransCategoryParamsSchema,
-            TransCategoryCreateParamsSchema: schemas_1.TransCategoryCreateParamsSchema,
-            TransCompanyParamsSchema: schemas_1.TransCompanyParamsSchema,
-            TransCompanyCreateParamsSchema: schemas_1.TransCompanyCreateParamsSchema,
-            TransPurchaseOrderReceiptParamsSchema: schemas_1.TransPurchaseOrderReceiptParamsSchema,
-            TransUserParamsSchema: schemas_1.TransUserParamsSchema,
-            TransUserCreateParamsSchema: schemas_1.TransUserCreateParamsSchema,
-            TransWebDisplayTypeParamsSchema: schemas_1.TransWebDisplayTypeParamsSchema,
-            TransWebDisplayTypeCreateParamsSchema: schemas_1.TransWebDisplayTypeCreateParamsSchema,
-            TransWebDisplayTypeDefaultsParamsSchema: schemas_1.TransWebDisplayTypeDefaultsParamsSchema,
-            TransWebDisplayTypeDefinitionParamsSchema: schemas_1.TransWebDisplayTypeDefinitionParamsSchema,
-        };
         /**
-         * Entity contacts refresh operations for data synchronization
-         * @fullPath api.p21Apis.entityContacts
-         * @service p21-apis
-         * @domain entity-data-management
-         * @discoverable true
+         * Entity Contacts Operations - OpenAPI Path: /entity-contacts
+         * @description Entity contacts data refresh and synchronization following OpenAPI path mirroring pattern
          */
         this.entityContacts = {
             /**
-             * Trigger entity contacts data refresh for synchronization
-             *
-             * @fullPath api.p21Apis.entityContacts.refresh
-             * @service p21-apis
-             * @domain entity-data-management
-             * @dataMethod refreshData - returns only the refresh result without metadata
-             * @discoverable true
-             * @searchTerms ["entity contacts", "data refresh", "synchronization", "contact sync", "entity sync"]
-             * @relatedEndpoints ["api.p21Apis.entityCustomers.refresh", "api.p21Apis.healthCheck", "api.p21Core.address.refresh"]
-             * @commonPatterns ["Refresh contact data", "Synchronize entity contacts", "Trigger data sync", "Update contact information"]
-             * @workflow ["data-synchronization", "entity-refresh", "contact-management", "erp-sync"]
-             * @prerequisites ["Valid site ID", "Data refresh permissions", "Entity access rights"]
-             * @nextSteps ["api.p21Core.address.list for contact addresses", "api.customers.customer.list for customer contacts"]
-             * @businessRules ["Site-scoped refresh operations", "Asynchronous data synchronization", "Background processing for large datasets"]
-             * @functionalArea "entity-data-management"
-             * @caching "No caching - real-time refresh operations"
-             * @performance "Asynchronous operation, returns immediately with status"
-             *
-             * @param params Site ID and refresh parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with refresh status and metadata
-             *
-             * @example
-             * ```typescript
-             * // Trigger entity contacts refresh
-             * const response = await client.entityContacts.refresh({ 'x-site-id': 'SITE123' });
-             * console.log(response.data); // Refresh operation result
-             *
-             * // Get just the data
-             * const refreshResult = await client.entityContacts.refreshData({ 'x-site-id': 'SITE123' });
-             * ```
+             * Entity contacts refresh operations - OpenAPI Path: /entity-contacts/refresh
              */
-            refresh: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/entity-contacts/refresh',
-                    paramsSchema: schemas_1.EntityContactsRefreshParamsSchema,
-                    responseSchema: schemas_1.EntityContactsRefreshResponseSchema,
-                }, params);
-            },
-            // Data method for entity contacts operations
-            refreshData: async (params) => {
-                const response = await this.entityContacts.refresh(params);
-                return response.data;
+            refresh: {
+                /**
+                 * Trigger entity contacts data refresh for synchronization
+                 * @description Initiates a data refresh operation for entity contacts to synchronize with the P21 ERP system. Returns status of the refresh operation for monitoring and verification.
+                 *
+                 * @fullPath api.p21Apis.entityContacts.refresh.get
+                 * @service p21-apis
+                 * @domain entity-data-management
+                 * @dataMethod getData - returns only the refresh result without metadata
+                 * @discoverable true
+                 * @searchTerms ["entity contacts", "data refresh", "synchronization", "contact sync", "entity sync"]
+                 * @relatedEndpoints ["api.p21Apis.entityCustomers.refresh.get", "api.p21Apis.healthCheck.get", "api.p21Core.address.list"]
+                 * @commonPatterns ["Refresh contact data", "Synchronize entity contacts", "Trigger data sync", "Update contact information"]
+                 * @workflow ["data-synchronization", "entity-refresh", "contact-management", "erp-sync"]
+                 * @prerequisites ["Valid site ID", "Data refresh permissions", "Entity access rights"]
+                 * @nextSteps ["api.p21Core.address.list for contact addresses", "api.customers.customer.list for customer contacts"]
+                 * @businessRules ["Site-scoped refresh operations", "Asynchronous data synchronization", "Background processing for large datasets"]
+                 * @functionalArea "entity-data-management"
+                 * @performance "Asynchronous operation, returns immediately with status"
+                 */
+                get: async (params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/entity-contacts/refresh',
+                        paramsSchema: schemas_1.EntityContactsRefreshParamsSchema,
+                        responseSchema: schemas_1.EntityContactsRefreshResponseSchema,
+                    }, params || {});
+                },
+                /**
+                 * Get only entity contacts refresh data without response metadata
+                 * @param params Site ID and refresh parameters
+                 * @returns Promise<EntityRefreshData> Direct refresh result object
+                 */
+                getData: async (params) => {
+                    const response = await this.entityContacts.refresh.get(params);
+                    return response.data;
+                },
             },
         };
         /**
-         * Entity customers refresh operations for data synchronization
-         * @fullPath api.p21Apis.entityCustomers
-         * @service p21-apis
-         * @domain entity-data-management
-         * @discoverable true
+         * Entity Customers Operations - OpenAPI Path: /entity-customers
+         * @description Entity customers data refresh and synchronization following OpenAPI path mirroring pattern
          */
         this.entityCustomers = {
             /**
-             * Trigger entity customers data refresh for synchronization
-             *
-             * @fullPath api.p21Apis.entityCustomers.refresh
-             * @service p21-apis
-             * @domain entity-data-management
-             * @dataMethod refreshData - returns only the refresh result without metadata
-             * @discoverable true
-             * @searchTerms ["entity customers", "data refresh", "synchronization", "customer sync", "entity sync"]
-             * @relatedEndpoints ["api.p21Apis.entityContacts.refresh", "api.p21Apis.healthCheck", "api.customers.customer.refresh"]
-             * @commonPatterns ["Refresh customer data", "Synchronize entity customers", "Trigger data sync", "Update customer information"]
-             * @workflow ["data-synchronization", "entity-refresh", "customer-management", "erp-sync"]
-             * @prerequisites ["Valid site ID", "Data refresh permissions", "Entity access rights"]
-             * @nextSteps ["api.customers.customer.list for customer details", "api.p21Core.company.list for company customers"]
-             * @businessRules ["Site-scoped refresh operations", "Asynchronous data synchronization", "Background processing for large datasets"]
-             * @functionalArea "entity-data-management"
-             * @caching "No caching - real-time refresh operations"
-             * @performance "Asynchronous operation, returns immediately with status"
-             *
-             * @param params Site ID and refresh parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with refresh status and metadata
-             *
-             * @example
-             * ```typescript
-             * // Trigger entity customers refresh
-             * const response = await client.entityCustomers.refresh({ 'x-site-id': 'SITE123' });
-             * console.log(response.data); // Refresh operation result
-             *
-             * // Get just the data
-             * const refreshResult = await client.entityCustomers.refreshData({ 'x-site-id': 'SITE123' });
-             * ```
+             * Entity customers refresh operations - OpenAPI Path: /entity-customers/refresh
              */
-            refresh: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/entity-customers/refresh',
-                    paramsSchema: schemas_1.EntityCustomersRefreshParamsSchema,
-                    responseSchema: schemas_1.EntityCustomersRefreshResponseSchema,
-                }, params);
-            },
-            // Data method for entity customers operations
-            refreshData: async (params) => {
-                const response = await this.entityCustomers.refresh(params);
-                return response.data;
+            refresh: {
+                /**
+                 * Trigger entity customers data refresh for synchronization
+                 * @description Initiates a data refresh operation for entity customers to synchronize with the P21 ERP system. Returns status of the refresh operation for monitoring and verification.
+                 *
+                 * @fullPath api.p21Apis.entityCustomers.refresh.get
+                 * @service p21-apis
+                 * @domain entity-data-management
+                 * @dataMethod getData - returns only the refresh result without metadata
+                 * @discoverable true
+                 * @searchTerms ["entity customers", "data refresh", "synchronization", "customer sync", "entity sync"]
+                 * @relatedEndpoints ["api.p21Apis.entityContacts.refresh.get", "api.p21Apis.healthCheck.get", "api.customers.customer.list"]
+                 * @commonPatterns ["Refresh customer data", "Synchronize entity customers", "Trigger data sync", "Update customer information"]
+                 * @workflow ["data-synchronization", "entity-refresh", "customer-management", "erp-sync"]
+                 * @prerequisites ["Valid site ID", "Data refresh permissions", "Entity access rights"]
+                 * @nextSteps ["api.customers.customer.list for customer details", "api.p21Core.company.list for company customers"]
+                 * @businessRules ["Site-scoped refresh operations", "Asynchronous data synchronization", "Background processing for large datasets"]
+                 * @functionalArea "entity-data-management"
+                 * @performance "Asynchronous operation, returns immediately with status"
+                 */
+                get: async (params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/entity-customers/refresh',
+                        paramsSchema: schemas_1.EntityCustomersRefreshParamsSchema,
+                        responseSchema: schemas_1.EntityCustomersRefreshResponseSchema,
+                    }, params || {});
+                },
+                /**
+                 * Get only entity customers refresh data without response metadata
+                 * @param params Site ID and refresh parameters
+                 * @returns Promise<EntityRefreshData> Direct refresh result object
+                 */
+                getData: async (params) => {
+                    const response = await this.entityCustomers.refresh.get(params);
+                    return response.data;
+                },
             },
         };
         /**
-         * Health check operations for service monitoring and system status verification
-         * @fullPath api.p21Apis.health
-         * @service p21-apis
-         * @domain system-monitoring
-         * @discoverable true
+         * Health Check Operations - OpenAPI Path: /health-check
+         * @description Service health monitoring and status verification following OpenAPI path mirroring pattern
          */
-        this.health = {
+        this.healthCheck = {
             /**
              * Perform health check to verify P21 APIs service status and connectivity
+             * @description Returns service health status and configuration information for monitoring and diagnostics. Essential for verifying P21 system connectivity and service availability.
              *
-             * @fullPath api.p21Apis.health.check
+             * @fullPath api.p21Apis.healthCheck.get
              * @service p21-apis
              * @domain system-monitoring
-             * @dataMethod checkData - returns only the health status without metadata
+             * @dataMethod getData - returns only the health status without metadata
              * @discoverable true
              * @searchTerms ["health check", "service status", "system monitor", "service availability", "connectivity test"]
-             * @relatedEndpoints ["api.p21Core.health.check", "system monitoring endpoints"]
+             * @relatedEndpoints ["api.p21Core.healthCheck.get", "system monitoring endpoints"]
              * @commonPatterns ["Check service health", "Monitor system status", "Verify connectivity", "Service diagnostics"]
              * @workflow ["system-monitoring", "health-verification", "service-diagnostics"]
              * @prerequisites ["Site ID configuration", "System access"]
              * @nextSteps ["Service remediation if unhealthy", "Integration health checks"]
              * @businessRules ["Returns service configuration", "Site-specific health status", "Authentication verification"]
              * @functionalArea "system-monitoring"
-             * @caching "Cache for 5 minutes for health status"
              * @performance "Lightweight check, immediate response"
-             *
-             * @param params Site ID for health check
-             * @returns Promise<BaseResponse<unknown>> Service health status and configuration
-             *
-             * @example
-             * ```typescript
-             * // Check service health
-             * const response = await client.health.check({ 'x-site-id': 'SITE123' });
-             * console.log(response.data); // Health status information
-             *
-             * // Get just the data
-             * const healthStatus = await client.health.checkData({ 'x-site-id': 'SITE123' });
-             * ```
              */
-            check: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/health-check',
-                    paramsSchema: schemas_1.HealthCheckParamsSchema,
-                    responseSchema: schemas_1.HealthCheckResponseSchema,
-                }, params);
-            },
-            // Data method for health operations
-            checkData: async (params) => {
-                const response = await this.health.check(params);
+            get: this.createHealthCheckMethod(schemas_1.HealthCheckResponseSchema),
+            /**
+             * Get only health check data without response metadata
+             * @returns Promise<HealthCheckData> Direct health status object
+             */
+            getData: async () => {
+                const response = await this.healthCheck.get();
                 return response.data;
             },
         };
         /**
-         * Transaction category operations for category management and CRUD operations
-         * @fullPath api.p21Apis.transCategory
-         * @service p21-apis
-         * @domain category-management
-         * @discoverable true
+         * Transaction Category Operations - OpenAPI Path: /trans-category
+         * @description Category management and CRUD operations following OpenAPI path mirroring pattern
          */
         this.transCategory = {
             /**
-             * Create new transaction category
+             * Create new transaction category - OpenAPI Path: /trans-category
+             * @description Creates a new category within the P21 transactional system. Returns the created category details for verification and further operations.
              *
              * @fullPath api.p21Apis.transCategory.create
              * @service p21-apis
@@ -262,20 +202,11 @@ class P21ApisClient extends base_client_1.BaseServiceClient {
              * @businessRules ["Site-scoped category creation", "Unique category constraints", "Category hierarchy support"]
              * @functionalArea "category-management"
              * @performance "Real-time category creation with immediate availability"
-             *
-             * @param params Site ID for category creation
-             * @returns Promise<BaseResponse<unknown>> Complete response with created category details
              */
-            create: async (params) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/trans-category',
-                    paramsSchema: schemas_1.TransCategoryCreateParamsSchema,
-                    responseSchema: schemas_1.TransCategoryResponseSchema,
-                }, params);
-            },
+            create: this.createCreateMethod('/trans-category', schemas_1.TransCategoryCreateParamsSchema, schemas_1.TransCategoryResponseSchema),
             /**
-             * Get transaction category details by category UID
+             * Get transaction category details by category UID - OpenAPI Path: /trans-category/{categoryUid}
+             * @description Retrieves comprehensive category details including metadata, relationships, and configuration. Used for category management and verification workflows.
              *
              * @fullPath api.p21Apis.transCategory.get
              * @service p21-apis
@@ -291,20 +222,18 @@ class P21ApisClient extends base_client_1.BaseServiceClient {
              * @businessRules ["Category UID must exist", "Site-scoped access", "Optional category ID validation"]
              * @functionalArea "category-management"
              * @performance "Direct lookup by UID, very fast response"
-             *
-             * @param params Category UID and site ID parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with category details
              */
-            get: async (params) => {
+            get: async (categoryUid, params) => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/trans-category/{categoryUid}',
+                    path: `/trans-category/${categoryUid}`,
                     paramsSchema: schemas_1.TransCategoryParamsSchema,
                     responseSchema: schemas_1.TransCategoryResponseSchema,
-                }, params, { categoryUid: params.categoryUid });
+                }, { categoryUid, ...params });
             },
             /**
-             * Update transaction category by category UID
+             * Update transaction category by category UID - OpenAPI Path: /trans-category/{categoryUid}
+             * @description Updates existing category information including metadata and relationships. Returns updated category details for verification.
              *
              * @fullPath api.p21Apis.transCategory.update
              * @service p21-apis
@@ -320,20 +249,18 @@ class P21ApisClient extends base_client_1.BaseServiceClient {
              * @businessRules ["Category UID must exist", "Site-scoped modifications", "Data validation requirements"]
              * @functionalArea "category-management"
              * @performance "Real-time category updates with immediate effect"
-             *
-             * @param params Category UID and site ID parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with updated category details
              */
-            update: async (params) => {
+            update: async (categoryUid, params) => {
                 return this.executeRequest({
                     method: 'PUT',
-                    path: '/trans-category/{categoryUid}',
+                    path: `/trans-category/${categoryUid}`,
                     paramsSchema: schemas_1.TransCategoryParamsSchema,
                     responseSchema: schemas_1.TransCategoryResponseSchema,
-                }, params, { categoryUid: params.categoryUid });
+                }, { categoryUid, ...params });
             },
             /**
-             * Delete transaction category by category UID
+             * Delete transaction category by category UID - OpenAPI Path: /trans-category/{categoryUid}
+             * @description Removes category from the P21 transactional system. Returns deletion confirmation and handles cascade operations.
              *
              * @fullPath api.p21Apis.transCategory.delete
              * @service p21-apis
@@ -349,46 +276,41 @@ class P21ApisClient extends base_client_1.BaseServiceClient {
              * @businessRules ["Category UID must exist", "Cascade deletion rules", "Related entity validation"]
              * @functionalArea "category-management"
              * @performance "Real-time category deletion with immediate effect"
-             *
-             * @param params Category UID and site ID parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with deletion confirmation
              */
-            delete: async (params) => {
+            delete: async (categoryUid, params) => {
                 return this.executeRequest({
                     method: 'DELETE',
-                    path: '/trans-category/{categoryUid}',
+                    path: `/trans-category/${categoryUid}`,
                     paramsSchema: schemas_1.TransCategoryParamsSchema,
                     responseSchema: schemas_1.TransCategoryResponseSchema,
-                }, params, { categoryUid: params.categoryUid });
+                }, { categoryUid, ...params });
             },
             // Data methods for transaction category operations
             createData: async (params) => {
-                const response = await this.transCategory.create(params);
+                const response = await this.transCategory.create(params || {});
                 return response.data;
             },
-            getData: async (params) => {
-                const response = await this.transCategory.get(params);
+            getData: async (categoryUid, params) => {
+                const response = await this.transCategory.get(categoryUid, params);
                 return response.data;
             },
-            updateData: async (params) => {
-                const response = await this.transCategory.update(params);
+            updateData: async (categoryUid, params) => {
+                const response = await this.transCategory.update(categoryUid, params);
                 return response.data;
             },
-            deleteData: async (params) => {
-                const response = await this.transCategory.delete(params);
+            deleteData: async (categoryUid, params) => {
+                const response = await this.transCategory.delete(categoryUid, params);
                 return response.data;
             },
         };
         /**
-         * Transaction company operations for company management and CRUD operations
-         * @fullPath api.p21Apis.transCompany
-         * @service p21-apis
-         * @domain company-management
-         * @discoverable true
+         * Transaction Company Operations - OpenAPI Path: /trans-company
+         * @description Company management and CRUD operations following OpenAPI path mirroring pattern
          */
         this.transCompany = {
             /**
-             * Create new transaction company
+             * Create new transaction company - OpenAPI Path: /trans-company
+             * @description Creates a new company entity within the P21 transactional system. Returns the created company details for verification and further operations.
              *
              * @fullPath api.p21Apis.transCompany.create
              * @service p21-apis
@@ -404,553 +326,298 @@ class P21ApisClient extends base_client_1.BaseServiceClient {
              * @businessRules ["Site-scoped company creation", "Unique company constraints", "Corporate hierarchy support"]
              * @functionalArea "company-management"
              * @performance "Real-time company creation with immediate availability"
-             *
-             * @param params Site ID for company creation
-             * @returns Promise<BaseResponse<unknown>> Complete response with created company details
              */
-            create: async (params) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/trans-company',
-                    paramsSchema: schemas_1.TransCompanyCreateParamsSchema,
-                    responseSchema: schemas_1.TransCompanyResponseSchema,
-                }, params);
-            },
+            create: this.createCreateMethod('/trans-company', schemas_1.TransCompanyCreateParamsSchema, schemas_1.TransCompanyResponseSchema),
             /**
-             * Get transaction company details by company UID
-             *
-             * @fullPath api.p21Apis.transCompany.get
-             * @service p21-apis
-             * @domain company-management
-             * @dataMethod getData - returns only the company object without metadata
-             * @discoverable true
-             * @searchTerms ["company details", "get company", "company info", "company lookup"]
-             * @relatedEndpoints ["api.p21Apis.transCompany.update", "api.p21Apis.transCompany.delete", "api.p21Core.company.get"]
-             * @commonPatterns ["Get company details", "View company information", "Company lookup", "Company verification"]
-             * @workflow ["company-details", "business-management", "corporate-lookup", "entity-browsing"]
-             * @prerequisites ["Valid company UID", "Site ID", "Company access permissions"]
-             * @nextSteps ["api.p21Apis.transCompany.update for modifications", "api.p21Core.company for extended operations"]
-             * @businessRules ["Company UID must exist", "Site-scoped access", "Optional company ID validation"]
-             * @functionalArea "company-management"
-             * @performance "Direct lookup by UID, very fast response"
-             *
-             * @param params Company UID and site ID parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with company details
+             * Get transaction company details by company UID - OpenAPI Path: /trans-company/{companyUid}
              */
-            get: async (params) => {
+            get: async (companyUid, params) => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/trans-company/{companyUid}',
+                    path: `/trans-company/${companyUid}`,
                     paramsSchema: schemas_1.TransCompanyParamsSchema,
                     responseSchema: schemas_1.TransCompanyResponseSchema,
-                }, params, { companyUid: params.companyUid });
+                }, { companyUid, ...params });
             },
             /**
-             * Update transaction company by company UID
-             *
-             * @fullPath api.p21Apis.transCompany.update
-             * @service p21-apis
-             * @domain company-management
-             * @dataMethod updateData - returns only the updated company without metadata
-             * @discoverable true
-             * @searchTerms ["update company", "modify company", "company update", "edit company"]
-             * @relatedEndpoints ["api.p21Apis.transCompany.get", "api.p21Apis.transCompany.delete", "api.p21Core.company.update"]
-             * @commonPatterns ["Update company information", "Modify company details", "Company maintenance", "Company editing"]
-             * @workflow ["company-management", "business-management", "corporate-maintenance", "entity-updates"]
-             * @prerequisites ["Valid company UID", "Site ID", "Company modification permissions"]
-             * @nextSteps ["api.p21Apis.transCompany.get for verification", "api.p21Core.company for related updates"]
-             * @businessRules ["Company UID must exist", "Site-scoped modifications", "Data validation requirements"]
-             * @functionalArea "company-management"
-             * @performance "Real-time company updates with immediate effect"
-             *
-             * @param params Company UID and site ID parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with updated company details
+             * Update transaction company by company UID - OpenAPI Path: /trans-company/{companyUid}
              */
-            update: async (params) => {
+            update: async (companyUid, params) => {
                 return this.executeRequest({
                     method: 'PUT',
-                    path: '/trans-company/{companyUid}',
+                    path: `/trans-company/${companyUid}`,
                     paramsSchema: schemas_1.TransCompanyParamsSchema,
                     responseSchema: schemas_1.TransCompanyResponseSchema,
-                }, params, { companyUid: params.companyUid });
+                }, { companyUid, ...params });
             },
             /**
-             * Delete transaction company by company UID
-             *
-             * @fullPath api.p21Apis.transCompany.delete
-             * @service p21-apis
-             * @domain company-management
-             * @dataMethod deleteData - returns only the deletion result without metadata
-             * @discoverable true
-             * @searchTerms ["delete company", "remove company", "company deletion", "company removal"]
-             * @relatedEndpoints ["api.p21Apis.transCompany.create", "api.p21Apis.transCompany.get", "api.p21Core.company.delete"]
-             * @commonPatterns ["Delete company", "Remove company from system", "Company cleanup", "Company removal"]
-             * @workflow ["company-management", "system-cleanup", "corporate-maintenance", "entity-management"]
-             * @prerequisites ["Valid company UID", "Site ID", "Company deletion permissions"]
-             * @nextSteps ["api.p21Core.company.list to verify removal", "related entity reassignment if needed"]
-             * @businessRules ["Company UID must exist", "Cascade deletion rules", "Related entity validation"]
-             * @functionalArea "company-management"
-             * @performance "Real-time company deletion with immediate effect"
-             *
-             * @param params Company UID and site ID parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with deletion confirmation
+             * Delete transaction company by company UID - OpenAPI Path: /trans-company/{companyUid}
              */
-            delete: async (params) => {
+            delete: async (companyUid, params) => {
                 return this.executeRequest({
                     method: 'DELETE',
-                    path: '/trans-company/{companyUid}',
+                    path: `/trans-company/${companyUid}`,
                     paramsSchema: schemas_1.TransCompanyParamsSchema,
                     responseSchema: schemas_1.TransCompanyResponseSchema,
-                }, params, { companyUid: params.companyUid });
+                }, { companyUid, ...params });
             },
-            // Data methods for transaction company operations
+            // Data methods
             createData: async (params) => {
-                const response = await this.transCompany.create(params);
+                const response = await this.transCompany.create(params || {});
                 return response.data;
             },
-            getData: async (params) => {
-                const response = await this.transCompany.get(params);
+            getData: async (companyUid, params) => {
+                const response = await this.transCompany.get(companyUid, params);
                 return response.data;
             },
-            updateData: async (params) => {
-                const response = await this.transCompany.update(params);
+            updateData: async (companyUid, params) => {
+                const response = await this.transCompany.update(companyUid, params);
                 return response.data;
             },
-            deleteData: async (params) => {
-                const response = await this.transCompany.delete(params);
+            deleteData: async (companyUid, params) => {
+                const response = await this.transCompany.delete(companyUid, params);
                 return response.data;
             },
         };
         /**
-         * Transaction purchase order receipt operations for purchase order management
-         * @fullPath api.p21Apis.transPurchaseOrderReceipt
-         * @service p21-apis
-         * @domain purchase-order-management
-         * @discoverable true
+         * Transaction Purchase Order Receipt Operations - OpenAPI Path: /trans-purchase-order-receipt
+         * @description Purchase order receipt management following OpenAPI path mirroring pattern
          */
         this.transPurchaseOrderReceipt = {
             /**
-             * Get purchase order receipt details by PO number
-             *
-             * @fullPath api.p21Apis.transPurchaseOrderReceipt.get
-             * @service p21-apis
-             * @domain purchase-order-management
-             * @dataMethod getData - returns only the purchase order receipt object without metadata
-             * @discoverable true
-             * @searchTerms ["purchase order receipt", "PO receipt", "purchase order", "receipt details", "PO details"]
-             * @relatedEndpoints ["api.p21Apis.transPurchaseOrderReceipt.update", "api.orders.purchaseOrders.list", "api.items.invMast.list"]
-             * @commonPatterns ["Get PO receipt details", "View purchase order receipt", "Receipt lookup", "PO verification"]
-             * @workflow ["purchase-order-processing", "receipt-management", "inventory-receiving", "procurement-operations"]
-             * @prerequisites ["Valid PO number", "Site ID", "Purchase order access permissions"]
-             * @nextSteps ["api.p21Apis.transPurchaseOrderReceipt.update for modifications", "api.orders.purchaseOrders for related operations"]
-             * @businessRules ["PO number must exist", "Site-scoped access", "Receipt status validation"]
-             * @functionalArea "purchase-order-management"
-             * @performance "Direct lookup by PO number, includes receipt details"
-             *
-             * @param params PO number and site ID parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with purchase order receipt details
+             * Get purchase order receipt details by PO number - OpenAPI Path: /trans-purchase-order-receipt/{poNo}
              */
-            get: async (params) => {
+            get: async (poNo) => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/trans-purchase-order-receipt/{poNo}',
+                    path: `/trans-purchase-order-receipt/${poNo}`,
                     paramsSchema: schemas_1.TransPurchaseOrderReceiptParamsSchema,
                     responseSchema: schemas_1.TransPurchaseOrderReceiptResponseSchema,
-                }, params, { poNo: params.poNo });
+                }, { poNo });
             },
             /**
-             * Update purchase order receipt by PO number
-             *
-             * @fullPath api.p21Apis.transPurchaseOrderReceipt.update
-             * @service p21-apis
-             * @domain purchase-order-management
-             * @dataMethod updateData - returns only the updated purchase order receipt without metadata
-             * @discoverable true
-             * @searchTerms ["update PO receipt", "modify purchase order receipt", "receipt update", "PO receipt update"]
-             * @relatedEndpoints ["api.p21Apis.transPurchaseOrderReceipt.get", "api.orders.purchaseOrders.update", "api.items.invMast.updateQuantity"]
-             * @commonPatterns ["Update receipt information", "Modify PO receipt", "Receipt maintenance", "PO processing"]
-             * @workflow ["purchase-order-processing", "receipt-management", "inventory-receiving", "procurement-updates"]
-             * @prerequisites ["Valid PO number", "Site ID", "Purchase order modification permissions"]
-             * @nextSteps ["api.p21Apis.transPurchaseOrderReceipt.get for verification", "api.orders.purchaseOrders for related updates"]
-             * @businessRules ["PO number must exist", "Site-scoped modifications", "Receipt status validation"]
-             * @functionalArea "purchase-order-management"
-             * @performance "Real-time PO receipt updates with immediate effect"
-             *
-             * @param params PO number and site ID parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with updated purchase order receipt details
+             * Update purchase order receipt by PO number - OpenAPI Path: /trans-purchase-order-receipt/{poNo}
              */
-            update: async (params) => {
+            update: async (poNo) => {
                 return this.executeRequest({
                     method: 'PUT',
-                    path: '/trans-purchase-order-receipt/{poNo}',
+                    path: `/trans-purchase-order-receipt/${poNo}`,
                     paramsSchema: schemas_1.TransPurchaseOrderReceiptParamsSchema,
                     responseSchema: schemas_1.TransPurchaseOrderReceiptResponseSchema,
-                }, params, { poNo: params.poNo });
+                }, { poNo });
             },
-            // Data methods for transaction purchase order receipt operations
-            getData: async (params) => {
-                const response = await this.transPurchaseOrderReceipt.get(params);
+            // Data methods
+            getData: async (poNo) => {
+                const response = await this.transPurchaseOrderReceipt.get(poNo);
                 return response.data;
             },
-            updateData: async (params) => {
-                const response = await this.transPurchaseOrderReceipt.update(params);
+            updateData: async (poNo) => {
+                const response = await this.transPurchaseOrderReceipt.update(poNo);
                 return response.data;
             },
         };
         /**
-         * Transaction user operations for user management and CRUD operations
-         * @fullPath api.p21Apis.transUser
-         * @service p21-apis
-         * @domain user-management
-         * @discoverable true
+         * Transaction User Operations - OpenAPI Path: /trans-user
+         * @description User management and CRUD operations following OpenAPI path mirroring pattern
          */
         this.transUser = {
             /**
-             * Create new transaction user
-             *
-             * @fullPath api.p21Apis.transUser.create
-             * @service p21-apis
-             * @domain user-management
-             * @dataMethod createData - returns only the created user without metadata
-             * @discoverable true
-             * @searchTerms ["create user", "new user", "user creation", "add user"]
-             * @relatedEndpoints ["api.p21Apis.transUser.get", "api.p21Apis.transUser.update", "api.users.user.list"]
-             * @commonPatterns ["Create new user", "Add user to system", "User setup", "User account creation"]
-             * @workflow ["user-setup", "account-management", "user-administration", "access-management"]
-             * @prerequisites ["Valid site ID", "User creation permissions", "Authentication"]
-             * @nextSteps ["api.p21Apis.transUser.get for verification", "api.users.user for user operations"]
-             * @businessRules ["Site-scoped user creation", "Unique user constraints", "User validation requirements"]
-             * @functionalArea "user-management"
-             * @performance "Real-time user creation with immediate availability"
-             *
-             * @param params Site ID for user creation
-             * @returns Promise<BaseResponse<unknown>> Complete response with created user details
+             * Create new transaction user - OpenAPI Path: /trans-user
              */
-            create: async (params) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/trans-user',
-                    paramsSchema: schemas_1.TransUserCreateParamsSchema,
-                    responseSchema: schemas_1.TransUserResponseSchema,
-                }, params);
-            },
+            create: this.createCreateMethod('/trans-user', schemas_1.TransUserCreateParamsSchema, schemas_1.TransUserResponseSchema),
             /**
-             * Get transaction user details by user UID
-             *
-             * @fullPath api.p21Apis.transUser.get
-             * @service p21-apis
-             * @domain user-management
-             * @dataMethod getData - returns only the user object without metadata
-             * @discoverable true
-             * @searchTerms ["user details", "get user", "user info", "user lookup"]
-             * @relatedEndpoints ["api.p21Apis.transUser.update", "api.p21Apis.transUser.delete", "api.users.user.get"]
-             * @commonPatterns ["Get user details", "View user information", "User lookup", "User verification"]
-             * @workflow ["user-details", "account-management", "user-lookup", "access-verification"]
-             * @prerequisites ["Valid user UID", "Site ID", "User access permissions"]
-             * @nextSteps ["api.p21Apis.transUser.update for modifications", "api.users.user for extended operations"]
-             * @businessRules ["User UID must exist", "Site-scoped access", "Optional user ID validation"]
-             * @functionalArea "user-management"
-             * @performance "Direct lookup by UID, very fast response"
-             *
-             * @param params User UID and site ID parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with user details
+             * Get transaction user details by user UID - OpenAPI Path: /trans-user/{usersUid}
              */
-            get: async (params) => {
+            get: async (usersUid, params) => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/trans-user/{usersUid}',
+                    path: `/trans-user/${usersUid}`,
                     paramsSchema: schemas_1.TransUserParamsSchema,
                     responseSchema: schemas_1.TransUserResponseSchema,
-                }, params, { usersUid: params.usersUid });
+                }, { usersUid, ...params });
             },
             /**
-             * Update transaction user by user UID
-             *
-             * @fullPath api.p21Apis.transUser.update
-             * @service p21-apis
-             * @domain user-management
-             * @dataMethod updateData - returns only the updated user without metadata
-             * @discoverable true
-             * @searchTerms ["update user", "modify user", "user update", "edit user"]
-             * @relatedEndpoints ["api.p21Apis.transUser.get", "api.p21Apis.transUser.delete", "api.users.user.update"]
-             * @commonPatterns ["Update user information", "Modify user details", "User maintenance", "User editing"]
-             * @workflow ["user-management", "account-management", "user-maintenance", "access-updates"]
-             * @prerequisites ["Valid user UID", "Site ID", "User modification permissions"]
-             * @nextSteps ["api.p21Apis.transUser.get for verification", "api.users.user for related updates"]
-             * @businessRules ["User UID must exist", "Site-scoped modifications", "Data validation requirements"]
-             * @functionalArea "user-management"
-             * @performance "Real-time user updates with immediate effect"
-             *
-             * @param params User UID and site ID parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with updated user details
+             * Update transaction user by user UID - OpenAPI Path: /trans-user/{usersUid}
              */
-            update: async (params) => {
+            update: async (usersUid, params) => {
                 return this.executeRequest({
                     method: 'PUT',
-                    path: '/trans-user/{usersUid}',
+                    path: `/trans-user/${usersUid}`,
                     paramsSchema: schemas_1.TransUserParamsSchema,
                     responseSchema: schemas_1.TransUserResponseSchema,
-                }, params, { usersUid: params.usersUid });
+                }, { usersUid, ...params });
             },
             /**
-             * Delete transaction user by user UID
-             *
-             * @fullPath api.p21Apis.transUser.delete
-             * @service p21-apis
-             * @domain user-management
-             * @dataMethod deleteData - returns only the deletion result without metadata
-             * @discoverable true
-             * @searchTerms ["delete user", "remove user", "user deletion", "user removal"]
-             * @relatedEndpoints ["api.p21Apis.transUser.create", "api.p21Apis.transUser.get", "api.users.user.delete"]
-             * @commonPatterns ["Delete user", "Remove user from system", "User cleanup", "User removal"]
-             * @workflow ["user-management", "system-cleanup", "account-maintenance", "access-management"]
-             * @prerequisites ["Valid user UID", "Site ID", "User deletion permissions"]
-             * @nextSteps ["api.users.user.list to verify removal", "related entity reassignment if needed"]
-             * @businessRules ["User UID must exist", "Cascade deletion rules", "Related entity validation"]
-             * @functionalArea "user-management"
-             * @performance "Real-time user deletion with immediate effect"
-             *
-             * @param params User UID and site ID parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with deletion confirmation
+             * Delete transaction user by user UID - OpenAPI Path: /trans-user/{usersUid}
              */
-            delete: async (params) => {
+            delete: async (usersUid, params) => {
                 return this.executeRequest({
                     method: 'DELETE',
-                    path: '/trans-user/{usersUid}',
+                    path: `/trans-user/${usersUid}`,
                     paramsSchema: schemas_1.TransUserParamsSchema,
                     responseSchema: schemas_1.TransUserResponseSchema,
-                }, params, { usersUid: params.usersUid });
+                }, { usersUid, ...params });
             },
-            // Data methods for transaction user operations
+            // Data methods
             createData: async (params) => {
-                const response = await this.transUser.create(params);
+                const response = await this.transUser.create(params || {});
                 return response.data;
             },
-            getData: async (params) => {
-                const response = await this.transUser.get(params);
+            getData: async (usersUid, params) => {
+                const response = await this.transUser.get(usersUid, params);
                 return response.data;
             },
-            updateData: async (params) => {
-                const response = await this.transUser.update(params);
+            updateData: async (usersUid, params) => {
+                const response = await this.transUser.update(usersUid, params);
                 return response.data;
             },
-            deleteData: async (params) => {
-                const response = await this.transUser.delete(params);
+            deleteData: async (usersUid, params) => {
+                const response = await this.transUser.delete(usersUid, params);
                 return response.data;
             },
         };
         /**
-         * Transaction web display type operations for web display management and CRUD operations
-         * @fullPath api.p21Apis.transWebDisplayType
-         * @service p21-apis
-         * @domain web-display-management
-         * @discoverable true
+         * Transaction Web Display Type Operations - OpenAPI Path: /trans-web-display-type
+         * @description Web display type management and CRUD operations following OpenAPI path mirroring pattern
          */
         this.transWebDisplayType = {
             /**
-             * Create new transaction web display type
-             *
-             * @fullPath api.p21Apis.transWebDisplayType.create
-             * @service p21-apis
-             * @domain web-display-management
-             * @dataMethod createData - returns only the created web display type without metadata
-             * @discoverable true
-             * @searchTerms ["create web display type", "new web display", "display type creation", "add display type"]
-             * @relatedEndpoints ["api.p21Apis.transWebDisplayType.get", "api.p21Apis.transWebDisplayType.update", "api.commerce.webDisplay.list"]
-             * @commonPatterns ["Create new web display type", "Add display type to system", "Display setup", "Web configuration"]
-             * @workflow ["web-display-setup", "ui-configuration", "display-management", "web-customization"]
-             * @prerequisites ["Valid site ID", "Display type creation permissions", "Authentication"]
-             * @nextSteps ["api.p21Apis.transWebDisplayType.get for verification", "api.commerce.webDisplay for display operations"]
-             * @businessRules ["Site-scoped display type creation", "Unique display type constraints", "Web configuration validation"]
-             * @functionalArea "web-display-management"
-             * @performance "Real-time display type creation with immediate availability"
-             *
-             * @param params Site ID for web display type creation
-             * @returns Promise<BaseResponse<unknown>> Complete response with created web display type details
+             * Create new transaction web display type - OpenAPI Path: /trans-web-display-type
              */
-            create: async (params) => {
-                return this.executeRequest({
-                    method: 'POST',
-                    path: '/trans-web-display-type',
-                    paramsSchema: schemas_1.TransWebDisplayTypeCreateParamsSchema,
-                    responseSchema: schemas_1.TransWebDisplayTypeResponseSchema,
-                }, params);
-            },
+            create: this.createCreateMethod('/trans-web-display-type', schemas_1.TransWebDisplayTypeCreateParamsSchema, schemas_1.TransWebDisplayTypeResponseSchema),
             /**
-             * Get transaction web display type details by display type UID
-             *
-             * @fullPath api.p21Apis.transWebDisplayType.get
-             * @service p21-apis
-             * @domain web-display-management
-             * @dataMethod getData - returns only the web display type object without metadata
-             * @discoverable true
-             * @searchTerms ["web display type details", "get display type", "display type info", "display type lookup"]
-             * @relatedEndpoints ["api.p21Apis.transWebDisplayType.update", "api.p21Apis.transWebDisplayType.delete", "api.commerce.webDisplay.get"]
-             * @commonPatterns ["Get display type details", "View display type information", "Display type lookup", "Display type verification"]
-             * @workflow ["web-display-details", "ui-configuration", "display-lookup", "web-browsing"]
-             * @prerequisites ["Valid display type UID", "Site ID", "Display type access permissions"]
-             * @nextSteps ["api.p21Apis.transWebDisplayType.update for modifications", "api.commerce.webDisplay for extended operations"]
-             * @businessRules ["Display type UID must exist", "Site-scoped access", "Optional display type ID validation"]
-             * @functionalArea "web-display-management"
-             * @performance "Direct lookup by UID, very fast response"
-             *
-             * @param params Web display type UID and site ID parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with web display type details
+             * Get transaction web display type details by display type UID - OpenAPI Path: /trans-web-display-type/{webDisplayTypeUid}
              */
-            get: async (params) => {
+            get: async (webDisplayTypeUid, params) => {
                 return this.executeRequest({
                     method: 'GET',
-                    path: '/trans-web-display-type/{webDisplayTypeUid}',
+                    path: `/trans-web-display-type/${webDisplayTypeUid}`,
                     paramsSchema: schemas_1.TransWebDisplayTypeParamsSchema,
                     responseSchema: schemas_1.TransWebDisplayTypeResponseSchema,
-                }, params, { webDisplayTypeUid: params.webDisplayTypeUid });
+                }, { webDisplayTypeUid, ...params });
             },
             /**
-             * Update transaction web display type by display type UID
-             *
-             * @fullPath api.p21Apis.transWebDisplayType.update
-             * @service p21-apis
-             * @domain web-display-management
-             * @dataMethod updateData - returns only the updated web display type without metadata
-             * @discoverable true
-             * @searchTerms ["update web display type", "modify display type", "display type update", "edit display type"]
-             * @relatedEndpoints ["api.p21Apis.transWebDisplayType.get", "api.p21Apis.transWebDisplayType.delete", "api.commerce.webDisplay.update"]
-             * @commonPatterns ["Update display type information", "Modify display type details", "Display type maintenance", "Display type editing"]
-             * @workflow ["web-display-management", "ui-configuration", "display-maintenance", "web-updates"]
-             * @prerequisites ["Valid display type UID", "Site ID", "Display type modification permissions"]
-             * @nextSteps ["api.p21Apis.transWebDisplayType.get for verification", "api.commerce.webDisplay for related updates"]
-             * @businessRules ["Display type UID must exist", "Site-scoped modifications", "Data validation requirements"]
-             * @functionalArea "web-display-management"
-             * @performance "Real-time display type updates with immediate effect"
-             *
-             * @param params Web display type UID and site ID parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with updated web display type details
+             * Update transaction web display type by display type UID - OpenAPI Path: /trans-web-display-type/{webDisplayTypeUid}
              */
-            update: async (params) => {
+            update: async (webDisplayTypeUid, params) => {
                 return this.executeRequest({
                     method: 'PUT',
-                    path: '/trans-web-display-type/{webDisplayTypeUid}',
+                    path: `/trans-web-display-type/${webDisplayTypeUid}`,
                     paramsSchema: schemas_1.TransWebDisplayTypeParamsSchema,
                     responseSchema: schemas_1.TransWebDisplayTypeResponseSchema,
-                }, params, { webDisplayTypeUid: params.webDisplayTypeUid });
+                }, { webDisplayTypeUid, ...params });
             },
             /**
-             * Delete transaction web display type by display type UID
-             *
-             * @fullPath api.p21Apis.transWebDisplayType.delete
-             * @service p21-apis
-             * @domain web-display-management
-             * @dataMethod deleteData - returns only the deletion result without metadata
-             * @discoverable true
-             * @searchTerms ["delete web display type", "remove display type", "display type deletion", "display type removal"]
-             * @relatedEndpoints ["api.p21Apis.transWebDisplayType.create", "api.p21Apis.transWebDisplayType.get", "api.commerce.webDisplay.delete"]
-             * @commonPatterns ["Delete display type", "Remove display type from system", "Display type cleanup", "Display type removal"]
-             * @workflow ["web-display-management", "system-cleanup", "display-maintenance", "web-configuration"]
-             * @prerequisites ["Valid display type UID", "Site ID", "Display type deletion permissions"]
-             * @nextSteps ["api.commerce.webDisplay.list to verify removal", "related display reassignment if needed"]
-             * @businessRules ["Display type UID must exist", "Cascade deletion rules", "Related entity validation"]
-             * @functionalArea "web-display-management"
-             * @performance "Real-time display type deletion with immediate effect"
-             *
-             * @param params Web display type UID and site ID parameters
-             * @returns Promise<BaseResponse<unknown>> Complete response with deletion confirmation
+             * Delete transaction web display type by display type UID - OpenAPI Path: /trans-web-display-type/{webDisplayTypeUid}
              */
-            delete: async (params) => {
+            delete: async (webDisplayTypeUid, params) => {
                 return this.executeRequest({
                     method: 'DELETE',
-                    path: '/trans-web-display-type/{webDisplayTypeUid}',
+                    path: `/trans-web-display-type/${webDisplayTypeUid}`,
                     paramsSchema: schemas_1.TransWebDisplayTypeParamsSchema,
                     responseSchema: schemas_1.TransWebDisplayTypeResponseSchema,
-                }, params, { webDisplayTypeUid: params.webDisplayTypeUid });
+                }, { webDisplayTypeUid, ...params });
             },
             /**
-             * Get web display type defaults for configuration setup
-             *
-             * @fullPath api.p21Apis.transWebDisplayType.defaults
-             * @service p21-apis
-             * @domain web-display-management
-             * @dataMethod defaultsData - returns only the default values without metadata
-             * @discoverable true
-             * @searchTerms ["web display type defaults", "display defaults", "default values", "display configuration"]
-             * @relatedEndpoints ["api.p21Apis.transWebDisplayType.definition", "api.p21Apis.transWebDisplayType.create", "api.commerce.webDisplay.defaults"]
-             * @commonPatterns ["Get display defaults", "View default configuration", "Display setup values", "Configuration templates"]
-             * @workflow ["web-display-setup", "ui-configuration", "display-configuration", "web-customization"]
-             * @prerequisites ["Site ID", "Display configuration access permissions"]
-             * @nextSteps ["api.p21Apis.transWebDisplayType.create with defaults", "api.p21Apis.transWebDisplayType.definition for schema"]
-             * @businessRules ["Site-scoped default values", "Configuration template access", "Default value validation"]
-             * @functionalArea "web-display-management"
-             * @caching "Cache defaults for 30 minutes, change infrequently"
-             * @performance "Quick access to default configuration values"
-             *
-             * @param params Site ID for web display type defaults
-             * @returns Promise<BaseResponse<unknown>> Complete response with default values for web display type
+             * Web Display Type Defaults Operations - OpenAPI Path: /trans-web-display-type/defaults
              */
-            defaults: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/trans-web-display-type/defaults',
-                    paramsSchema: schemas_1.TransWebDisplayTypeDefaultsParamsSchema,
-                    responseSchema: schemas_1.TransWebDisplayTypeDefaultsResponseSchema,
-                }, params);
+            defaults: {
+                /**
+                 * Get web display type defaults for configuration setup - OpenAPI Path: /trans-web-display-type/defaults
+                 * @description Retrieves default configuration values for web display types. Essential for setup and configuration workflows.
+                 *
+                 * @fullPath api.p21Apis.transWebDisplayType.defaults.get
+                 * @service p21-apis
+                 * @domain web-display-management
+                 * @dataMethod getData - returns only the default values without metadata
+                 * @discoverable true
+                 * @searchTerms ["web display type defaults", "display defaults", "default values", "display configuration"]
+                 * @relatedEndpoints ["api.p21Apis.transWebDisplayType.definition.get", "api.p21Apis.transWebDisplayType.create", "api.commerce.webDisplay.defaults"]
+                 * @commonPatterns ["Get display defaults", "View default configuration", "Display setup values", "Configuration templates"]
+                 * @workflow ["web-display-setup", "ui-configuration", "display-configuration", "web-customization"]
+                 * @prerequisites ["Site ID", "Display configuration access permissions"]
+                 * @nextSteps ["api.p21Apis.transWebDisplayType.create with defaults", "api.p21Apis.transWebDisplayType.definition for schema"]
+                 * @businessRules ["Site-scoped default values", "Configuration template access", "Default value validation"]
+                 * @functionalArea "web-display-management"
+                 * @performance "Quick access to default configuration values"
+                 */
+                get: async (params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/trans-web-display-type/defaults',
+                        paramsSchema: schemas_1.TransWebDisplayTypeDefaultsParamsSchema,
+                        responseSchema: schemas_1.TransWebDisplayTypeDefaultsResponseSchema,
+                    }, params || {});
+                },
+                /**
+                 * Get only web display type defaults data without response metadata
+                 * @param params Site ID for web display type defaults
+                 * @returns Promise<TransWebDisplayTypeDefaultsData> Direct default values object
+                 */
+                getData: async (params) => {
+                    const response = await this.transWebDisplayType.defaults.get(params);
+                    return response.data;
+                },
             },
             /**
-             * Get web display type definition for service schema information
-             *
-             * @fullPath api.p21Apis.transWebDisplayType.definition
-             * @service p21-apis
-             * @domain web-display-management
-             * @dataMethod definitionData - returns only the service definition without metadata
-             * @discoverable true
-             * @searchTerms ["web display type definition", "display definition", "service definition", "schema definition"]
-             * @relatedEndpoints ["api.p21Apis.transWebDisplayType.defaults", "api.p21Apis.transWebDisplayType.create", "api.commerce.webDisplay.schema"]
-             * @commonPatterns ["Get service definition", "View schema information", "Display type schema", "Service metadata"]
-             * @workflow ["web-display-setup", "ui-configuration", "schema-discovery", "service-introspection"]
-             * @prerequisites ["Site ID", "Service definition access permissions"]
-             * @nextSteps ["api.p21Apis.transWebDisplayType.defaults for default values", "api.p21Apis.transWebDisplayType.create for implementation"]
-             * @businessRules ["Site-scoped service definition", "Schema information access", "Service metadata validation"]
-             * @functionalArea "web-display-management"
-             * @caching "Cache definition for 60 minutes, schema changes infrequently"
-             * @performance "Quick access to service schema and definition"
-             *
-             * @param params Site ID for web display type definition
-             * @returns Promise<BaseResponse<unknown>> Complete response with service definition for web display type
+             * Web Display Type Definition Operations - OpenAPI Path: /trans-web-display-type/definition
              */
-            definition: async (params) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/trans-web-display-type/definition',
-                    paramsSchema: schemas_1.TransWebDisplayTypeDefinitionParamsSchema,
-                    responseSchema: schemas_1.TransWebDisplayTypeDefinitionResponseSchema,
-                }, params);
-            },
-            // Data methods for transaction web display type operations
+            definition: {
+                /**
+                 * Get web display type definition for service schema information - OpenAPI Path: /trans-web-display-type/definition
+                 * @description Retrieves service definition and schema information for web display types. Used for introspection and development workflows.
+                 *
+                 * @fullPath api.p21Apis.transWebDisplayType.definition.get
+                 * @service p21-apis
+                 * @domain web-display-management
+                 * @dataMethod getData - returns only the service definition without metadata
+                 * @discoverable true
+                 * @searchTerms ["web display type definition", "display definition", "service definition", "schema definition"]
+                 * @relatedEndpoints ["api.p21Apis.transWebDisplayType.defaults.get", "api.p21Apis.transWebDisplayType.create", "api.commerce.webDisplay.schema"]
+                 * @commonPatterns ["Get service definition", "View schema information", "Display type schema", "Service metadata"]
+                 * @workflow ["web-display-setup", "ui-configuration", "schema-discovery", "service-introspection"]
+                 * @prerequisites ["Site ID", "Service definition access permissions"]
+                 * @nextSteps ["api.p21Apis.transWebDisplayType.defaults for default values", "api.p21Apis.transWebDisplayType.create for implementation"]
+                 * @businessRules ["Site-scoped service definition", "Schema information access", "Service metadata validation"]
+                 * @functionalArea "web-display-management"
+                 * @performance "Quick access to service schema and definition"
+                 */
+                get: async (params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/trans-web-display-type/definition',
+                        paramsSchema: schemas_1.TransWebDisplayTypeDefinitionParamsSchema,
+                        responseSchema: schemas_1.TransWebDisplayTypeDefinitionResponseSchema,
+                    }, params || {});
+                },
+                /**
+                 * Get only web display type definition data without response metadata
+                 * @param params Site ID for web display type definition
+                 * @returns Promise<TransWebDisplayTypeDefinitionData> Direct service definition object
+                 */
+                getData: async (params) => {
+                    const response = await this.transWebDisplayType.definition.get(params);
+                    return response.data;
+                },
+            },
+            // Data methods
             createData: async (params) => {
-                const response = await this.transWebDisplayType.create(params);
-                return response.data;
-            },
-            getData: async (params) => {
-                const response = await this.transWebDisplayType.get(params);
-                return response.data;
-            },
-            updateData: async (params) => {
-                const response = await this.transWebDisplayType.update(params);
+                const response = await this.transWebDisplayType.create(params || {});
                 return response.data;
             },
-            deleteData: async (params) => {
-                const response = await this.transWebDisplayType.delete(params);
+            getData: async (webDisplayTypeUid, params) => {
+                const response = await this.transWebDisplayType.get(webDisplayTypeUid, params);
                 return response.data;
             },
-            defaultsData: async (params) => {
-                const response = await this.transWebDisplayType.defaults(params);
+            updateData: async (webDisplayTypeUid, params) => {
+                const response = await this.transWebDisplayType.update(webDisplayTypeUid, params);
                 return response.data;
             },
-            definitionData: async (params) => {
-                const response = await this.transWebDisplayType.definition(params);
+            deleteData: async (webDisplayTypeUid, params) => {
+                const response = await this.transWebDisplayType.delete(webDisplayTypeUid, params);
                 return response.data;
             },
         };
-        // Reference schemas to ensure 100% import coverage
-        void this.schemaRefs;
     }
 }
 exports.P21ApisClient = P21ApisClient;