@simpleapps-com/augur-api 0.3.3 → 0.4.1

package/dist/cjs/services/smarty-streets/client.js

@@ -16,260 +16,283 @@ const schemas_1 = require("./schemas");
 class SmartyStreetsClient extends base_client_1.BaseServiceClient {
     constructor(http, baseUrl) {
         super('smarty-streets', http, baseUrl || 'https://smarty-streets.augur-api.com');
+        /**
+         * Health check operations for /health-check endpoint
+         * Following OpenAPI Path Mirroring Pattern
+         */
+        this.healthCheck = {
+            /**
+             * Check SmartyStreets service health and API connectivity
+             *
+             * @fullPath api.smartyStreets.healthCheck.get
+             * @service smarty-streets
+             * @domain system-health
+             * @dataMethod healthCheck.getData
+             * @discoverable true
+             * @searchTerms ["health", "status", "availability", "ping", "check", "address service", "smartystreets connectivity", "validation service"]
+             * @relatedEndpoints ["api.smartyStreets.ping.get", "api.smartyStreets.us.lookup.get", "api.customers.addresses.validate", "api.logistics.healthCheck.get", "api.shipping.healthCheck.get"]
+             * @commonPatterns ["Health check", "Service status", "Address service availability", "System monitoring", "API connectivity test"]
+             * @workflow ["system-monitoring", "health-checks", "service-discovery", "address-validation-setup", "api-status-verification"]
+             * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header", "SmartyStreets API connectivity"]
+             * @nextSteps ["Use address validation endpoints if healthy", "Verify SmartyStreets API credits", "Monitor service metrics"]
+             * @businessRules ["Returns service and API status", "Requires standard authentication", "Standard health check format", "Reports API credit status"]
+             * @functionalArea "system-monitoring"
+             * @caching "No caching - real-time status required"
+             * @performance "Fast response, minimal processing, use for address service monitoring"
+             *
+             * @param params Health check parameters with site ID
+             * @returns Promise<HealthCheckResponse> Service health status with SmartyStreets API connectivity
+             *
+             * @example
+             * ```typescript
+             * // Check if SmartyStreets service is healthy
+             * const response = await client.healthCheck.get({ 'x-site-id': 'SITE123' });
+             * console.log(response.data.status); // 'healthy'
+             * console.log(response.data.service); // 'smarty-streets'
+             * console.log(response.data.smartystreets_connectivity); // true
+             * console.log(response.status); // HTTP status code
+             *
+             * // Get just the health status
+             * const status = await client.healthCheck.getData({ 'x-site-id': 'SITE123' });
+             * console.log(status); // Health data object
+             * ```
+             */
+            get: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/health-check',
+                    paramsSchema: schemas_1.HealthCheckParamsSchema,
+                    responseSchema: schemas_1.HealthCheckResponseSchema,
+                }, params);
+            },
+            /**
+             * Get SmartyStreets service health data without full response metadata
+             *
+             * @fullPath api.smartyStreets.healthCheck.getData
+             * @service smarty-streets
+             * @domain system-health
+             * @dataMethod healthCheck.getData
+             * @discoverable true
+             * @searchTerms ["health data", "service status", "smartystreets availability", "api connectivity"]
+             * @relatedEndpoints ["api.smartyStreets.healthCheck.get", "api.smartyStreets.us.lookup.get"]
+             * @commonPatterns ["Get health status", "Check API connectivity", "Service monitoring"]
+             * @workflow ["system-monitoring", "health-checks", "service-verification"]
+             * @prerequisites ["Valid authentication token", "x-site-id header"]
+             * @nextSteps ["Use address validation endpoints if healthy", "Monitor service metrics"]
+             * @businessRules ["Returns only health data object", "No response metadata included"]
+             * @functionalArea "system-monitoring"
+             * @caching "No caching - real-time status required"
+             * @performance "Direct data access, faster for simple health checks"
+             *
+             * @param params Health check parameters with site ID
+             * @returns Promise<HealthCheckData> Direct health status data object
+             */
+            getData: async (params) => {
+                const response = await this.healthCheck.get(params);
+                return response.data;
+            },
+        };
+        /**
+         * Ping operations for /ping endpoint
+         * Following OpenAPI Path Mirroring Pattern
+         */
+        this.ping = {
+            /**
+             * Ping SmartyStreets service for connectivity verification
+             *
+             * @fullPath api.smartyStreets.ping.get
+             * @service smarty-streets
+             * @domain system-health
+             * @dataMethod ping.getData
+             * @discoverable true
+             * @searchTerms ["ping", "connectivity", "response time", "pong", "test", "smartystreets ping", "service alive", "latency check"]
+             * @relatedEndpoints ["api.smartyStreets.healthCheck.get", "api.smartyStreets.us.lookup.get", "api.customers.addresses.ping", "api.logistics.ping.get"]
+             * @commonPatterns ["Ping test", "Connectivity check", "Response time test", "Service alive check", "Latency monitoring"]
+             * @workflow ["system-monitoring", "connectivity-tests", "performance-monitoring", "service-diagnostics", "latency-measurement"]
+             * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header", "Network connectivity"]
+             * @nextSteps ["Use for latency monitoring", "Verify consistent response times", "Include in system health dashboards"]
+             * @businessRules ["Returns pong response", "Measures response time", "Requires standard authentication", "Simple connectivity test"]
+             * @functionalArea "system-monitoring"
+             * @caching "No caching - real-time ping test required"
+             * @performance "Ultra-fast response, use for latency monitoring and connectivity verification"
+             *
+             * @param params Ping parameters with site ID
+             * @returns Promise<PingResponse> Ping response with timing information
+             *
+             * @example
+             * ```typescript
+             * // Test service connectivity
+             * const response = await client.ping.get({ 'x-site-id': 'SITE123' });
+             * console.log(response.data.message); // 'pong'
+             * console.log(response.data.response_time_ms); // Response time
+             * console.log(response.status); // HTTP status code
+             *
+             * // Get just the ping data
+             * const pingData = await client.ping.getData({ 'x-site-id': 'SITE123' });
+             * console.log(pingData); // Ping data object
+             * ```
+             */
+            get: async (params) => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/ping',
+                    paramsSchema: schemas_1.PingParamsSchema,
+                    responseSchema: schemas_1.PingResponseSchema,
+                }, params);
+            },
+            /**
+             * Get SmartyStreets ping data without full response metadata
+             *
+             * @fullPath api.smartyStreets.ping.getData
+             * @service smarty-streets
+             * @domain system-health
+             * @dataMethod ping.getData
+             * @discoverable true
+             * @searchTerms ["ping data", "connectivity test", "response time", "service latency"]
+             * @relatedEndpoints ["api.smartyStreets.ping.get", "api.smartyStreets.healthCheck.get"]
+             * @commonPatterns ["Get ping response", "Check connectivity", "Measure latency"]
+             * @workflow ["system-monitoring", "connectivity-tests", "performance-monitoring"]
+             * @prerequisites ["Valid authentication token", "x-site-id header"]
+             * @nextSteps ["Use for latency monitoring", "Include in performance dashboards"]
+             * @businessRules ["Returns only ping data object", "No response metadata included"]
+             * @functionalArea "system-monitoring"
+             * @caching "No caching - real-time ping test required"
+             * @performance "Direct data access, optimal for latency monitoring"
+             *
+             * @param params Ping parameters with site ID
+             * @returns Promise<PingData> Direct ping response data object
+             */
+            getData: async (params) => {
+                const response = await this.ping.get(params);
+                return response.data;
+            },
+        };
+        /**
+         * US operations for /us/* endpoints
+         * Following OpenAPI Path Mirroring Pattern
+         */
+        this.us = {
+            /**
+             * Lookup operations for /us/lookup endpoint
+             * Following OpenAPI Path Mirroring Pattern
+             */
+            lookup: {
+                /**
+                 * Validate and standardize US addresses using SmartyStreets API
+                 *
+                 * @fullPath api.smartyStreets.us.lookup.get
+                 * @service smarty-streets
+                 * @domain address-validation-and-geocoding
+                 * @dataMethod us.lookup.getData
+                 * @discoverable true
+                 * @searchTerms ["address validation", "us addresses", "standardize", "verify", "lookup", "postal", "zip code", "street address", "delivery", "dpv", "geocoding"]
+                 * @relatedEndpoints ["api.customers.addresses.create", "api.customers.addresses.validate", "api.shipping.rates.calculate", "api.commerce.checkout.validateAddress", "api.logistics.addresses.verify"]
+                 * @commonPatterns ["Validate customer address", "Standardize shipping address", "Verify delivery address", "Clean address data", "Geocode address", "Check address deliverability"]
+                 * @workflow ["address-validation", "customer-onboarding", "checkout-process", "shipping-calculation", "data-quality", "address-standardization", "geocoding-workflow"]
+                 * @prerequisites ["Valid US address components", "Valid authentication token", "x-site-id header", "SmartyStreets API access", "Sufficient API credits"]
+                 * @nextSteps ["Use standardized address for shipping", "Store validated address", "Calculate shipping rates", "Update customer record", "Process geocoding data"]
+                 * @businessRules ["US addresses only", "Requires complete address components", "Returns standardized USPS format", "Validates deliverability", "Provides geocoding data", "Consumes API credits"]
+                 * @functionalArea "address-validation-and-geocoding"
+                 * @crossSite "Supports multi-site address validation with different API configurations"
+                 * @caching "Cache validated addresses for 30 days, invalidate on address changes"
+                 * @performance "Batch requests for multiple addresses, implement retry logic for API limits, monitor credit usage"
+                 *
+                 * @param params Complete US address components for validation
+                 * @returns Promise<UsLookupResponse> Standardized address with validation results and geocoding data
+                 *
+                 * @example
+                 * ```typescript
+                 * // Validate and standardize a customer address
+                 * const addressRequest = {
+                 *   address1: '1234 Example Street',
+                 *   address2: 'Apt 5B',
+                 *   city: 'Provo',
+                 *   state: 'UT',
+                 *   postalCode: '84606',
+                 *   'x-site-id': 'SITE123'
+                 * };
+                 *
+                 * const response = await client.us.lookup.get(addressRequest);
+                 * console.log(response.data.candidates); // Array of standardized addresses
+                 * console.log(response.data.valid_candidates); // Number of valid addresses
+                 * console.log(response.status); // HTTP status code
+                 *
+                 * // Get just the validation data
+                 * const validationResult = await client.us.lookup.getData(addressRequest);
+                 * console.log(validationResult); // Direct validation results
+                 *
+                 * // Validate shipping address for e-commerce
+                 * const shippingAddress = await client.us.lookup.get({
+                 *   address1: '123 Main Street',
+                 *   city: 'New York',
+                 *   state: 'NY',
+                 *   postalCode: '10001',
+                 *   'x-site-id': 'ECOMMERCE-SITE'
+                 * });
+                 *
+                 * // Check if address is deliverable
+                 * const standardized = shippingAddress.data.candidates[0];
+                 * if (standardized?.analysis?.dpv_match_y) {
+                 *   console.log('Address is deliverable');
+                 *   console.log('Standardized:', standardized.delivery_line_1);
+                 *   console.log('ZIP+4:', standardized.zipcode + '-' + standardized.plus4_code);
+                 * }
+                 *
+                 * // Extract geocoding data
+                 * if (standardized?.metadata) {
+                 *   console.log('County:', standardized.metadata.county_name);
+                 *   console.log('Time Zone:', standardized.metadata.time_zone);
+                 *   console.log('Carrier Route:', standardized.metadata.carrier_route);
+                 * }
+                 *
+                 * // Handle validation errors
+                 * if (shippingAddress.data.valid_candidates === 0) {
+                 *   console.log('Invalid address - requires correction');
+                 * } else if (shippingAddress.data.ambiguous_candidates > 0) {
+                 *   console.log('Multiple matches found - user selection required');
+                 * }
+                 * ```
+                 */
+                get: async (params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/us/lookup',
+                        paramsSchema: schemas_1.UsLookupParamsSchema,
+                        responseSchema: schemas_1.UsLookupResponseSchema,
+                    }, params);
+                },
+                /**
+                 * Get US address validation data without full response metadata
+                 *
+                 * @fullPath api.smartyStreets.us.lookup.getData
+                 * @service smarty-streets
+                 * @domain address-validation-and-geocoding
+                 * @dataMethod us.lookup.getData
+                 * @discoverable true
+                 * @searchTerms ["address data", "validation results", "standardized address", "geocoding data", "dpv results"]
+                 * @relatedEndpoints ["api.smartyStreets.us.lookup.get", "api.customers.addresses.create", "api.shipping.rates.calculate"]
+                 * @commonPatterns ["Get address validation results", "Extract standardized address", "Process geocoding data"]
+                 * @workflow ["address-validation", "customer-onboarding", "checkout-process", "shipping-calculation"]
+                 * @prerequisites ["Valid US address components", "Valid authentication token", "SmartyStreets API access"]
+                 * @nextSteps ["Use standardized address", "Store validation results", "Calculate shipping rates"]
+                 * @businessRules ["Returns only address validation data", "No response metadata included", "Direct access to candidates array"]
+                 * @functionalArea "address-validation-and-geocoding"
+                 * @caching "Cache validation results for 30 days"
+                 * @performance "Direct data access, optimal for address processing and validation workflows"
+                 *
+                 * @param params Complete US address components for validation
+                 * @returns Promise<UsLookupData> Direct address validation results without response wrapper
+                 */
+                getData: async (params) => {
+                    const response = await this.us.lookup.get(params);
+                    return response.data;
+                },
+            },
+        };
     }
     getServiceDescription() {
         return 'SmartyStreets address validation service for US address standardization and geocoding';
     }
