@simpleapps-com/augur-api 0.3.2 → 0.4.0

package/dist/types/services/smarty-streets/client.d.ts

@@ -1,6 +1,6 @@
 import { BaseServiceClient } from '../../core/base-client';
 import type { HTTPClient } from '../../core/client';
-import { HealthCheckParams, HealthCheckResponse, PingParams, PingResponse, USLookupParams, USLookupResponse, HealthCheckData, PingData, USLookupData } from './schemas';
+import { HealthCheckParams, HealthCheckResponse, HealthCheckData, PingParams, PingResponse, PingData, UsLookupParams, UsLookupResponse, UsLookupData } from './schemas';
 /**
  * SmartyStreets Address Validation Service Client
  *
@@ -15,223 +15,247 @@ export declare class SmartyStreetsClient extends BaseServiceClient {
     constructor(http: HTTPClient, baseUrl?: string);
     protected getServiceDescription(): string;
     /**
-     * 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
-     * ```
+     * Health check operations for /health-check endpoint
+     * Following OpenAPI Path Mirroring Pattern
      */
-    healthCheck(params: HealthCheckParams): Promise<HealthCheckResponse>;
+    readonly 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: (params: HealthCheckParams) => Promise<HealthCheckResponse>;
+        /**
+         * 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: (params: HealthCheckParams) => Promise<HealthCheckData>;
+    };
     /**
-     * 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
-     * ```
+     * Ping operations for /ping endpoint
+     * Following OpenAPI Path Mirroring Pattern
      */
-    ping(params: PingParams): Promise<PingResponse>;
+    readonly 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: (params: PingParams) => Promise<PingResponse>;
+        /**
+         * 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: (params: PingParams) => Promise<PingData>;
+    };
     /**
-     * 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');
-     * }
-     * ```
+     * US operations for /us/* endpoints
+     * Following OpenAPI Path Mirroring Pattern
      */
