@simpleapps-com/augur-api 0.3.3 → 0.4.1

package/dist/esm/services/legacy/client.js

@@ -12,7 +12,14 @@ ItemCategoryResponseSchema,
 OrderResetApiResponseSchema, } from './schemas';
 /**
  * Legacy API Client
- * @description Client for interacting with Legacy microservice API endpoints for legacy data structures, state management, inventory operations, and order processing
+ * @description Client for interacting with Legacy microservice API endpoints following OpenAPI Path Mirroring Pattern
+ * @fullPath api.legacy
+ * @service legacy
+ * @domain legacy-data-management
+ * @discoverable true
+ * @searchTerms ["legacy", "states", "inventory", "orders", "tags", "categories"]
+ * @relatedEndpoints ["items", "customers", "orders"]
+ * @commonPatterns ["CRUD operations", "state management", "inventory tagging"]
  * @example
  * ```typescript
  * import { HTTPClient } from '@augur/api-client/core';
@@ -21,14 +28,20 @@ OrderResetApiResponseSchema, } from './schemas';
  * const http = new HTTPClient('legacy', { siteId: 'your-site-id', bearerToken: 'your-token' });
  * const legacy = new LegacyClient(http);
  *
- * // List states
- * const states = await legacy.states.list({ limit: 25, twoLetterCode: 'CA' });
+ * // Health check
+ * const health = await legacy.healthCheck.get();
  *
- * // Get inventory tags
+ * // Inventory operations
+ * const alsoBought = await legacy.invMast.alsoBought.list(12345);
  * const tags = await legacy.invMast.tags.list(12345);
+ * const webDesc = await legacy.invMast.webDesc.list(12345);
  *
- * // Reset order
- * const resetResult = await legacy.orders.reset(67890);
+ * // State management
+ * const states = await legacy.legacy.state.list({ limit: 25, twoLetterCode: 'CA' });
+ *
+ * // Categories and orders
+ * const category = await legacy.itemCategory.get(67890);
+ * const resetResult = await legacy.orders.reset.get(98765);
  * ```
  */
 export class LegacyClient extends BaseServiceClient {
@@ -42,148 +55,106 @@ export class LegacyClient extends BaseServiceClient {
         /**
          * Health check endpoint
          * @description Service health monitoring (requires only x-site-id header, no bearer token)
+         * @fullPath api.legacy.healthCheck.get
+         * @service legacy
+         * @domain system-monitoring
+         * @dataMethod getHealthCheckData
+         * @discoverable true
+         * @searchTerms ["health", "status", "monitoring"]
+         * @relatedEndpoints ["healthCheck"]
+         * @commonPatterns ["service health check"]
          */
-        this.getHealthCheck = this.createHealthCheckMethod(HealthCheckResponseSchema);
-        /**
-         * State management endpoints
-         * @description CRUD operations for US states and provinces with tax information
-         */
-        this.states = {
-            /**
-             * List states with optional filtering and pagination
-             * @description Retrieve a paginated list of states with optional filtering by two-letter code
-             * @param params Optional filtering and pagination parameters
-             * @returns Paginated list of state objects with tax information
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * // List all states
-             * const allStates = await client.states.list();
-             *
-             * // Filter by state code
-             * const californiaStates = await client.states.list({
-             *   twoLetterCode: 'CA',
-             *   limit: 10
-             * });
-             *
-             * // Paginated results
-             * const statesPage = await client.states.list({
-             *   limit: 25,
-             *   offset: 50
-             * });
-             * ```
-             */
-            list: this.createListMethod('/legacy/state', StateListParamsSchema, StateListResponseSchema),
-            /**
-             * Get state details by UID
-             * @description Retrieve complete details for a specific state including tax information
-             * @param stateUid State unique identifier
-             * @param params Optional query parameters
-             * @returns Complete state object with tax and administrative information
-             * @throws ValidationError When parameters are invalid or response is malformed
-             * @example
-             * ```typescript
-             * // Get state by UID
-             * const state = await client.states.get(1);
-             * console.log(state.state_name, state.tax_rate);
-             *
-             * // Get with additional filtering
-             * const state = await client.states.get(1, { twoLetterCode: 'CA' });
-             * ```
-             */
-            get: this.createGetMethod('/legacy/state/{id}', StateResponseSchema, StateGetParamsSchema),
-            /**
-             * Create a new state record
-             * @description Add a new state or province to the system with tax configuration
-             * @param stateData State information including name, code, and tax settings
-             * @returns Created state object with assigned state_uid
-             * @throws ValidationError When state data is invalid or response is malformed
-             * @example
-             * ```typescript
-             * const newState = await client.states.create({
-             *   country_uid: 1,
-             *   two_letter_code: 'TX',
-             *   state_name: 'Texas',
-             *   tax_rate: 0.0625,
-             *   active: 1,
-             *   tax_shipping: 0
-             * });
-             * console.log('Created state with UID:', newState.state_uid);
-             * ```
-             */
-            create: this.createCreateMethod('/legacy/state', CreateStateRequestSchema, StateResponseSchema),
+        this.healthCheck = {
             /**
-             * Update an existing state record
-             * @description Modify state information including tax rates and administrative details
-             * @param stateUid State unique identifier
-             * @param stateData Updated state information (partial updates supported)
-             * @returns Updated state object
-             * @throws ValidationError When state data is invalid or response is malformed
-             * @example
-             * ```typescript
-             * const updatedState = await client.states.update(1, {
-             *   state_name: 'California Updated',
-             *   tax_rate: 0.0925,
-             *   active: 1
-             * });
-             * ```
-             */
-            update: this.createUpdateMethod('/legacy/state/{id}', UpdateStateRequestSchema, StateResponseSchema),
-            /**
-             * Delete a state record
-             * @description Remove a state from the system (use with caution)
-             * @param stateUid State unique identifier
-             * @returns Confirmation of deletion
+             * Get service health status
+             * @description Check if the legacy service is healthy and operational
+             * @returns Service health status and metadata
              * @throws ValidationError When response is malformed
              * @example
              * ```typescript
-             * const result = await client.states.delete(1);
-             * console.log('State deleted:', result.deleted);
+             * const health = await client.healthCheck.get();
+             * console.log('Service status:', health.data.status);
              * ```
              */
-            delete: this.createDeleteMethod('/legacy/state/{id}', DeleteResponseSchema),
+            get: this.createHealthCheckMethod(HealthCheckResponseSchema),
         };
         /**
          * Inventory master operations
          * @description Operations for inventory items including also-bought analysis, tagging, and web descriptions
+         * @fullPath api.legacy.invMast
+         * @service legacy
+         * @domain inventory-management
+         * @discoverable true
+         * @searchTerms ["inventory", "products", "tags", "descriptions"]
+         * @relatedEndpoints ["items", "commerce"]
+         * @commonPatterns ["product management", "inventory tagging"]
          */
         this.invMast = {
             /**
-             * Get products frequently bought with a specific item
-             * @description Retrieve products commonly purchased together for recommendation systems
-             * @param invMastUid Inventory master unique identifier
-             * @returns Array of related products with relationship strength data
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const alsoBought = await client.invMast.getAlsoBought(12345);
-             * alsoBought.forEach(product => {
-             *   console.log(`${product.item_desc} - Frequency: ${product.frequency}`);
-             * });
-             * ```
+             * Also-bought analysis operations
+             * @description Products frequently bought together analysis
              */
-            getAlsoBought: async (invMastUid) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/inv-mast/{id}/also-bought',
-                    responseSchema: AlsoBoughtListResponseSchema,
-                }, undefined, { id: String(invMastUid) });
+            alsoBought: {
+                /**
+                 * List products frequently bought with a specific item
+                 * @description Retrieve products commonly purchased together for recommendation systems
+                 * @fullPath api.legacy.invMast.alsoBought.list
+                 * @service legacy
+                 * @domain product-recommendations
+                 * @dataMethod listAlsoBoughtData
+                 * @discoverable true
+                 * @searchTerms ["also bought", "recommendations", "related products"]
+                 * @relatedEndpoints ["commerce.recommendations"]
+                 * @commonPatterns ["product recommendations", "cross-selling"]
+                 * @param invMastUid Inventory master unique identifier
+                 * @returns Array of related products with relationship strength data
+                 * @throws ValidationError When response is malformed
+                 * @example
+                 * ```typescript
+                 * const alsoBought = await client.invMast.alsoBought.list(12345);
+                 * alsoBought.data.forEach(product => {
+                 *   console.log(`${product.item_desc} - Frequency: ${product.frequency}`);
+                 * });
+                 * ```
+                 */
+                list: async (invMastUid) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/inv-mast/{id}/also-bought',
+                        responseSchema: AlsoBoughtListResponseSchema,
+                    }, undefined, { id: String(invMastUid) });
+                },
             },
             /**
              * Inventory tags management
              * @description CRUD operations for inventory item tags and metadata
+             * @fullPath api.legacy.invMast.tags
+             * @service legacy
+             * @domain inventory-metadata
+             * @discoverable true
+             * @searchTerms ["inventory tags", "metadata", "tagging"]
+             * @relatedEndpoints ["items.attributes"]
+             * @commonPatterns ["product tagging", "metadata management"]
              */
             tags: {
                 /**
                  * List tags for an inventory item
                  * @description Retrieve all tags associated with a specific inventory item
+                 * @fullPath api.legacy.invMast.tags.list
+                 * @service legacy
+                 * @domain inventory-metadata
+                 * @dataMethod listTagsData
+                 * @discoverable true
+                 * @searchTerms ["list tags", "inventory metadata", "product tags"]
+                 * @relatedEndpoints ["items.attributes.list"]
+                 * @commonPatterns ["tag listing", "metadata retrieval"]
                  * @param invMastUid Inventory master unique identifier
                  * @returns Array of tag objects for the item
                  * @throws ValidationError When response is malformed
                  * @example
                  * ```typescript
                  * const tags = await client.invMast.tags.list(12345);
-                 * tags.forEach(tag => {
+                 * tags.data.forEach(tag => {
                  *   console.log(`${tag.tag_name}: ${tag.tag_value}`);
                  * });
                  * ```
@@ -198,6 +169,14 @@ export class LegacyClient extends BaseServiceClient {
                 /**
                  * Get specific tag details
                  * @description Retrieve details of a specific inventory tag
+                 * @fullPath api.legacy.invMast.tags.get
+                 * @service legacy
+                 * @domain inventory-metadata
+                 * @dataMethod getTagData
+                 * @discoverable true
+                 * @searchTerms ["tag details", "inventory tag", "metadata"]
+                 * @relatedEndpoints ["items.attributes.get"]
+                 * @commonPatterns ["tag lookup", "metadata retrieval"]
                  * @param invMastUid Inventory master unique identifier
                  * @param invMastTagsUid Tag unique identifier
                  * @returns Complete tag object
@@ -205,7 +184,7 @@ export class LegacyClient extends BaseServiceClient {
                  * @example
                  * ```typescript
                  * const tag = await client.invMast.tags.get(12345, 67890);
-                 * console.log(`Tag: ${tag.tag_name} = ${tag.tag_value}`);
+                 * console.log(`Tag: ${tag.data.tag_name} = ${tag.data.tag_value}`);
                  * ```
                  */
                 get: async (invMastUid, invMastTagsUid) => {
@@ -221,6 +200,14 @@ export class LegacyClient extends BaseServiceClient {
                 /**
                  * Create a new tag for an inventory item
                  * @description Add a new tag to an inventory item for categorization or metadata
+                 * @fullPath api.legacy.invMast.tags.create
+                 * @service legacy
+                 * @domain inventory-metadata
+                 * @dataMethod createTagData
+                 * @discoverable true
+                 * @searchTerms ["create tag", "add metadata", "tag inventory"]
+                 * @relatedEndpoints ["items.attributes.create"]
+                 * @commonPatterns ["tag creation", "metadata assignment"]
                  * @param invMastUid Inventory master unique identifier
                  * @param tagData Tag information including name and value
                  * @returns Created tag object with assigned UID
@@ -232,6 +219,7 @@ export class LegacyClient extends BaseServiceClient {
                  *   tag_value: 'true',
                  *   active: 1
                  * });
+                 * console.log('Created tag:', newTag.data.tag_name);
                  * ```
                  */
                 create: async (invMastUid, tagData) => {
@@ -245,6 +233,14 @@ export class LegacyClient extends BaseServiceClient {
                 /**
                  * Update an existing inventory tag
                  * @description Modify tag information for an inventory item
+                 * @fullPath api.legacy.invMast.tags.update
+                 * @service legacy
+                 * @domain inventory-metadata
+                 * @dataMethod updateTagData
+                 * @discoverable true
+                 * @searchTerms ["update tag", "modify metadata", "tag maintenance"]
+                 * @relatedEndpoints ["items.attributes.update"]
+                 * @commonPatterns ["tag updates", "metadata modification"]
                  * @param invMastUid Inventory master unique identifier
                  * @param invMastTagsUid Tag unique identifier
                  * @param tagData Updated tag information
@@ -256,6 +252,7 @@ export class LegacyClient extends BaseServiceClient {
                  *   tag_name: 'Premium Product',
                  *   tag_value: 'true'
                  * });
+                 * console.log('Updated tag:', updatedTag.data.tag_name);
                  * ```
                  */
                 update: async (invMastUid, invMastTagsUid, tagData) => {
@@ -272,6 +269,14 @@ export class LegacyClient extends BaseServiceClient {
                 /**
                  * Delete an inventory tag
                  * @description Remove a tag from an inventory item
+                 * @fullPath api.legacy.invMast.tags.delete
+                 * @service legacy
+                 * @domain inventory-metadata
+                 * @dataMethod deleteTagData
+                 * @discoverable true
+                 * @searchTerms ["delete tag", "remove metadata", "tag cleanup"]
+                 * @relatedEndpoints ["items.attributes.delete"]
+                 * @commonPatterns ["tag removal", "metadata cleanup"]
                  * @param invMastUid Inventory master unique identifier
                  * @param invMastTagsUid Tag unique identifier
                  * @returns Confirmation of deletion
@@ -279,7 +284,7 @@ export class LegacyClient extends BaseServiceClient {
                  * @example
                  * ```typescript
                  * const result = await client.invMast.tags.delete(12345, 67890);
-                 * console.log('Tag deleted:', result.deleted);
+                 * console.log('Tag deleted:', result.data.deleted);
                  * ```
                  */
                 delete: async (invMastUid, invMastTagsUid) => {
@@ -296,18 +301,33 @@ export class LegacyClient extends BaseServiceClient {
             /**
              * Web descriptions management
              * @description CRUD operations for inventory item web descriptions and marketing content
+             * @fullPath api.legacy.invMast.webDesc
+             * @service legacy
+             * @domain content-management
+             * @discoverable true
+             * @searchTerms ["web descriptions", "marketing content", "product descriptions"]
+             * @relatedEndpoints ["items.products", "commerce.products"]
+             * @commonPatterns ["content management", "product descriptions"]
              */
-            webDescriptions: {
+            webDesc: {
                 /**
                  * List web descriptions for an inventory item
                  * @description Retrieve all web descriptions for display on websites and catalogs
+                 * @fullPath api.legacy.invMast.webDesc.list
+                 * @service legacy
+                 * @domain content-management
+                 * @dataMethod listWebDescData
+                 * @discoverable true
+                 * @searchTerms ["list descriptions", "web content", "product content"]
+                 * @relatedEndpoints ["items.products.list", "commerce.products.list"]
+                 * @commonPatterns ["content retrieval", "description listing"]
                  * @param invMastUid Inventory master unique identifier
                  * @returns Array of web description objects
                  * @throws ValidationError When response is malformed
                  * @example
                  * ```typescript
-                 * const descriptions = await client.invMast.webDescriptions.list(12345);
-                 * descriptions.forEach(desc => {
+                 * const descriptions = await client.invMast.webDesc.list(12345);
+                 * descriptions.data.forEach(desc => {
                  *   console.log(`${desc.description_type}: ${desc.description_text}`);
                  * });
                  * ```
@@ -322,14 +342,22 @@ export class LegacyClient extends BaseServiceClient {
                 /**
                  * Get specific web description details
                  * @description Retrieve details of a specific web description
+                 * @fullPath api.legacy.invMast.webDesc.get
+                 * @service legacy
+                 * @domain content-management
+                 * @dataMethod getWebDescData
+                 * @discoverable true
+                 * @searchTerms ["description details", "web content", "product description"]
+                 * @relatedEndpoints ["items.products.get", "commerce.products.get"]
+                 * @commonPatterns ["content retrieval", "description lookup"]
                  * @param invMastUid Inventory master unique identifier
                  * @param invMastWebDescUid Web description unique identifier
                  * @returns Complete web description object
                  * @throws ValidationError When response is malformed
                  * @example
                  * ```typescript
-                 * const desc = await client.invMast.webDescriptions.get(12345, 67890);
-                 * console.log(desc.description_type, desc.description_text);
+                 * const desc = await client.invMast.webDesc.get(12345, 67890);
+                 * console.log(desc.data.description_type, desc.data.description_text);
                  * ```
                  */
                 get: async (invMastUid, invMastWebDescUid) => {
@@ -345,17 +373,26 @@ export class LegacyClient extends BaseServiceClient {
                 /**
                  * Create a new web description
                  * @description Add web description content for an inventory item
+                 * @fullPath api.legacy.invMast.webDesc.create
+                 * @service legacy
+                 * @domain content-management
+                 * @dataMethod createWebDescData
+                 * @discoverable true
+                 * @searchTerms ["create description", "add content", "product content"]
+                 * @relatedEndpoints ["items.products.create", "commerce.products.create"]
+                 * @commonPatterns ["content creation", "description authoring"]
                  * @param invMastUid Inventory master unique identifier
                  * @param descData Web description content and metadata
                  * @returns Created web description object with assigned UID
                  * @throws ValidationError When description data is invalid or response is malformed
                  * @example
                  * ```typescript
-                 * const newDesc = await client.invMast.webDescriptions.create(12345, {
+                 * const newDesc = await client.invMast.webDesc.create(12345, {
                  *   description_type: 'long',
                  *   description_text: 'Detailed product description for web display',
                  *   display_order: 1
                  * });
+                 * console.log('Created description:', newDesc.data.description_type);
                  * ```
                  */
                 create: async (invMastUid, descData) => {
@@ -369,6 +406,14 @@ export class LegacyClient extends BaseServiceClient {
                 /**
                  * Update an existing web description
                  * @description Modify web description content for an inventory item
+                 * @fullPath api.legacy.invMast.webDesc.update
+                 * @service legacy
+                 * @domain content-management
+                 * @dataMethod updateWebDescData
+                 * @discoverable true
+                 * @searchTerms ["update description", "modify content", "content editing"]
+                 * @relatedEndpoints ["items.products.update", "commerce.products.update"]
+                 * @commonPatterns ["content updates", "description editing"]
                  * @param invMastUid Inventory master unique identifier
                  * @param invMastWebDescUid Web description unique identifier
                  * @param descData Updated description information
@@ -376,10 +421,11 @@ export class LegacyClient extends BaseServiceClient {
                  * @throws ValidationError When description data is invalid or response is malformed
                  * @example
                  * ```typescript
-                 * const updatedDesc = await client.invMast.webDescriptions.update(12345, 67890, {
+                 * const updatedDesc = await client.invMast.webDesc.update(12345, 67890, {
                  *   description_text: 'Updated detailed product description',
                  *   display_order: 2
                  * });
+                 * console.log('Updated description:', updatedDesc.data.description_text);
                  * ```
                  */
                 update: async (invMastUid, invMastWebDescUid, descData) => {
@@ -396,14 +442,22 @@ export class LegacyClient extends BaseServiceClient {
                 /**
                  * Delete a web description
                  * @description Remove web description content from an inventory item
+                 * @fullPath api.legacy.invMast.webDesc.delete
+                 * @service legacy
+                 * @domain content-management
+                 * @dataMethod deleteWebDescData
+                 * @discoverable true
+                 * @searchTerms ["delete description", "remove content", "content cleanup"]
+                 * @relatedEndpoints ["items.products.delete", "commerce.products.delete"]
+                 * @commonPatterns ["content removal", "description cleanup"]
                  * @param invMastUid Inventory master unique identifier
                  * @param invMastWebDescUid Web description unique identifier
                  * @returns Confirmation of deletion
                  * @throws ValidationError When response is malformed
                  * @example
                  * ```typescript
-                 * const result = await client.invMast.webDescriptions.delete(12345, 67890);
-                 * console.log('Description deleted:', result.deleted);
+                 * const result = await client.invMast.webDesc.delete(12345, 67890);
+                 * console.log('Description deleted:', result.data.deleted);
                  * ```
                  */
                 delete: async (invMastUid, invMastWebDescUid) => {
@@ -421,18 +475,33 @@ export class LegacyClient extends BaseServiceClient {
         /**
          * Item category operations
          * @description Operations for hierarchical item categorization
+         * @fullPath api.legacy.itemCategory
+         * @service legacy
+         * @domain product-categorization
+         * @discoverable true
+         * @searchTerms ["categories", "item categories", "hierarchy"]
+         * @relatedEndpoints ["items.categories"]
+         * @commonPatterns ["category lookup", "hierarchical navigation"]
          */
         this.itemCategory = {
             /**
              * Get item category details
              * @description Retrieve complete details for a specific item category including hierarchical information
+             * @fullPath api.legacy.itemCategory.get
+             * @service legacy
+             * @domain product-categorization
+             * @dataMethod getItemCategoryData
+             * @discoverable true
+             * @searchTerms ["category details", "item category", "hierarchy"]
+             * @relatedEndpoints ["items.categories.get"]
+             * @commonPatterns ["category lookup", "hierarchical data"]
              * @param itemCategoryUid Item category unique identifier
              * @returns Complete category object with hierarchy details
              * @throws ValidationError When response is malformed
              * @example
              * ```typescript
              * const category = await client.itemCategory.get(12345);
-             * console.log(category.item_category_desc, category.path, category.level);
+             * console.log(category.data.item_category_desc, category.data.path, category.data.level);
              * ```
              */
             get: async (itemCategoryUid) => {
@@ -446,26 +515,199 @@ export class LegacyClient extends BaseServiceClient {
         /**
          * Order management operations
          * @description Operations for order processing and management
+         * @fullPath api.legacy.orders
+         * @service legacy
+         * @domain order-management
+         * @discoverable true
+         * @searchTerms ["orders", "order processing", "reset"]
+         * @relatedEndpoints ["orders", "customers.orders"]
+         * @commonPatterns ["order processing", "order management"]
          */
         this.orders = {
             /**
-             * Reset order for reprocessing
-             * @description Reset an order by ID for reprocessing (can use web_orders_uid or web_reference_no)
-             * @param orderId Order identifier (web_orders_uid or web_reference_no)
-             * @returns Order reset confirmation with processing status
-             * @throws ValidationError When response is malformed
-             * @example
-             * ```typescript
-             * const resetResult = await client.orders.reset(12345);
-             * console.log(resetResult.reset_status, resetResult.message);
-             * ```
+             * Order reset operations
+             * @description Reset orders for reprocessing
              */
-            reset: async (orderId) => {
-                return this.executeRequest({
-                    method: 'GET',
-                    path: '/orders/{id}/reset',
-                    responseSchema: OrderResetApiResponseSchema,
-                }, undefined, { id: String(orderId) });
+            reset: {
+                /**
+                 * Reset order for reprocessing
+                 * @description Reset an order by ID for reprocessing (can use web_orders_uid or web_reference_no)
+                 * @fullPath api.legacy.orders.reset.get
+                 * @service legacy
+                 * @domain order-management
+                 * @dataMethod resetOrderData
+                 * @discoverable true
+                 * @searchTerms ["reset order", "reprocess order", "order retry"]
+                 * @relatedEndpoints ["orders.orders.update", "customers.orders.update"]
+                 * @commonPatterns ["order reprocessing", "failed order retry"]
+                 * @param orderId Order identifier (web_orders_uid or web_reference_no)
+                 * @returns Order reset confirmation with processing status
+                 * @throws ValidationError When response is malformed
+                 * @example
+                 * ```typescript
+                 * const resetResult = await client.orders.reset.get(12345);
+                 * console.log(resetResult.data.reset_status, resetResult.data.message);
+                 * ```
+                 */
+                get: async (orderId) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/orders/{id}/reset',
+                        responseSchema: OrderResetApiResponseSchema,
+                    }, undefined, { id: String(orderId) });
+                },
+            },
+        };
+        /**
+         * Legacy namespace operations
+         * @description Operations under the /legacy path prefix
+         */
+        this.legacy = {
+            /**
+             * State management endpoints
+             * @description CRUD operations for US states and provinces with tax information
+             * @fullPath api.legacy.legacy.state
+             * @service legacy
+             * @domain geographic-data
+             * @discoverable true
+             * @searchTerms ["states", "provinces", "tax", "geographic"]
+             * @relatedEndpoints ["customers.addresses"]
+             * @commonPatterns ["state lookup", "tax calculation"]
+             */
+            state: {
+                /**
+                 * List states with optional filtering and pagination
+                 * @description Retrieve a paginated list of states with optional filtering by two-letter code
+                 * @fullPath api.legacy.legacy.state.list
+                 * @service legacy
+                 * @domain geographic-data
+                 * @dataMethod listStatesData
+                 * @discoverable true
+                 * @searchTerms ["list states", "provinces", "tax rates"]
+                 * @relatedEndpoints ["customers.addresses.list"]
+                 * @commonPatterns ["geographic lookup", "tax calculation setup"]
+                 * @param params Optional filtering and pagination parameters
+                 * @returns Paginated list of state objects with tax information
+                 * @throws ValidationError When parameters are invalid or response is malformed
+                 * @example
+                 * ```typescript
+                 * // List all states
+                 * const allStates = await client.legacy.state.list();
+                 *
+                 * // Filter by state code
+                 * const californiaStates = await client.legacy.state.list({
+                 *   twoLetterCode: 'CA',
+                 *   limit: 10
+                 * });
+                 *
+                 * // Paginated results
+                 * const statesPage = await client.legacy.state.list({
+                 *   limit: 25,
+                 *   offset: 50
+                 * });
+                 * ```
+                 */
+                list: this.createListMethod('/legacy/state', StateListParamsSchema, StateListResponseSchema),
+                /**
+                 * Get state details by UID
+                 * @description Retrieve complete details for a specific state including tax information
+                 * @fullPath api.legacy.legacy.state.get
+                 * @service legacy
+                 * @domain geographic-data
+                 * @dataMethod getStateData
+                 * @discoverable true
+                 * @searchTerms ["state details", "tax information", "state lookup"]
+                 * @relatedEndpoints ["customers.addresses.get"]
+                 * @commonPatterns ["state lookup by ID", "tax rate retrieval"]
+                 * @param stateUid State unique identifier
+                 * @param params Optional query parameters
+                 * @returns Complete state object with tax and administrative information
+                 * @throws ValidationError When parameters are invalid or response is malformed
+                 * @example
+                 * ```typescript
+                 * // Get state by UID
+                 * const state = await client.legacy.state.get(1);
+                 * console.log(state.data.state_name, state.data.tax_rate);
+                 *
+                 * // Get with additional filtering
+                 * const state = await client.legacy.state.get(1, { twoLetterCode: 'CA' });
+                 * ```
+                 */
+                get: this.createGetMethod('/legacy/state/{id}', StateResponseSchema, StateGetParamsSchema),
+                /**
+                 * Create a new state record
+                 * @description Add a new state or province to the system with tax configuration
+                 * @fullPath api.legacy.legacy.state.create
+                 * @service legacy
+                 * @domain geographic-data
+                 * @dataMethod createStateData
+                 * @discoverable true
+                 * @searchTerms ["create state", "add province", "tax setup"]
+                 * @relatedEndpoints ["customers.addresses.create"]
+                 * @commonPatterns ["state creation", "tax configuration"]
+                 * @param stateData State information including name, code, and tax settings
+                 * @returns Created state object with assigned state_uid
+                 * @throws ValidationError When state data is invalid or response is malformed
+                 * @example
+                 * ```typescript
+                 * const newState = await client.legacy.state.create({
+                 *   country_uid: 1,
+                 *   two_letter_code: 'TX',
+                 *   state_name: 'Texas',
+                 *   tax_rate: 0.0625,
+                 *   active: 1,
+                 *   tax_shipping: 0
+                 * });
+                 * console.log('Created state with UID:', newState.data.state_uid);
+                 * ```
+                 */
+                create: this.createCreateMethod('/legacy/state', CreateStateRequestSchema, StateResponseSchema),
+                /**
+                 * Update an existing state record
+                 * @description Modify state information including tax rates and administrative details
+                 * @fullPath api.legacy.legacy.state.update
+                 * @service legacy
+                 * @domain geographic-data
+                 * @dataMethod updateStateData
+                 * @discoverable true
+                 * @searchTerms ["update state", "modify tax", "state maintenance"]
+                 * @relatedEndpoints ["customers.addresses.update"]
+                 * @commonPatterns ["tax rate updates", "state maintenance"]
+                 * @param stateUid State unique identifier
+                 * @param stateData Updated state information (partial updates supported)
+                 * @returns Updated state object
+                 * @throws ValidationError When state data is invalid or response is malformed
+                 * @example
+                 * ```typescript
+                 * const updatedState = await client.legacy.state.update(1, {
+                 *   state_name: 'California Updated',
+                 *   tax_rate: 0.0925,
+                 *   active: 1
+                 * });
+                 * ```
+                 */
+                update: this.createUpdateMethod('/legacy/state/{id}', UpdateStateRequestSchema, StateResponseSchema),
+                /**
+                 * Delete a state record
+                 * @description Remove a state from the system (use with caution)
+                 * @fullPath api.legacy.legacy.state.delete
+                 * @service legacy
+                 * @domain geographic-data
+                 * @dataMethod deleteStateData
+                 * @discoverable true
+                 * @searchTerms ["delete state", "remove state", "state cleanup"]
+                 * @relatedEndpoints ["customers.addresses.delete"]
+                 * @commonPatterns ["state removal", "data cleanup"]
+                 * @param stateUid State unique identifier
+                 * @returns Confirmation of deletion
+                 * @throws ValidationError When response is malformed
+                 * @example
+                 * ```typescript
+                 * const result = await client.legacy.state.delete(1);
+                 * console.log('State deleted:', result.data.deleted);
+                 * ```
+                 */
+                delete: this.createDeleteMethod('/legacy/state/{id}', DeleteResponseSchema),
             },
         };
     }