-    /**
-     * Check SmartyStreets service health and API connectivity
-     *
-     * @fullPath api.smartyStreets.healthCheck.get
-     * @service smarty-streets
-     * @domain system-health
-     * @dataMethod healthCheckData
-     * @discoverable true
-     * @searchTerms ["health", "status", "availability", "ping", "check", "address service", "smartystreets connectivity", "validation service"]
-     * @relatedEndpoints ["api.smartyStreets.ping.get", "api.smartyStreets.us.lookup", "api.customers.addresses.validate", "api.logistics.healthCheck.get", "api.shipping.healthCheck.get"]
-     * @commonPatterns ["Health check", "Service status", "Address service availability", "System monitoring", "API connectivity test"]
-     * @workflow ["system-monitoring", "health-checks", "service-discovery", "address-validation-setup", "api-status-verification"]
-     * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header", "SmartyStreets API connectivity"]
-     * @nextSteps ["Use address validation endpoints if healthy", "Verify SmartyStreets API credits", "Monitor service metrics"]
-     * @businessRules ["Returns service and API status", "Requires standard authentication", "Standard health check format", "Reports API credit status"]
-     * @functionalArea "system-monitoring"
-     * @caching "No caching - real-time status required"
-     * @performance "Fast response, minimal processing, use for address service monitoring"
-     *
-     * @param params Health check parameters with site ID
-     * @returns Promise<HealthCheckResponse> Service health status with SmartyStreets API connectivity
-     *
-     * @example
-     * ```typescript
-     * // Check if SmartyStreets service is healthy
-     * const response = await client.healthCheck({ 'x-site-id': 'SITE123' });
-     * console.log(response.data.status); // 'healthy'
-     * console.log(response.data.service); // 'smarty-streets'
-     * console.log(response.data.smartystreets_connectivity); // true
-     * console.log(response.status); // HTTP status code
-     *
-     * // Get just the health status
-     * const status = await client.healthCheckData({ 'x-site-id': 'SITE123' });
-     * console.log(status); // Health data object
-     * ```
-     */
-    async healthCheck(params) {
-        return this.executeRequest({
-            method: 'GET',
-            path: '/health-check',
-            paramsSchema: schemas_1.HealthCheckParamsSchema,
-            responseSchema: schemas_1.HealthCheckResponseSchema,
-        }, params);
-    }
-    /**
-     * Ping SmartyStreets service for connectivity verification
-     *
-     * @fullPath api.smartyStreets.ping.get
-     * @service smarty-streets
-     * @domain system-health
-     * @dataMethod pingData
-     * @discoverable true
-     * @searchTerms ["ping", "connectivity", "response time", "pong", "test", "smartystreets ping", "service alive", "latency check"]
-     * @relatedEndpoints ["api.smartyStreets.healthCheck.get", "api.smartyStreets.us.lookup", "api.customers.addresses.ping", "api.logistics.ping.get"]
-     * @commonPatterns ["Ping test", "Connectivity check", "Response time test", "Service alive check", "Latency monitoring"]
-     * @workflow ["system-monitoring", "connectivity-tests", "performance-monitoring", "service-diagnostics", "latency-measurement"]
-     * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header", "Network connectivity"]
-     * @nextSteps ["Use for latency monitoring", "Verify consistent response times", "Include in system health dashboards"]
-     * @businessRules ["Returns pong response", "Measures response time", "Requires standard authentication", "Simple connectivity test"]
-     * @functionalArea "system-monitoring"
-     * @caching "No caching - real-time ping test required"
-     * @performance "Ultra-fast response, use for latency monitoring and connectivity verification"
-     *
-     * @param params Ping parameters with site ID
-     * @returns Promise<PingResponse> Ping response with timing information
-     *
-     * @example
-     * ```typescript
-     * // Test service connectivity
-     * const response = await client.ping({ 'x-site-id': 'SITE123' });
-     * console.log(response.data.message); // 'pong'
-     * console.log(response.data.response_time_ms); // Response time
-     * console.log(response.status); // HTTP status code
-     *
-     * // Get just the ping data
-     * const pingData = await client.pingData({ 'x-site-id': 'SITE123' });
-     * console.log(pingData); // Ping data object
-     * ```
-     */
-    async ping(params) {
-        return this.executeRequest({
-            method: 'GET',
-            path: '/ping',
-            paramsSchema: schemas_1.PingParamsSchema,
-            responseSchema: schemas_1.PingResponseSchema,
-        }, params);
-    }
-    /**
-     * Validate and standardize US addresses using SmartyStreets API
-     *
-     * @fullPath api.smartyStreets.us.lookup
-     * @service smarty-streets
-     * @domain address-validation-and-geocoding
-     * @dataMethod usLookupData
-     * @discoverable true
-     * @searchTerms ["address validation", "us addresses", "standardize", "verify", "lookup", "postal", "zip code", "street address", "delivery", "dpv", "geocoding"]
-     * @relatedEndpoints ["api.customers.addresses.create", "api.customers.addresses.validate", "api.shipping.rates.calculate", "api.commerce.checkout.validateAddress", "api.logistics.addresses.verify"]
-     * @commonPatterns ["Validate customer address", "Standardize shipping address", "Verify delivery address", "Clean address data", "Geocode address", "Check address deliverability"]
-     * @workflow ["address-validation", "customer-onboarding", "checkout-process", "shipping-calculation", "data-quality", "address-standardization", "geocoding-workflow"]
-     * @prerequisites ["Valid US address components", "Valid authentication token", "x-site-id header", "SmartyStreets API access", "Sufficient API credits"]
-     * @nextSteps ["Use standardized address for shipping", "Store validated address", "Calculate shipping rates", "Update customer record", "Process geocoding data"]
-     * @businessRules ["US addresses only", "Requires complete address components", "Returns standardized USPS format", "Validates deliverability", "Provides geocoding data", "Consumes API credits"]
-     * @functionalArea "address-validation-and-geocoding"
-     * @crossSite "Supports multi-site address validation with different API configurations"
-     * @caching "Cache validated addresses for 30 days, invalidate on address changes"
-     * @performance "Batch requests for multiple addresses, implement retry logic for API limits, monitor credit usage"
-     *
-     * @param params Complete US address components for validation
-     * @returns Promise<USLookupResponse> Standardized address with validation results and geocoding data
-     *
-     * @example
-     * ```typescript
-     * // Validate and standardize a customer address
-     * const addressRequest = {
-     *   address1: '1234 Example Street',
-     *   address2: 'Apt 5B',
-     *   city: 'Provo',
-     *   state: 'UT',
-     *   postalCode: '84606',
-     *   'x-site-id': 'SITE123'
-     * };
-     *
-     * const response = await client.usLookup(addressRequest);
-     * console.log(response.data.candidates); // Array of standardized addresses
-     * console.log(response.data.valid_candidates); // Number of valid addresses
-     * console.log(response.status); // HTTP status code
-     *
-     * // Get just the validation data
-     * const validationResult = await client.usLookupData(addressRequest);
-     * console.log(validationResult); // Direct validation results
-     *
-     * // Validate shipping address for e-commerce
-     * const shippingAddress = await client.usLookup({
-     *   address1: '123 Main Street',
-     *   city: 'New York',
-     *   state: 'NY',
-     *   postalCode: '10001',
-     *   'x-site-id': 'ECOMMERCE-SITE'
-     * });
-     *
-     * // Check if address is deliverable
-     * const standardized = shippingAddress.data.candidates[0];
-     * if (standardized?.analysis?.dpv_match_y) {
-     *   console.log('Address is deliverable');
-     *   console.log('Standardized:', standardized.delivery_line_1);
-     *   console.log('ZIP+4:', standardized.zipcode + '-' + standardized.plus4_code);
-     * }
-     *
-     * // Extract geocoding data
-     * if (standardized?.metadata) {
-     *   console.log('County:', standardized.metadata.county_name);
-     *   console.log('Time Zone:', standardized.metadata.time_zone);
-     *   console.log('Carrier Route:', standardized.metadata.carrier_route);
-     * }
-     *
-     * // Handle validation errors
-     * if (shippingAddress.data.valid_candidates === 0) {
-     *   console.log('Invalid address - requires correction');
-     * } else if (shippingAddress.data.ambiguous_candidates > 0) {
-     *   console.log('Multiple matches found - user selection required');
-     * }
-     * ```
-     */
-    async usLookup(params) {
-        return this.executeRequest({
-            method: 'GET',
-            path: '/us/lookup',
-            paramsSchema: schemas_1.USLookupParamsSchema,
-            responseSchema: schemas_1.USLookupResponseSchema,
-        }, params);
-    }
-    // Data methods - return data portion only for convenience
-    /**
-     * Get SmartyStreets service health data without full response metadata
-     *
-     * @fullPath api.smartyStreets.healthCheckData.get
-     * @service smarty-streets
-     * @domain system-health
-     * @dataMethod healthCheckData
-     * @discoverable true
-     * @searchTerms ["health data", "service status", "smartystreets availability", "api connectivity"]
-     * @relatedEndpoints ["api.smartyStreets.healthCheck.get", "api.smartyStreets.us.lookup"]
-     * @commonPatterns ["Get health status", "Check API connectivity", "Service monitoring"]
-     * @workflow ["system-monitoring", "health-checks", "service-verification"]
-     * @prerequisites ["Valid authentication token", "x-site-id header"]
-     * @nextSteps ["Use address validation endpoints if healthy", "Monitor service metrics"]
-     * @businessRules ["Returns only health data object", "No response metadata included"]
-     * @functionalArea "system-monitoring"
-     * @caching "No caching - real-time status required"
-     * @performance "Direct data access, faster for simple health checks"
-     *
-     * @param params Health check parameters with site ID
-     * @returns Promise<HealthCheckData> Direct health status data object
-     */
-    async healthCheckData(params) {
-        const response = await this.healthCheck(params);
-        return response.data;
-    }
-    /**
-     * Get SmartyStreets ping data without full response metadata
-     *
-     * @fullPath api.smartyStreets.pingData.get
-     * @service smarty-streets
-     * @domain system-health
-     * @dataMethod pingData
-     * @discoverable true
-     * @searchTerms ["ping data", "connectivity test", "response time", "service latency"]
-     * @relatedEndpoints ["api.smartyStreets.ping.get", "api.smartyStreets.healthCheck.get"]
-     * @commonPatterns ["Get ping response", "Check connectivity", "Measure latency"]
-     * @workflow ["system-monitoring", "connectivity-tests", "performance-monitoring"]
-     * @prerequisites ["Valid authentication token", "x-site-id header"]
-     * @nextSteps ["Use for latency monitoring", "Include in performance dashboards"]
-     * @businessRules ["Returns only ping data object", "No response metadata included"]
-     * @functionalArea "system-monitoring"
-     * @caching "No caching - real-time ping test required"
-     * @performance "Direct data access, optimal for latency monitoring"
-     *
-     * @param params Ping parameters with site ID
-     * @returns Promise<PingData> Direct ping response data object
-     */
-    async pingData(params) {
-        const response = await this.ping(params);
-        return response.data;
-    }
-    /**
-     * Get US address validation data without full response metadata
-     *
-     * @fullPath api.smartyStreets.usLookupData.get
-     * @service smarty-streets
-     * @domain address-validation-and-geocoding
-     * @dataMethod usLookupData
-     * @discoverable true
-     * @searchTerms ["address data", "validation results", "standardized address", "geocoding data", "dpv results"]
-     * @relatedEndpoints ["api.smartyStreets.us.lookup", "api.customers.addresses.create", "api.shipping.rates.calculate"]
-     * @commonPatterns ["Get address validation results", "Extract standardized address", "Process geocoding data"]
-     * @workflow ["address-validation", "customer-onboarding", "checkout-process", "shipping-calculation"]
-     * @prerequisites ["Valid US address components", "Valid authentication token", "SmartyStreets API access"]
-     * @nextSteps ["Use standardized address", "Store validation results", "Calculate shipping rates"]
-     * @businessRules ["Returns only address validation data", "No response metadata included", "Direct access to candidates array"]
-     * @functionalArea "address-validation-and-geocoding"
-     * @caching "Cache validation results for 30 days"
-     * @performance "Direct data access, optimal for address processing and validation workflows"
-     *
-     * @param params Complete US address components for validation
-     * @returns Promise<USLookupData> Direct address validation results without response wrapper
-     */
-    async usLookupData(params) {
-        const response = await this.usLookup(params);
-        return response.data;
-    }
 }
 exports.SmartyStreetsClient = SmartyStreetsClient;
 //# sourceMappingURL=client.js.map