-    usLookup(params: USLookupParams): Promise<USLookupResponse>;
-    /**
-     * 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
-     */
-    healthCheckData(params: HealthCheckParams): Promise<HealthCheckData>;
-    /**
-     * 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
-     */
-    pingData(params: PingParams): Promise<PingData>;
-    /**
-     * 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
-     */
-    usLookupData(params: USLookupParams): Promise<USLookupData>;
+    readonly 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: (params: UsLookupParams) => Promise<UsLookupResponse>;
+            /**
+             * 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: (params: UsLookupParams) => Promise<UsLookupData>;
+        };
+    };
 }
 //# sourceMappingURL=client.d.ts.map

package/dist/types/services/smarty-streets/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/services/smarty-streets/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAEL,iBAAiB,EAEjB,mBAAmB,EAEnB,UAAU,EAEV,YAAY,EAEZ,cAAc,EAEd,gBAAgB,EAChB,eAAe,EACf,QAAQ,EACR,YAAY,EACb,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;GASG;AACH,qBAAa,mBAAoB,SAAQ,iBAAiB;gBAC5C,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,MAAM;IAI9C,SAAS,CAAC,qBAAqB,IAAI,MAAM;IAIzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACG,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAY1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACG,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;IAYrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2EG;IACG,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAcjE;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,eAAe,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IAK1E;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC;IAKrD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,YAAY,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC;CAIlE"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/services/smarty-streets/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAEL,iBAAiB,EAEjB,mBAAmB,EACnB,eAAe,EAEf,UAAU,EAEV,YAAY,EACZ,QAAQ,EAER,cAAc,EAEd,gBAAgB,EAChB,YAAY,EACb,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;GASG;AACH,qBAAa,mBAAoB,SAAQ,iBAAiB;gBAC5C,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,MAAM;IAI9C,SAAS,CAAC,qBAAqB,IAAI,MAAM;IAIzC;;;OAGG;IACH,SAAgB,WAAW;QACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAmCG;sBACiB,iBAAiB,KAAG,OAAO,CAAC,mBAAmB,CAAC;QAYpE;;;;;;;;;;;;;;;;;;;;;WAqBG;0BACqB,iBAAiB,KAAG,OAAO,CAAC,eAAe,CAAC;MAIpE;IAEF;;;OAGG;IACH,SAAgB,IAAI;QAClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAkCG;sBACiB,UAAU,KAAG,OAAO,CAAC,YAAY,CAAC;QAYtD;;;;;;;;;;;;;;;;;;;;;WAqBG;0BACqB,UAAU,KAAG,OAAO,CAAC,QAAQ,CAAC;MAItD;IAEF;;;OAGG;IACH,SAAgB,EAAE;QAChB;;;WAGG;;YAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA2EG;0BACiB,cAAc,KAAG,OAAO,CAAC,gBAAgB,CAAC;YAY9D;;;;;;;;;;;;;;;;;;;;;eAqBG;8BACqB,cAAc,KAAG,OAAO,CAAC,YAAY,CAAC;;MAKhE;CACH"}

package/dist/types/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/types/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/types/services/smarty-streets/schemas/healthCheck.d.ts

@@ -0,0 +1,140 @@
+import { z } from 'zod';
+/**
+ * Health check parameters - SmartyStreets service health verification
+ * OpenAPI Path: /health-check
+ */
+export declare const HealthCheckParamsSchema: z.ZodObject<{
+    'x-site-id': z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    'x-site-id': string;
+}, {
+    'x-site-id': string;
+}>;
+/**
+ * Health check response data
+ * SmartyStreets service health status information
+ */
+export declare const HealthCheckDataSchema: z.ZodObject<{
+    status: z.ZodString;
+    service: z.ZodString;
+    timestamp: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    smartystreets_connectivity: z.ZodOptional<z.ZodBoolean>;
+    api_credits_remaining: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: string;
+    service: string;
+    timestamp?: string | undefined;
+    version?: string | undefined;
+    smartystreets_connectivity?: boolean | undefined;
+    api_credits_remaining?: number | undefined;
+}, {
+    status: string;
+    service: string;
+    timestamp?: string | undefined;
+    version?: string | undefined;
+    smartystreets_connectivity?: boolean | undefined;
+    api_credits_remaining?: number | undefined;
+}>;
+/**
+ * Health check response using BaseResponseSchema
+ */
+export declare const HealthCheckResponseSchema: z.ZodEffects<z.ZodObject<{
+    count: z.ZodNumber;
+    data: z.ZodObject<{
+        status: z.ZodString;
+        service: z.ZodString;
+        timestamp: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+        smartystreets_connectivity: z.ZodOptional<z.ZodBoolean>;
+        api_credits_remaining: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        status: string;
+        service: string;
+        timestamp?: string | undefined;
+        version?: string | undefined;
+        smartystreets_connectivity?: boolean | undefined;
+        api_credits_remaining?: number | undefined;
+    }, {
+        status: string;
+        service: string;
+        timestamp?: string | undefined;
+        version?: string | undefined;
+        smartystreets_connectivity?: boolean | undefined;
+        api_credits_remaining?: number | undefined;
+    }>;
+    message: z.ZodString;
+    options: z.ZodUnion<[z.ZodArray<z.ZodUnknown, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    params: z.ZodUnion<[z.ZodArray<z.ZodUnknown, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    status: z.ZodNumber;
+    total: z.ZodNumber;
+    totalResults: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        status: string;
+        service: string;
+        timestamp?: string | undefined;
+        version?: string | undefined;
+        smartystreets_connectivity?: boolean | undefined;
+        api_credits_remaining?: number | undefined;
+    };
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        status: string;
+        service: string;
+        timestamp?: string | undefined;
+        version?: string | undefined;
+        smartystreets_connectivity?: boolean | undefined;
+        api_credits_remaining?: number | undefined;
+    };
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}>, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        status: string;
+        service: string;
+        timestamp?: string | undefined;
+        version?: string | undefined;
+        smartystreets_connectivity?: boolean | undefined;
+        api_credits_remaining?: number | undefined;
+    };
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}, {
+    params: Record<string, unknown> | unknown[];
+    data: {
+        status: string;
+        service: string;
+        timestamp?: string | undefined;
+        version?: string | undefined;
+        smartystreets_connectivity?: boolean | undefined;
+        api_credits_remaining?: number | undefined;
+    };
+    options: Record<string, unknown> | unknown[];
+    status: number;
+    message: string;
+    count: number;
+    total: number;
+    totalResults: number;
+}>;
+export type HealthCheckParams = z.infer<typeof HealthCheckParamsSchema>;
+export type HealthCheckData = z.infer<typeof HealthCheckDataSchema>;
+export type HealthCheckResponse = z.infer<typeof HealthCheckResponseSchema>;
+//# sourceMappingURL=healthCheck.d.ts.map