@simpleapps-com/augur-api 0.3.0 → 0.3.1

package/dist/cjs/services/avalara/client.d.ts

@@ -0,0 +1,337 @@
+import { BaseServiceClient } from '../../core/base-client';
+import type { HTTPClient } from '../../core/client';
+import { RatesRequestParams, TaxCalculationResult } from './schemas';
+/**
+ * Avalara Tax Service Client
+ *
+ * Provides access to Avalara tax calculation endpoints for real-time tax rate
+ * computation and compliance.
+ *
+ * @service avalara
+ * @domain tax-calculation
+ */
+export declare class AvalaraClient extends BaseServiceClient {
+    constructor(http: HTTPClient, baseUrl?: string);
+    protected getServiceDescription(): string;
+    /**
+     * Check service health and availability
+     *
+     * @fullPath api.avalara.healthCheck.get
+     * @service avalara
+     * @domain system-health
+     * @dataMethod healthCheckData
+     * @discoverable true
+     * @searchTerms ["health", "status", "availability", "ping", "check", "tax service"]
+     * @relatedEndpoints ["api.avalara.rates.calculate", "api.agrWork.healthCheck.get", "api.agrInfo.healthCheck.get", "api.commerce.healthCheck.get"]
+     * @commonPatterns ["Health check", "Service status", "Tax service availability", "System monitoring"]
+     * @workflow ["system-monitoring", "health-checks", "service-discovery", "tax-service-verification"]
+     * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header"]
+     * @nextSteps ["Use tax calculation endpoints if healthy", "Verify tax service connectivity", "Monitor service metrics"]
+     * @businessRules ["Returns service status and basic info", "Requires standard authentication", "Standard health check format"]
+     * @functionalArea "system-monitoring"
+     * @caching "No caching - real-time status required"
+     * @performance "Fast response, minimal processing, use for tax service monitoring"
+     *
+     * @returns Promise<HealthCheckResponse> Service health status
+     *
+     * @example
+     * ```typescript
+     * // Check if tax service is healthy
+     * const response = await client.healthCheck();
+     * console.log(response.data); // Health status string
+     * console.log(response.status); // HTTP status code
+     *
+     * // Get just the health status
+     * const status = await client.healthCheckData();
+     * console.log(status); // Direct string access
+     * ```
+     */
+    readonly healthCheck: () => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: string;
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+    /**
+     * Calculate tax rates for transaction lines
+     *
+     * @fullPath api.avalara.rates.calculate
+     * @service avalara
+     * @domain tax-calculation
+     * @dataMethod ratesCalculateData
+     * @discoverable true
+     * @searchTerms ["tax", "rates", "calculate", "avalara", "sales tax", "vat", "compliance", "transaction"]
+     * @relatedEndpoints ["api.commerce.orders.create", "api.commerce.cartHeaders.checkout", "api.items.pricing.calculate", "api.customers.addresses.validate"]
+     * @commonPatterns ["Calculate sales tax", "Get tax rates", "Tax compliance", "E-commerce tax calculation", "Multi-jurisdiction tax"]
+     * @workflow ["e-commerce-checkout", "order-processing", "tax-compliance", "invoice-generation", "financial-reporting"]
+     * @prerequisites ["Valid transaction data", "Public bearer token", "x-site-id header", "Valid addresses", "Product/service lines"]
+     * @nextSteps ["Apply calculated tax to order", "Store tax calculation results", "Generate compliant invoice", "Submit tax returns"]
+     * @businessRules ["Requires valid addresses", "Supports multiple tax jurisdictions", "Real-time calculation", "Compliance with local tax laws", "Handles exemptions and special rates"]
+     * @functionalArea "tax-and-compliance"
+     * @crossSite "Multi-site tax calculation support"
+     * @caching "Cache for 1 hour for identical requests, tax rates change infrequently"
+     * @performance "Optimize by batching multiple line items, use address validation for accuracy"
+     *
+     * @param params Tax calculation request parameters including lines, addresses, and transaction details
+     * @returns Promise<RatesResponse> Complete tax calculation results with rates, amounts, and jurisdiction details
+     *
+     * @example
+     * ```typescript
+     * // Calculate tax for a simple sale
+     * const taxRequest = {
+     *   lines: [{
+     *     amount: 100.00,
+     *     description: 'Widget',
+     *     quantity: 1
+     *   }],
+     *   addresses: {
+     *     shipTo: {
+     *       line1: '123 Main St',
+     *       city: 'Irvine',
+     *       region: 'CA',
+     *       country: 'US',
+     *       postalCode: '92602'
+     *     }
+     *   },
+     *   type: 'SalesOrder',
+     *   date: '2024-01-15',
+     *   companyCode: 'DEFAULT'
+     * };
+     *
+     * const response = await client.ratesCalculate(taxRequest);
+     * console.log(response.data.totalTax); // Total tax amount
+     * console.log(response.data.lines); // Tax details per line
+     *
+     * // Get just the calculation result
+     * const taxResult = await client.ratesCalculateData(taxRequest);
+     * console.log(taxResult.totalTax); // Direct access to tax amount
+     *
+     * // Multi-line transaction with shipping
+     * const complexRequest = {
+     *   lines: [
+     *     { amount: 50.00, description: 'Product A', taxCode: 'P0000000' },
+     *     { amount: 30.00, description: 'Product B', taxCode: 'P0000000' },
+     *     { amount: 10.00, description: 'Shipping', taxCode: 'FR010000' }
+     *   ],
+     *   addresses: {
+     *     shipFrom: {
+     *       line1: '100 Warehouse Blvd',
+     *       city: 'Los Angeles',
+     *       region: 'CA',
+     *       country: 'US',
+     *       postalCode: '90210'
+     *     },
+     *     shipTo: {
+     *       line1: '456 Customer Ave',
+     *       city: 'New York',
+     *       region: 'NY',
+     *       country: 'US',
+     *       postalCode: '10001'
+     *     }
+     *   },
+     *   type: 'SalesInvoice',
+     *   customerCode: 'CUST001',
+     *   commit: true
+     * };
+     *
+     * const complexResult = await client.ratesCalculateData(complexRequest);
+     * ```
+     */
+    readonly ratesCalculate: (data: import("zod").objectInputType<{
+        lines: import("zod").ZodArray<import("zod").ZodObject<{
+            amount: import("zod").ZodNumber;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            taxCode: import("zod").ZodOptional<import("zod").ZodString>;
+            customerUsageType: import("zod").ZodOptional<import("zod").ZodString>;
+            itemCode: import("zod").ZodOptional<import("zod").ZodString>;
+            quantity: import("zod").ZodOptional<import("zod").ZodNumber>;
+            discount: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            amount: number;
+            description?: string | undefined;
+            quantity?: number | undefined;
+            taxCode?: string | undefined;
+            customerUsageType?: string | undefined;
+            itemCode?: string | undefined;
+            discount?: number | undefined;
+        }, {
+            amount: number;
+            description?: string | undefined;
+            quantity?: number | undefined;
+            taxCode?: string | undefined;
+            customerUsageType?: string | undefined;
+            itemCode?: string | undefined;
+            discount?: number | undefined;
+        }>, "many">;
+        addresses: import("zod").ZodOptional<import("zod").ZodObject<{
+            shipFrom: import("zod").ZodOptional<import("zod").ZodObject<{
+                line1: import("zod").ZodOptional<import("zod").ZodString>;
+                city: import("zod").ZodOptional<import("zod").ZodString>;
+                region: import("zod").ZodOptional<import("zod").ZodString>;
+                country: import("zod").ZodOptional<import("zod").ZodString>;
+                postalCode: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "strip", import("zod").ZodTypeAny, {
+                city?: string | undefined;
+                country?: string | undefined;
+                postalCode?: string | undefined;
+                line1?: string | undefined;
+                region?: string | undefined;
+            }, {
+                city?: string | undefined;
+                country?: string | undefined;
+                postalCode?: string | undefined;
+                line1?: string | undefined;
+                region?: string | undefined;
+            }>>;
+            shipTo: import("zod").ZodObject<{
+                line1: import("zod").ZodOptional<import("zod").ZodString>;
+                city: import("zod").ZodOptional<import("zod").ZodString>;
+                region: import("zod").ZodOptional<import("zod").ZodString>;
+                country: import("zod").ZodOptional<import("zod").ZodString>;
+                postalCode: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "strip", import("zod").ZodTypeAny, {
+                city?: string | undefined;
+                country?: string | undefined;
+                postalCode?: string | undefined;
+                line1?: string | undefined;
+                region?: string | undefined;
+            }, {
+                city?: string | undefined;
+                country?: string | undefined;
+                postalCode?: string | undefined;
+                line1?: string | undefined;
+                region?: string | undefined;
+            }>;
+        }, "strip", import("zod").ZodTypeAny, {
+            shipTo: {
+                city?: string | undefined;
+                country?: string | undefined;
+                postalCode?: string | undefined;
+                line1?: string | undefined;
+                region?: string | undefined;
+            };
+            shipFrom?: {
+                city?: string | undefined;
+                country?: string | undefined;
+                postalCode?: string | undefined;
+                line1?: string | undefined;
+                region?: string | undefined;
+            } | undefined;
+        }, {
+            shipTo: {
+                city?: string | undefined;
+                country?: string | undefined;
+                postalCode?: string | undefined;
+                line1?: string | undefined;
+                region?: string | undefined;
+            };
+            shipFrom?: {
+                city?: string | undefined;
+                country?: string | undefined;
+                postalCode?: string | undefined;
+                line1?: string | undefined;
+                region?: string | undefined;
+            } | undefined;
+        }>>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+        type: import("zod").ZodOptional<import("zod").ZodEnum<["SalesOrder", "SalesInvoice", "ReturnInvoice", "InventoryTransferOrder"]>>;
+        companyCode: import("zod").ZodOptional<import("zod").ZodString>;
+        customerCode: import("zod").ZodOptional<import("zod").ZodString>;
+        businessIdentificationNo: import("zod").ZodOptional<import("zod").ZodString>;
+        commit: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        currencyCode: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">) => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: {
+            lines?: import("zod").objectInputType<{
+                lineNumber: import("zod").ZodOptional<import("zod").ZodString>;
+                taxableAmount: import("zod").ZodOptional<import("zod").ZodNumber>;
+                tax: import("zod").ZodOptional<import("zod").ZodNumber>;
+                taxCalculated: import("zod").ZodOptional<import("zod").ZodNumber>;
+                rate: import("zod").ZodOptional<import("zod").ZodNumber>;
+                exemptAmount: import("zod").ZodOptional<import("zod").ZodNumber>;
+                details: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    jurisdictionName: import("zod").ZodOptional<import("zod").ZodString>;
+                    rate: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    tax: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    taxableAmount: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    taxType: import("zod").ZodOptional<import("zod").ZodString>;
+                    jurisdictionType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, "strip", import("zod").ZodTypeAny, {
+                    taxableAmount?: number | undefined;
+                    tax?: number | undefined;
+                    rate?: number | undefined;
+                    jurisdictionName?: string | undefined;
+                    taxType?: string | undefined;
+                    jurisdictionType?: string | undefined;
+                }, {
+                    taxableAmount?: number | undefined;
+                    tax?: number | undefined;
+                    rate?: number | undefined;
+                    jurisdictionName?: string | undefined;
+                    taxType?: string | undefined;
+                    jurisdictionType?: string | undefined;
+                }>, "many">>;
+            }, import("zod").ZodTypeAny, "passthrough">[] | undefined;
+            summary?: {
+                country?: string | undefined;
+                region?: string | undefined;
+                tax?: number | undefined;
+                taxCalculated?: number | undefined;
+                rate?: number | undefined;
+                taxType?: string | undefined;
+                jurisType?: string | undefined;
+                jurisCode?: string | undefined;
+                jurisName?: string | undefined;
+                taxAuthorityType?: number | undefined;
+                stateAssignedNo?: string | undefined;
+                taxName?: string | undefined;
+                taxGroup?: string | undefined;
+                rateType?: string | undefined;
+                taxable?: number | undefined;
+                nonTaxable?: number | undefined;
+                exemption?: number | undefined;
+            }[] | undefined;
+            totalAmount?: number | undefined;
+            addresses?: {
+                city?: string | undefined;
+                country?: string | undefined;
+                postalCode?: string | undefined;
+                line1?: string | undefined;
+                region?: string | undefined;
+                addressType?: string | undefined;
+                latitude?: number | undefined;
+                longitude?: number | undefined;
+            }[] | undefined;
+            totalExempt?: number | undefined;
+            totalTaxable?: number | undefined;
+            totalTax?: number | undefined;
+            totalTaxCalculated?: number | undefined;
+            taxDate?: string | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+    /**
+     * Get health check status data only
+     * @returns Promise<string> Health status string
+     */
+    readonly healthCheckData: () => Promise<string>;
+    /**
+     * Calculate tax rates and return calculation result data only
+     * @param params Tax calculation request parameters
+     * @returns Promise<TaxCalculationResult> Tax calculation result with rates and amounts
+     */
+    readonly ratesCalculateData: (params: RatesRequestParams) => Promise<TaxCalculationResult>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/cjs/services/avalara/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/services/avalara/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAGL,kBAAkB,EAElB,oBAAoB,EACrB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;GAQG;AACH,qBAAa,aAAc,SAAQ,iBAAiB;gBACtC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,MAAM;IAI9C,SAAS,CAAC,qBAAqB,IAAI,MAAM;IAIzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,QAAQ,CAAC,WAAW;;;;;;;;;OAA2D;IAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoFG;IACH,QAAQ,CAAC,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAIrB;IAIF;;;OAGG;IACH,QAAQ,CAAC,eAAe,QAAa,OAAO,CAAC,MAAM,CAAC,CAGlD;IAEF;;;;OAIG;IACH,QAAQ,CAAC,kBAAkB,GACzB,QAAQ,kBAAkB,KACzB,OAAO,CAAC,oBAAoB,CAAC,CAG9B;CACH"}

package/dist/cjs/services/avalara/client.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvalaraClient = void 0;
+const base_client_1 = require("../../core/base-client");
+const schemas_1 = require("./schemas");
+/**
+ * Avalara Tax Service Client
+ *
+ * Provides access to Avalara tax calculation endpoints for real-time tax rate
+ * computation and compliance.
+ *
+ * @service avalara
+ * @domain tax-calculation
+ */
+class AvalaraClient extends base_client_1.BaseServiceClient {
+    constructor(http, baseUrl) {
+        super('avalara', http, baseUrl || 'https://avalara.augur-api.com');
+        /**
+         * Check service health and availability
+         *
+         * @fullPath api.avalara.healthCheck.get
+         * @service avalara
+         * @domain system-health
+         * @dataMethod healthCheckData
+         * @discoverable true
+         * @searchTerms ["health", "status", "availability", "ping", "check", "tax service"]
+         * @relatedEndpoints ["api.avalara.rates.calculate", "api.agrWork.healthCheck.get", "api.agrInfo.healthCheck.get", "api.commerce.healthCheck.get"]
+         * @commonPatterns ["Health check", "Service status", "Tax service availability", "System monitoring"]
+         * @workflow ["system-monitoring", "health-checks", "service-discovery", "tax-service-verification"]
+         * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header"]
+         * @nextSteps ["Use tax calculation endpoints if healthy", "Verify tax service connectivity", "Monitor service metrics"]
+         * @businessRules ["Returns service status and basic info", "Requires standard authentication", "Standard health check format"]
+         * @functionalArea "system-monitoring"
+         * @caching "No caching - real-time status required"
+         * @performance "Fast response, minimal processing, use for tax service monitoring"
+         *
+         * @returns Promise<HealthCheckResponse> Service health status
+         *
+         * @example
+         * ```typescript
+         * // Check if tax service is healthy
+         * const response = await client.healthCheck();
+         * console.log(response.data); // Health status string
+         * console.log(response.status); // HTTP status code
+         *
+         * // Get just the health status
+         * const status = await client.healthCheckData();
+         * console.log(status); // Direct string access
+         * ```
+         */
+        this.healthCheck = this.createHealthCheckMethod(schemas_1.HealthCheckResponseSchema);
+        /**
+         * Calculate tax rates for transaction lines
+         *
+         * @fullPath api.avalara.rates.calculate
+         * @service avalara
+         * @domain tax-calculation
+         * @dataMethod ratesCalculateData
+         * @discoverable true
+         * @searchTerms ["tax", "rates", "calculate", "avalara", "sales tax", "vat", "compliance", "transaction"]
+         * @relatedEndpoints ["api.commerce.orders.create", "api.commerce.cartHeaders.checkout", "api.items.pricing.calculate", "api.customers.addresses.validate"]
+         * @commonPatterns ["Calculate sales tax", "Get tax rates", "Tax compliance", "E-commerce tax calculation", "Multi-jurisdiction tax"]
+         * @workflow ["e-commerce-checkout", "order-processing", "tax-compliance", "invoice-generation", "financial-reporting"]
+         * @prerequisites ["Valid transaction data", "Public bearer token", "x-site-id header", "Valid addresses", "Product/service lines"]
+         * @nextSteps ["Apply calculated tax to order", "Store tax calculation results", "Generate compliant invoice", "Submit tax returns"]
+         * @businessRules ["Requires valid addresses", "Supports multiple tax jurisdictions", "Real-time calculation", "Compliance with local tax laws", "Handles exemptions and special rates"]
+         * @functionalArea "tax-and-compliance"
+         * @crossSite "Multi-site tax calculation support"
+         * @caching "Cache for 1 hour for identical requests, tax rates change infrequently"
+         * @performance "Optimize by batching multiple line items, use address validation for accuracy"
+         *
+         * @param params Tax calculation request parameters including lines, addresses, and transaction details
+         * @returns Promise<RatesResponse> Complete tax calculation results with rates, amounts, and jurisdiction details
+         *
+         * @example
+         * ```typescript
+         * // Calculate tax for a simple sale
+         * const taxRequest = {
+         *   lines: [{
+         *     amount: 100.00,
+         *     description: 'Widget',
+         *     quantity: 1
+         *   }],
+         *   addresses: {
+         *     shipTo: {
+         *       line1: '123 Main St',
+         *       city: 'Irvine',
+         *       region: 'CA',
+         *       country: 'US',
+         *       postalCode: '92602'
+         *     }
+         *   },
+         *   type: 'SalesOrder',
+         *   date: '2024-01-15',
+         *   companyCode: 'DEFAULT'
+         * };
+         *
+         * const response = await client.ratesCalculate(taxRequest);
+         * console.log(response.data.totalTax); // Total tax amount
+         * console.log(response.data.lines); // Tax details per line
+         *
+         * // Get just the calculation result
+         * const taxResult = await client.ratesCalculateData(taxRequest);
+         * console.log(taxResult.totalTax); // Direct access to tax amount
+         *
+         * // Multi-line transaction with shipping
+         * const complexRequest = {
+         *   lines: [
+         *     { amount: 50.00, description: 'Product A', taxCode: 'P0000000' },
+         *     { amount: 30.00, description: 'Product B', taxCode: 'P0000000' },
+         *     { amount: 10.00, description: 'Shipping', taxCode: 'FR010000' }
+         *   ],
+         *   addresses: {
+         *     shipFrom: {
+         *       line1: '100 Warehouse Blvd',
+         *       city: 'Los Angeles',
+         *       region: 'CA',
+         *       country: 'US',
+         *       postalCode: '90210'
+         *     },
+         *     shipTo: {
+         *       line1: '456 Customer Ave',
+         *       city: 'New York',
+         *       region: 'NY',
+         *       country: 'US',
+         *       postalCode: '10001'
+         *     }
+         *   },
+         *   type: 'SalesInvoice',
+         *   customerCode: 'CUST001',
+         *   commit: true
+         * };
+         *
+         * const complexResult = await client.ratesCalculateData(complexRequest);
+         * ```
+         */
+        this.ratesCalculate = this.createCreateMethod('/rates', schemas_1.RatesRequestParamsSchema, schemas_1.RatesResponseSchema);
+        // Data-only methods for direct access to response data
+        /**
+         * Get health check status data only
+         * @returns Promise<string> Health status string
+         */
+        this.healthCheckData = async () => {
+            const response = await this.healthCheck();
+            return response.data;
+        };
+        /**
+         * Calculate tax rates and return calculation result data only
+         * @param params Tax calculation request parameters
+         * @returns Promise<TaxCalculationResult> Tax calculation result with rates and amounts
+         */
+        this.ratesCalculateData = async (params) => {
+            const response = await this.ratesCalculate(params);
+            return response.data;
+        };
+    }
+    getServiceDescription() {
+        return 'Avalara tax calculation service for real-time tax rate computation and compliance';
+    }
+}
+exports.AvalaraClient = AvalaraClient;
+//# sourceMappingURL=client.js.map

package/dist/cjs/services/avalara/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../src/services/avalara/client.ts"],"names":[],"mappings":";;;AAAA,wDAA2D;AAE3D,uCAMmB;AAEnB;;;;;;;;GAQG;AACH,MAAa,aAAc,SAAQ,+BAAiB;IAClD,YAAY,IAAgB,EAAE,OAAgB;QAC5C,KAAK,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,IAAI,+BAA+B,CAAC,CAAC;QAOrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCG;QACM,gBAAW,GAAG,IAAI,CAAC,uBAAuB,CAAC,mCAAyB,CAAC,CAAC;QAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAoFG;QACM,mBAAc,GAAG,IAAI,CAAC,kBAAkB,CAC/C,QAAQ,EACR,kCAAwB,EACxB,6BAAmB,CACpB,CAAC;QAEF,uDAAuD;QAEvD;;;WAGG;QACM,oBAAe,GAAG,KAAK,IAAqB,EAAE;YACrD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;YAC1C,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC,CAAC;QAEF;;;;WAIG;QACM,uBAAkB,GAAG,KAAK,EACjC,MAA0B,EACK,EAAE;YACjC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;YACnD,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC,CAAC;IAzJF,CAAC;IAES,qBAAqB;QAC7B,OAAO,mFAAmF,CAAC;IAC7F,CAAC;CAsJF;AA7JD,sCA6JC"}

package/dist/cjs/services/avalara/index.d.ts

@@ -0,0 +1,3 @@
+export { AvalaraClient } from './client';
+export type { HealthCheckResponse, RatesRequestParams, RatesResponse, TaxCalculationResult, TaxLine, } from './schemas';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/services/avalara/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/avalara/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,YAAY,EAEV,mBAAmB,EAEnB,kBAAkB,EAClB,aAAa,EACb,oBAAoB,EACpB,OAAO,GACR,MAAM,WAAW,CAAC"}

package/dist/cjs/services/avalara/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvalaraClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "AvalaraClient", { enumerable: true, get: function () { return client_1.AvalaraClient; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/services/avalara/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/services/avalara/index.ts"],"names":[],"mappings":";;;AAAA,mCAAyC;AAAhC,uGAAA,aAAa,OAAA"}