package/dist/cjs/services/smarty-streets/client.js.map

@@ -1 +1 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../src/services/smarty-streets/client.ts"],"names":[],"mappings":";;;AAAA,wDAA2D;AAE3D,uCAgBmB;AAEnB;;;;;;;;;GASG;AACH,MAAa,mBAAoB,SAAQ,+BAAiB;IACxD,YAAY,IAAgB,EAAE,OAAgB;QAC5C,KAAK,CAAC,gBAAgB,EAAE,IAAI,EAAE,OAAO,IAAI,sCAAsC,CAAC,CAAC;IACnF,CAAC;IAES,qBAAqB;QAC7B,OAAO,uFAAuF,CAAC;IACjG,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,KAAK,CAAC,WAAW,CAAC,MAAyB;QACzC,OAAO,IAAI,CAAC,cAAc,CACxB;YACE,MAAM,EAAE,KAAK;YACb,IAAI,EAAE,eAAe;YACrB,YAAY,EAAE,iCAAuB;YACrC,cAAc,EAAE,mCAAyB;SAC1C,EACD,MAAM,CACP,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,KAAK,CAAC,IAAI,CAAC,MAAkB;QAC3B,OAAO,IAAI,CAAC,cAAc,CACxB;YACE,MAAM,EAAE,KAAK;YACb,IAAI,EAAE,OAAO;YACb,YAAY,EAAE,0BAAgB;YAC9B,cAAc,EAAE,4BAAkB;SACnC,EACD,MAAM,CACP,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2EG;IACH,KAAK,CAAC,QAAQ,CAAC,MAAsB;QACnC,OAAO,IAAI,CAAC,cAAc,CACxB;YACE,MAAM,EAAE,KAAK;YACb,IAAI,EAAE,YAAY;YAClB,YAAY,EAAE,8BAAoB;YAClC,cAAc,EAAE,gCAAsB;SACvC,EACD,MAAM,CACP,CAAC;IACJ,CAAC;IAED,0DAA0D;IAE1D;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAK,CAAC,eAAe,CAAC,MAAyB;QAC7C,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAChD,OAAO,QAAQ,CAAC,IAAI,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAK,CAAC,QAAQ,CAAC,MAAkB;QAC/B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACzC,OAAO,QAAQ,CAAC,IAAI,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAK,CAAC,YAAY,CAAC,MAAsB;QACvC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAC7C,OAAO,QAAQ,CAAC,IAAI,CAAC;IACvB,CAAC;CACF;AAlRD,kDAkRC"}
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../src/services/smarty-streets/client.ts"],"names":[],"mappings":";;;AAAA,wDAA2D;AAE3D,uCAgBmB;AAEnB;;;;;;;;;GASG;AACH,MAAa,mBAAoB,SAAQ,+BAAiB;IACxD,YAAY,IAAgB,EAAE,OAAgB;QAC5C,KAAK,CAAC,gBAAgB,EAAE,IAAI,EAAE,OAAO,IAAI,sCAAsC,CAAC,CAAC;QAOnF;;;WAGG;QACa,gBAAW,GAAG;YAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAmCG;YACH,GAAG,EAAE,KAAK,EAAE,MAAyB,EAAgC,EAAE;gBACrE,OAAO,IAAI,CAAC,cAAc,CACxB;oBACE,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,eAAe;oBACrB,YAAY,EAAE,iCAAuB;oBACrC,cAAc,EAAE,mCAAyB;iBAC1C,EACD,MAAM,CACP,CAAC;YACJ,CAAC;YAED;;;;;;;;;;;;;;;;;;;;;eAqBG;YACH,OAAO,EAAE,KAAK,EAAE,MAAyB,EAA4B,EAAE;gBACrE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBACpD,OAAO,QAAQ,CAAC,IAAI,CAAC;YACvB,CAAC;SACF,CAAC;QAEF;;;WAGG;QACa,SAAI,GAAG;YACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAkCG;YACH,GAAG,EAAE,KAAK,EAAE,MAAkB,EAAyB,EAAE;gBACvD,OAAO,IAAI,CAAC,cAAc,CACxB;oBACE,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,OAAO;oBACb,YAAY,EAAE,0BAAgB;oBAC9B,cAAc,EAAE,4BAAkB;iBACnC,EACD,MAAM,CACP,CAAC;YACJ,CAAC;YAED;;;;;;;;;;;;;;;;;;;;;eAqBG;YACH,OAAO,EAAE,KAAK,EAAE,MAAkB,EAAqB,EAAE;gBACvD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBAC7C,OAAO,QAAQ,CAAC,IAAI,CAAC;YACvB,CAAC;SACF,CAAC;QAEF;;;WAGG;QACa,OAAE,GAAG;YACnB;;;eAGG;YACH,MAAM,EAAE;gBACN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA2EG;gBACH,GAAG,EAAE,KAAK,EAAE,MAAsB,EAA6B,EAAE;oBAC/D,OAAO,IAAI,CAAC,cAAc,CACxB;wBACE,MAAM,EAAE,KAAK;wBACb,IAAI,EAAE,YAAY;wBAClB,YAAY,EAAE,8BAAoB;wBAClC,cAAc,EAAE,gCAAsB;qBACvC,EACD,MAAM,CACP,CAAC;gBACJ,CAAC;gBAED;;;;;;;;;;;;;;;;;;;;;mBAqBG;gBACH,OAAO,EAAE,KAAK,EAAE,MAAsB,EAAyB,EAAE;oBAC/D,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;oBAClD,OAAO,QAAQ,CAAC,IAAI,CAAC;gBACvB,CAAC;aACF;SACF,CAAC;IApSF,CAAC;IAES,qBAAqB;QAC7B,OAAO,uFAAuF,CAAC;IACjG,CAAC;CAiSF;AAxSD,kDAwSC"}

