@simpleapps-com/augur-api 0.3.0 → 0.3.2

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

@@ -0,0 +1,957 @@
+"use strict";
+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
+ * @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"]
+ * @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"]
+ * @nextSteps ["api.p21Core for core ERP operations", "api.orders for order processing", "api.items for inventory management"]
+ * @businessRules ["Site-scoped data access", "Bearer JWT authentication required", "Transactional consistency", "Entity refresh synchronization"]
+ * @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 client = new P21ApisClient(new HTTPClient({ baseURL: 'https://p21-apis.augur-api.com' }));
+ *
+ * // Refresh entity data
+ * const contactsRefresh = await client.entityContacts.refresh({ 'x-site-id': 'SITE123' });
+ * console.log(contactsRefresh.data); // Refresh result
+ *
+ * // Create new category
+ * const newCategory = await client.transCategory.create({ 'x-site-id': 'SITE123' });
+ * console.log(newCategory.data); // Category creation result
+ *
+ * // Get category details
+ * const category = await client.transCategory.get({ categoryUid: 123, 'x-site-id': 'SITE123' });
+ * console.log(category.data); // Category details
+ *
+ * // Update company information
+ * const updatedCompany = await client.transCompany.update({ companyUid: 456, 'x-site-id': 'SITE123' });
+ * ```
+ */
+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
+     * @param baseUrl Base URL for the P21 APIs service (default: https://p21-apis.augur-api.com)
+     */
+    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
+         */
+        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' });
+             * ```
+             */
+            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;
+            },
+        };
+        /**
+         * Entity customers refresh operations for data synchronization
+         * @fullPath api.p21Apis.entityCustomers
+         * @service p21-apis
+         * @domain entity-data-management
+         * @discoverable true
+         */
+        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' });
+             * ```
+             */
+            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;
+            },
+        };
+        /**
+         * Health check operations for service monitoring and system status verification
+         * @fullPath api.p21Apis.health
+         * @service p21-apis
+         * @domain system-monitoring
+         * @discoverable true
+         */
+        this.health = {
+            /**
+             * Perform health check to verify P21 APIs service status and connectivity
+             *
+             * @fullPath api.p21Apis.health.check
+             * @service p21-apis
+             * @domain system-monitoring
+             * @dataMethod checkData - 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"]
+             * @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);
+                return response.data;
+            },
+        };
+        /**
+         * Transaction category operations for category management and CRUD operations
+         * @fullPath api.p21Apis.transCategory
+         * @service p21-apis
+         * @domain category-management
+         * @discoverable true
+         */
+        this.transCategory = {
+            /**
+             * Create new transaction category
+             *
+             * @fullPath api.p21Apis.transCategory.create
+             * @service p21-apis
+             * @domain category-management
+             * @dataMethod createData - returns only the created category without metadata
+             * @discoverable true
+             * @searchTerms ["create category", "new category", "category creation", "add category"]
+             * @relatedEndpoints ["api.p21Apis.transCategory.get", "api.p21Apis.transCategory.update", "api.items.categories.list"]
+             * @commonPatterns ["Create new category", "Add category to system", "Category setup", "Product categorization"]
+             * @workflow ["category-setup", "product-management", "inventory-organization", "catalog-management"]
+             * @prerequisites ["Valid site ID", "Category creation permissions", "Authentication"]
+             * @nextSteps ["api.p21Apis.transCategory.get for verification", "api.items.categories for category associations"]
+             * @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);
+            },
+            /**
+             * Get transaction category details by category UID
+             *
+             * @fullPath api.p21Apis.transCategory.get
+             * @service p21-apis
+             * @domain category-management
+             * @dataMethod getData - returns only the category object without metadata
+             * @discoverable true
+             * @searchTerms ["category details", "get category", "category info", "category lookup"]
+             * @relatedEndpoints ["api.p21Apis.transCategory.update", "api.p21Apis.transCategory.delete", "api.items.categories.get"]
+             * @commonPatterns ["Get category details", "View category information", "Category lookup", "Category verification"]
+             * @workflow ["category-details", "product-management", "inventory-lookup", "catalog-browsing"]
+             * @prerequisites ["Valid category UID", "Site ID", "Category access permissions"]
+             * @nextSteps ["api.p21Apis.transCategory.update for modifications", "api.items.categories for related products"]
+             * @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) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/trans-category/{categoryUid}',
+                    paramsSchema: schemas_1.TransCategoryParamsSchema,
+                    responseSchema: schemas_1.TransCategoryResponseSchema,
+                }, params, { categoryUid: params.categoryUid });
+            },
+            /**
+             * Update transaction category by category UID
+             *
+             * @fullPath api.p21Apis.transCategory.update
+             * @service p21-apis
+             * @domain category-management
+             * @dataMethod updateData - returns only the updated category without metadata
+             * @discoverable true
+             * @searchTerms ["update category", "modify category", "category update", "edit category"]
+             * @relatedEndpoints ["api.p21Apis.transCategory.get", "api.p21Apis.transCategory.delete", "api.items.categories.update"]
+             * @commonPatterns ["Update category information", "Modify category details", "Category maintenance", "Category editing"]
+             * @workflow ["category-management", "product-management", "inventory-maintenance", "catalog-updates"]
+             * @prerequisites ["Valid category UID", "Site ID", "Category modification permissions"]
+             * @nextSteps ["api.p21Apis.transCategory.get for verification", "api.items.categories for related updates"]
+             * @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) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/trans-category/{categoryUid}',
+                    paramsSchema: schemas_1.TransCategoryParamsSchema,
+                    responseSchema: schemas_1.TransCategoryResponseSchema,
+                }, params, { categoryUid: params.categoryUid });
+            },
+            /**
+             * Delete transaction category by category UID
+             *
+             * @fullPath api.p21Apis.transCategory.delete
+             * @service p21-apis
+             * @domain category-management
+             * @dataMethod deleteData - returns only the deletion result without metadata
+             * @discoverable true
+             * @searchTerms ["delete category", "remove category", "category deletion", "category removal"]
+             * @relatedEndpoints ["api.p21Apis.transCategory.create", "api.p21Apis.transCategory.get", "api.items.categories.delete"]
+             * @commonPatterns ["Delete category", "Remove category from system", "Category cleanup", "Category removal"]
+             * @workflow ["category-management", "system-cleanup", "inventory-maintenance", "catalog-management"]
+             * @prerequisites ["Valid category UID", "Site ID", "Category deletion permissions"]
+             * @nextSteps ["api.items.categories.list to verify removal", "related product reassignment if needed"]
+             * @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) => {
+                return this.executeRequest({
+                    method: 'DELETE',
+                    path: '/trans-category/{categoryUid}',
+                    paramsSchema: schemas_1.TransCategoryParamsSchema,
+                    responseSchema: schemas_1.TransCategoryResponseSchema,
+                }, params, { categoryUid: params.categoryUid });
+            },
+            // Data methods for transaction category operations
+            createData: async (params) => {
+                const response = await this.transCategory.create(params);
+                return response.data;
+            },
+            getData: async (params) => {
+                const response = await this.transCategory.get(params);
+                return response.data;
+            },
+            updateData: async (params) => {
+                const response = await this.transCategory.update(params);
+                return response.data;
+            },
+            deleteData: async (params) => {
+                const response = await this.transCategory.delete(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
+         */
+        this.transCompany = {
+            /**
+             * Create new transaction company
+             *
+             * @fullPath api.p21Apis.transCompany.create
+             * @service p21-apis
+             * @domain company-management
+             * @dataMethod createData - returns only the created company without metadata
+             * @discoverable true
+             * @searchTerms ["create company", "new company", "company creation", "add company"]
+             * @relatedEndpoints ["api.p21Apis.transCompany.get", "api.p21Apis.transCompany.update", "api.p21Core.company.list"]
+             * @commonPatterns ["Create new company", "Add company to system", "Company setup", "Business entity creation"]
+             * @workflow ["company-setup", "business-management", "corporate-structure", "entity-management"]
+             * @prerequisites ["Valid site ID", "Company creation permissions", "Authentication"]
+             * @nextSteps ["api.p21Apis.transCompany.get for verification", "api.p21Core.company for company operations"]
+             * @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);
+            },
+            /**
+             * 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: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/trans-company/{companyUid}',
+                    paramsSchema: schemas_1.TransCompanyParamsSchema,
+                    responseSchema: schemas_1.TransCompanyResponseSchema,
+                }, params, { companyUid: params.companyUid });
+            },
+            /**
+             * 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: async (params) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/trans-company/{companyUid}',
+                    paramsSchema: schemas_1.TransCompanyParamsSchema,
+                    responseSchema: schemas_1.TransCompanyResponseSchema,
+                }, params, { companyUid: params.companyUid });
+            },
+            /**
+             * 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: async (params) => {
+                return this.executeRequest({
+                    method: 'DELETE',
+                    path: '/trans-company/{companyUid}',
+                    paramsSchema: schemas_1.TransCompanyParamsSchema,
+                    responseSchema: schemas_1.TransCompanyResponseSchema,
+                }, params, { companyUid: params.companyUid });
+            },
+            // Data methods for transaction company operations
+            createData: async (params) => {
+                const response = await this.transCompany.create(params);
+                return response.data;
+            },
+            getData: async (params) => {
+                const response = await this.transCompany.get(params);
+                return response.data;
+            },
+            updateData: async (params) => {
+                const response = await this.transCompany.update(params);
+                return response.data;
+            },
+            deleteData: async (params) => {
+                const response = await this.transCompany.delete(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
+         */
+        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: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/trans-purchase-order-receipt/{poNo}',
+                    paramsSchema: schemas_1.TransPurchaseOrderReceiptParamsSchema,
+                    responseSchema: schemas_1.TransPurchaseOrderReceiptResponseSchema,
+                }, params, { poNo: params.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: async (params) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/trans-purchase-order-receipt/{poNo}',
+                    paramsSchema: schemas_1.TransPurchaseOrderReceiptParamsSchema,
+                    responseSchema: schemas_1.TransPurchaseOrderReceiptResponseSchema,
+                }, params, { poNo: params.poNo });
+            },
+            // Data methods for transaction purchase order receipt operations
+            getData: async (params) => {
+                const response = await this.transPurchaseOrderReceipt.get(params);
+                return response.data;
+            },
+            updateData: async (params) => {
+                const response = await this.transPurchaseOrderReceipt.update(params);
+                return response.data;
+            },
+        };
+        /**
+         * Transaction user operations for user management and CRUD operations
+         * @fullPath api.p21Apis.transUser
+         * @service p21-apis
+         * @domain user-management
+         * @discoverable true
+         */
+        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: async (params) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/trans-user',
+                    paramsSchema: schemas_1.TransUserCreateParamsSchema,
+                    responseSchema: schemas_1.TransUserResponseSchema,
+                }, params);
+            },
+            /**
+             * 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: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/trans-user/{usersUid}',
+                    paramsSchema: schemas_1.TransUserParamsSchema,
+                    responseSchema: schemas_1.TransUserResponseSchema,
+                }, params, { usersUid: params.usersUid });
+            },
+            /**
+             * 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: async (params) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/trans-user/{usersUid}',
+                    paramsSchema: schemas_1.TransUserParamsSchema,
+                    responseSchema: schemas_1.TransUserResponseSchema,
+                }, params, { usersUid: params.usersUid });
+            },
+            /**
+             * 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: async (params) => {
+                return this.executeRequest({
+                    method: 'DELETE',
+                    path: '/trans-user/{usersUid}',
+                    paramsSchema: schemas_1.TransUserParamsSchema,
+                    responseSchema: schemas_1.TransUserResponseSchema,
+                }, params, { usersUid: params.usersUid });
+            },
+            // Data methods for transaction user operations
+            createData: async (params) => {
+                const response = await this.transUser.create(params);
+                return response.data;
+            },
+            getData: async (params) => {
+                const response = await this.transUser.get(params);
+                return response.data;
+            },
+            updateData: async (params) => {
+                const response = await this.transUser.update(params);
+                return response.data;
+            },
+            deleteData: async (params) => {
+                const response = await this.transUser.delete(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
+         */
+        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: async (params) => {
+                return this.executeRequest({
+                    method: 'POST',
+                    path: '/trans-web-display-type',
+                    paramsSchema: schemas_1.TransWebDisplayTypeCreateParamsSchema,
+                    responseSchema: schemas_1.TransWebDisplayTypeResponseSchema,
+                }, params);
+            },
+            /**
+             * 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: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/trans-web-display-type/{webDisplayTypeUid}',
+                    paramsSchema: schemas_1.TransWebDisplayTypeParamsSchema,
+                    responseSchema: schemas_1.TransWebDisplayTypeResponseSchema,
+                }, params, { webDisplayTypeUid: params.webDisplayTypeUid });
+            },
+            /**
+             * 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: async (params) => {
+                return this.executeRequest({
+                    method: 'PUT',
+                    path: '/trans-web-display-type/{webDisplayTypeUid}',
+                    paramsSchema: schemas_1.TransWebDisplayTypeParamsSchema,
+                    responseSchema: schemas_1.TransWebDisplayTypeResponseSchema,
+                }, params, { webDisplayTypeUid: params.webDisplayTypeUid });
+            },
+            /**
+             * 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: async (params) => {
+                return this.executeRequest({
+                    method: 'DELETE',
+                    path: '/trans-web-display-type/{webDisplayTypeUid}',
+                    paramsSchema: schemas_1.TransWebDisplayTypeParamsSchema,
+                    responseSchema: schemas_1.TransWebDisplayTypeResponseSchema,
+                }, params, { webDisplayTypeUid: params.webDisplayTypeUid });
+            },
+            /**
+             * 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
+             */
+            defaults: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/trans-web-display-type/defaults',
+                    paramsSchema: schemas_1.TransWebDisplayTypeDefaultsParamsSchema,
+                    responseSchema: schemas_1.TransWebDisplayTypeDefaultsResponseSchema,
+                }, params);
+            },
+            /**
+             * 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
+             */
+            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
+            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);
+                return response.data;
+            },
+            deleteData: async (params) => {
+                const response = await this.transWebDisplayType.delete(params);
+                return response.data;
+            },
+            defaultsData: async (params) => {
+                const response = await this.transWebDisplayType.defaults(params);
+                return response.data;
+            },
+            definitionData: async (params) => {
+                const response = await this.transWebDisplayType.definition(params);
+                return response.data;
+            },
+        };
+        // Reference schemas to ensure 100% import coverage
+        void this.schemaRefs;
+    }
+}
+exports.P21ApisClient = P21ApisClient;
+//# sourceMappingURL=client.js.map