package/dist/cjs/services/smarty-streets/index.d.ts

@@ -1,4 +1,4 @@
 export { SmartyStreetsClient } from './client';
-export type { HealthCheckParams, PingParams, USLookupParams, HealthCheckData, PingData, AddressComponent, AddressMetadata, AddressAnalysis, StandardizedAddress, USLookupResult, USLookupData, HealthCheckResponse, PingResponse, USLookupResponse, } from './schemas';
-export { HealthCheckParamsSchema, PingParamsSchema, USLookupParamsSchema, HealthCheckDataSchema, PingDataSchema, AddressComponentSchema, AddressMetadataSchema, AddressAnalysisSchema, StandardizedAddressSchema, USLookupResultSchema, USLookupDataSchema, HealthCheckResponseSchema, PingResponseSchema, USLookupResponseSchema, } from './schemas';
+export type { HealthCheckParams, HealthCheckData, HealthCheckResponse, PingParams, PingData, PingResponse, UsLookupParams, AddressComponent, AddressMetadata, AddressAnalysis, StandardizedAddress, UsLookupResult, UsLookupData, UsLookupResponse, } from './schemas';
+export { HealthCheckParamsSchema, HealthCheckDataSchema, HealthCheckResponseSchema, PingParamsSchema, PingDataSchema, PingResponseSchema, UsLookupParamsSchema, AddressComponentSchema, AddressMetadataSchema, AddressAnalysisSchema, StandardizedAddressSchema, UsLookupResultSchema, UsLookupDataSchema, UsLookupResponseSchema, } from './schemas';
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/services/smarty-streets/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/smarty-streets/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAC/C,YAAY,EACV,iBAAiB,EACjB,UAAU,EACV,cAAc,EACd,eAAe,EACf,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,gBAAgB,GACjB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,cAAc,EACd,sBAAsB,EACtB,qBAAqB,EACrB,qBAAqB,EACrB,yBAAyB,EACzB,oBAAoB,EACpB,kBAAkB,EAClB,yBAAyB,EACzB,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/smarty-streets/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAG/C,YAAY,EACV,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,YAAY,EACZ,gBAAgB,GACjB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACrB,yBAAyB,EACzB,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,sBAAsB,EACtB,qBAAqB,EACrB,qBAAqB,EACrB,yBAAyB,EACzB,oBAAoB,EACpB,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,WAAW,CAAC"}

package/dist/cjs/services/smarty-streets/index.js

@@ -1,22 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.USLookupResponseSchema = exports.PingResponseSchema = exports.HealthCheckResponseSchema = exports.USLookupDataSchema = exports.USLookupResultSchema = exports.StandardizedAddressSchema = exports.AddressAnalysisSchema = exports.AddressMetadataSchema = exports.AddressComponentSchema = exports.PingDataSchema = exports.HealthCheckDataSchema = exports.USLookupParamsSchema = exports.PingParamsSchema = exports.HealthCheckParamsSchema = exports.SmartyStreetsClient = void 0;
-// SmartyStreets Service Exports
+exports.UsLookupResponseSchema = exports.UsLookupDataSchema = exports.UsLookupResultSchema = exports.StandardizedAddressSchema = exports.AddressAnalysisSchema = exports.AddressMetadataSchema = exports.AddressComponentSchema = exports.UsLookupParamsSchema = exports.PingResponseSchema = exports.PingDataSchema = exports.PingParamsSchema = exports.HealthCheckResponseSchema = exports.HealthCheckDataSchema = exports.HealthCheckParamsSchema = exports.SmartyStreetsClient = void 0;
+// SmartyStreets Service Exports - OpenAPI Path Mirroring Pattern Compliant
 var client_1 = require("./client");
 Object.defineProperty(exports, "SmartyStreetsClient", { enumerable: true, get: function () { return client_1.SmartyStreetsClient; } });
 var schemas_1 = require("./schemas");
 Object.defineProperty(exports, "HealthCheckParamsSchema", { enumerable: true, get: function () { return schemas_1.HealthCheckParamsSchema; } });
-Object.defineProperty(exports, "PingParamsSchema", { enumerable: true, get: function () { return schemas_1.PingParamsSchema; } });
-Object.defineProperty(exports, "USLookupParamsSchema", { enumerable: true, get: function () { return schemas_1.USLookupParamsSchema; } });
 Object.defineProperty(exports, "HealthCheckDataSchema", { enumerable: true, get: function () { return schemas_1.HealthCheckDataSchema; } });
+Object.defineProperty(exports, "HealthCheckResponseSchema", { enumerable: true, get: function () { return schemas_1.HealthCheckResponseSchema; } });
+Object.defineProperty(exports, "PingParamsSchema", { enumerable: true, get: function () { return schemas_1.PingParamsSchema; } });
 Object.defineProperty(exports, "PingDataSchema", { enumerable: true, get: function () { return schemas_1.PingDataSchema; } });
+Object.defineProperty(exports, "PingResponseSchema", { enumerable: true, get: function () { return schemas_1.PingResponseSchema; } });
+Object.defineProperty(exports, "UsLookupParamsSchema", { enumerable: true, get: function () { return schemas_1.UsLookupParamsSchema; } });
 Object.defineProperty(exports, "AddressComponentSchema", { enumerable: true, get: function () { return schemas_1.AddressComponentSchema; } });
 Object.defineProperty(exports, "AddressMetadataSchema", { enumerable: true, get: function () { return schemas_1.AddressMetadataSchema; } });
 Object.defineProperty(exports, "AddressAnalysisSchema", { enumerable: true, get: function () { return schemas_1.AddressAnalysisSchema; } });
 Object.defineProperty(exports, "StandardizedAddressSchema", { enumerable: true, get: function () { return schemas_1.StandardizedAddressSchema; } });
-Object.defineProperty(exports, "USLookupResultSchema", { enumerable: true, get: function () { return schemas_1.USLookupResultSchema; } });
-Object.defineProperty(exports, "USLookupDataSchema", { enumerable: true, get: function () { return schemas_1.USLookupDataSchema; } });
-Object.defineProperty(exports, "HealthCheckResponseSchema", { enumerable: true, get: function () { return schemas_1.HealthCheckResponseSchema; } });
-Object.defineProperty(exports, "PingResponseSchema", { enumerable: true, get: function () { return schemas_1.PingResponseSchema; } });
-Object.defineProperty(exports, "USLookupResponseSchema", { enumerable: true, get: function () { return schemas_1.USLookupResponseSchema; } });
+Object.defineProperty(exports, "UsLookupResultSchema", { enumerable: true, get: function () { return schemas_1.UsLookupResultSchema; } });
+Object.defineProperty(exports, "UsLookupDataSchema", { enumerable: true, get: function () { return schemas_1.UsLookupDataSchema; } });
+Object.defineProperty(exports, "UsLookupResponseSchema", { enumerable: true, get: function () { return schemas_1.UsLookupResponseSchema; } });
 //# sourceMappingURL=index.js.map

package/dist/cjs/services/smarty-streets/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/services/smarty-streets/index.ts"],"names":[],"mappings":";;;AAAA,gCAAgC;AAChC,mCAA+C;AAAtC,6GAAA,mBAAmB,OAAA;AAiB5B,qCAemB;AAdjB,kHAAA,uBAAuB,OAAA;AACvB,2GAAA,gBAAgB,OAAA;AAChB,+GAAA,oBAAoB,OAAA;AACpB,gHAAA,qBAAqB,OAAA;AACrB,yGAAA,cAAc,OAAA;AACd,iHAAA,sBAAsB,OAAA;AACtB,gHAAA,qBAAqB,OAAA;AACrB,gHAAA,qBAAqB,OAAA;AACrB,oHAAA,yBAAyB,OAAA;AACzB,+GAAA,oBAAoB,OAAA;AACpB,6GAAA,kBAAkB,OAAA;AAClB,oHAAA,yBAAyB,OAAA;AACzB,6GAAA,kBAAkB,OAAA;AAClB,iHAAA,sBAAsB,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/services/smarty-streets/index.ts"],"names":[],"mappings":";;;AAAA,2EAA2E;AAC3E,mCAA+C;AAAtC,6GAAA,mBAAmB,OAAA;AAoB5B,qCAemB;AAdjB,kHAAA,uBAAuB,OAAA;AACvB,gHAAA,qBAAqB,OAAA;AACrB,oHAAA,yBAAyB,OAAA;AACzB,2GAAA,gBAAgB,OAAA;AAChB,yGAAA,cAAc,OAAA;AACd,6GAAA,kBAAkB,OAAA;AAClB,+GAAA,oBAAoB,OAAA;AACpB,iHAAA,sBAAsB,OAAA;AACtB,gHAAA,qBAAqB,OAAA;AACrB,gHAAA,qBAAqB,OAAA;AACrB,oHAAA,yBAAyB,OAAA;AACzB,+GAAA,oBAAoB,OAAA;AACpB,6GAAA,kBAAkB,OAAA;AAClB,iHAAA,sBAAsB,OAAA"}