@simpleapps-com/augur-api 0.5.1 → 0.6.0

package/dist/cjs/services/logistics/resources/health-check.d.ts

@@ -0,0 +1,66 @@
+import type { LogisticsClient } from '../client';
+type ExecuteRequest = LogisticsClient['executeRequest'];
+/**
+ * Creates the healthCheck resource methods
+ * OpenAPI Path: /health-check → healthCheck.*
+ * @description Health check endpoint for Logistics service
+ */
+export declare function createHealthCheckResource(executeRequest: ExecuteRequest): {
+    /**
+     * Check service health and availability
+     *
+     * @fullPath api.logistics.healthCheck.get
+     * @service logistics
+     * @domain system-health
+     * @dataMethod healthCheckData.get
+     * @discoverable true
+     * @searchTerms ["health", "status", "availability", "ping", "check", "shipping service", "logistics"]
+     * @relatedEndpoints ["api.logistics.ping.get", "api.logistics.speedship.freight.get", "api.commerce.healthCheck.get", "api.orders.healthCheck.get"]
+     * @commonPatterns ["Health check", "Service status", "Shipping service availability", "System monitoring"]
+     * @workflow ["system-monitoring", "health-checks", "service-discovery", "logistics-service-verification"]
+     * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header"]
+     * @nextSteps ["Use shipping endpoints if healthy", "Verify logistics 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 logistics service monitoring"
+     *
+     * @returns Promise<HealthCheckResponse> Service health status
+     *
+     * @example
+     * ```typescript
+     * // Check if logistics service is healthy
+     * const response = await client.healthCheck.get();
+     * console.log(response.data); // Health status string
+     * console.log(response.status); // HTTP status code
+     *
+     * // Get just the health status
+     * const status = await client.healthCheckData.get();
+     * console.log(status); // Direct string access
+     * ```
+     */
+    get: () => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: string;
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+};
+/**
+ * Creates the healthCheckData resource methods (data-only versions)
+ */
+export declare function createHealthCheckDataResource(healthCheck: ReturnType<typeof createHealthCheckResource>): {
+    /**
+     * Get health check status data only
+     * @returns Promise<string> Health status string
+     */
+    get: () => Promise<string>;
+};
+export type HealthCheckResource = ReturnType<typeof createHealthCheckResource>;
+export type HealthCheckDataResource = ReturnType<typeof createHealthCheckDataResource>;
+export {};
+//# sourceMappingURL=health-check.d.ts.map

package/dist/cjs/services/logistics/resources/health-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-check.d.ts","sourceRoot":"","sources":["../../../../../src/services/logistics/resources/health-check.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,KAAK,cAAc,GAAG,eAAe,CAAC,gBAAgB,CAAC,CAAC;AAExD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,cAAc,EAAE,cAAc;IAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;;;;;;;;;;;EAYN;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,UAAU,CAAC,OAAO,yBAAyB,CAAC;IAGvD;;;OAGG;;EAMN;AAED,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC/E,MAAM,MAAM,uBAAuB,GAAG,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC"}

package/dist/cjs/services/logistics/resources/health-check.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHealthCheckResource = createHealthCheckResource;
+exports.createHealthCheckDataResource = createHealthCheckDataResource;
+const schemas_1 = require("../schemas");
+/**
+ * Creates the healthCheck resource methods
+ * OpenAPI Path: /health-check → healthCheck.*
+ * @description Health check endpoint for Logistics service
+ */
+function createHealthCheckResource(executeRequest) {
+    return {
+        /**
+         * Check service health and availability
+         *
+         * @fullPath api.logistics.healthCheck.get
+         * @service logistics
+         * @domain system-health
+         * @dataMethod healthCheckData.get
+         * @discoverable true
+         * @searchTerms ["health", "status", "availability", "ping", "check", "shipping service", "logistics"]
+         * @relatedEndpoints ["api.logistics.ping.get", "api.logistics.speedship.freight.get", "api.commerce.healthCheck.get", "api.orders.healthCheck.get"]
+         * @commonPatterns ["Health check", "Service status", "Shipping service availability", "System monitoring"]
+         * @workflow ["system-monitoring", "health-checks", "service-discovery", "logistics-service-verification"]
+         * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header"]
+         * @nextSteps ["Use shipping endpoints if healthy", "Verify logistics 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 logistics service monitoring"
+         *
+         * @returns Promise<HealthCheckResponse> Service health status
+         *
+         * @example
+         * ```typescript
+         * // Check if logistics service is healthy
+         * const response = await client.healthCheck.get();
+         * console.log(response.data); // Health status string
+         * console.log(response.status); // HTTP status code
+         *
+         * // Get just the health status
+         * const status = await client.healthCheckData.get();
+         * console.log(status); // Direct string access
+         * ```
+         */
+        get: async () => {
+            return executeRequest({
+                method: 'GET',
+                path: '/health-check',
+                responseSchema: schemas_1.HealthCheckResponseSchema,
+            }, undefined);
+        },
+    };
+}
+/**
+ * Creates the healthCheckData resource methods (data-only versions)
+ */
+function createHealthCheckDataResource(healthCheck) {
+    return {
+        /**
+         * Get health check status data only
+         * @returns Promise<string> Health status string
+         */
+        get: async () => {
+            const response = await healthCheck.get();
+            return response.data;
+        },
+    };
+}
+//# sourceMappingURL=health-check.js.map

package/dist/cjs/services/logistics/resources/health-check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-check.js","sourceRoot":"","sources":["../../../../../src/services/logistics/resources/health-check.ts"],"names":[],"mappings":";;AAUA,8DA8CC;AAKD,sEAaC;AA1ED,wCAAuD;AAKvD;;;;GAIG;AACH,SAAgB,yBAAyB,CAAC,cAA8B;IACtE,OAAO;QACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCG;QACH,GAAG,EAAE,KAAK,IAAI,EAAE;YACd,OAAO,cAAc,CACnB;gBACE,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,eAAe;gBACrB,cAAc,EAAE,mCAAyB;aAC1C,EACD,SAAS,CACV,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,6BAA6B,CAC3C,WAAyD;IAEzD,OAAO;QACL;;;WAGG;QACH,GAAG,EAAE,KAAK,IAAI,EAAE;YACd,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,GAAG,EAAE,CAAC;YACzC,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/cjs/services/logistics/resources/index.d.ts

@@ -0,0 +1,5 @@
+export { createHealthCheckResource, createHealthCheckDataResource, type HealthCheckResource, type HealthCheckDataResource, } from './health-check';
+export { createPingResource, createPingDataResource, type PingResource, type PingDataResource, } from './ping';
+export { createSpeedshipResource, createSpeedshipDataResource, type SpeedshipResource, type SpeedshipDataResource, } from './speedship';
+export { createShipviaResource, createShipviaDataResource, type ShipviaResource, type ShipviaDataResource, } from './shipvia';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/services/logistics/resources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/logistics/resources/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,yBAAyB,EACzB,6BAA6B,EAC7B,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,GAC7B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,KAAK,YAAY,EACjB,KAAK,gBAAgB,GACtB,MAAM,QAAQ,CAAC;AAEhB,OAAO,EACL,uBAAuB,EACvB,2BAA2B,EAC3B,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,GAC3B,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,KAAK,eAAe,EACpB,KAAK,mBAAmB,GACzB,MAAM,WAAW,CAAC"}

package/dist/cjs/services/logistics/resources/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createShipviaDataResource = exports.createShipviaResource = exports.createSpeedshipDataResource = exports.createSpeedshipResource = exports.createPingDataResource = exports.createPingResource = exports.createHealthCheckDataResource = exports.createHealthCheckResource = void 0;
+// Resource exports
+var health_check_1 = require("./health-check");
+Object.defineProperty(exports, "createHealthCheckResource", { enumerable: true, get: function () { return health_check_1.createHealthCheckResource; } });
+Object.defineProperty(exports, "createHealthCheckDataResource", { enumerable: true, get: function () { return health_check_1.createHealthCheckDataResource; } });
+var ping_1 = require("./ping");
+Object.defineProperty(exports, "createPingResource", { enumerable: true, get: function () { return ping_1.createPingResource; } });
+Object.defineProperty(exports, "createPingDataResource", { enumerable: true, get: function () { return ping_1.createPingDataResource; } });
+var speedship_1 = require("./speedship");
+Object.defineProperty(exports, "createSpeedshipResource", { enumerable: true, get: function () { return speedship_1.createSpeedshipResource; } });
+Object.defineProperty(exports, "createSpeedshipDataResource", { enumerable: true, get: function () { return speedship_1.createSpeedshipDataResource; } });
+var shipvia_1 = require("./shipvia");
+Object.defineProperty(exports, "createShipviaResource", { enumerable: true, get: function () { return shipvia_1.createShipviaResource; } });
+Object.defineProperty(exports, "createShipviaDataResource", { enumerable: true, get: function () { return shipvia_1.createShipviaDataResource; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/services/logistics/resources/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/services/logistics/resources/index.ts"],"names":[],"mappings":";;;AAAA,mBAAmB;AACnB,+CAKwB;AAJtB,yHAAA,yBAAyB,OAAA;AACzB,6HAAA,6BAA6B,OAAA;AAK/B,+BAKgB;AAJd,0GAAA,kBAAkB,OAAA;AAClB,8GAAA,sBAAsB,OAAA;AAKxB,yCAKqB;AAJnB,oHAAA,uBAAuB,OAAA;AACvB,wHAAA,2BAA2B,OAAA;AAK7B,qCAKmB;AAJjB,gHAAA,qBAAqB,OAAA;AACrB,oHAAA,yBAAyB,OAAA"}

package/dist/cjs/services/logistics/resources/ping.d.ts

@@ -0,0 +1,72 @@
+import type { LogisticsClient } from '../client';
+type ExecuteRequest = LogisticsClient['executeRequest'];
+/**
+ * Creates the ping resource methods
+ * OpenAPI Path: /ping → ping.*
+ * @description Ping endpoint for connectivity test
+ */
+export declare function createPingResource(executeRequest: ExecuteRequest): {
+    /**
+     * Ping the logistics service for basic connectivity testing
+     *
+     * @fullPath api.logistics.ping.get
+     * @service logistics
+     * @domain system-connectivity
+     * @dataMethod pingData.get
+     * @discoverable true
+     * @searchTerms ["ping", "pong", "connectivity", "test", "network", "response", "logistics"]
+     * @relatedEndpoints ["api.logistics.healthCheck.get", "api.logistics.speedship.freight.get", "api.commerce.ping.get"]
+     * @commonPatterns ["Ping test", "Network connectivity", "Service response test", "Basic connectivity check"]
+     * @workflow ["connectivity-testing", "network-diagnostics", "service-verification", "latency-measurement"]
+     * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header", "Network connectivity"]
+     * @nextSteps ["Measure response time", "Verify network stability", "Test full service endpoints"]
+     * @businessRules ["Returns pong response", "Requires standard authentication", "Minimal response format"]
+     * @functionalArea "system-monitoring"
+     * @caching "No caching - real-time connectivity test required"
+     * @performance "Extremely fast response, use for latency testing and connectivity verification"
+     *
+     * @returns Promise<PingResponse> Pong response confirming connectivity
+     *
+     * @example
+     * ```typescript
+     * // Test logistics service connectivity
+     * const response = await client.ping.get();
+     * console.log(response.data); // "pong" response
+     * console.log(response.status); // HTTP status code
+     *
+     * // Get just the ping response
+     * const pong = await client.pingData.get();
+     * console.log(pong); // Direct pong string
+     *
+     * // Measure response time
+     * const start = Date.now();
+     * await client.ping.get();
+     * const responseTime = Date.now() - start;
+     * console.log(`Logistics service response time: ${responseTime}ms`);
+     * ```
+     */
+    get: () => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: string;
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+};
+/**
+ * Creates the pingData resource methods (data-only versions)
+ */
+export declare function createPingDataResource(ping: ReturnType<typeof createPingResource>): {
+    /**
+     * Get ping response data only
+     * @returns Promise<string> Pong response string
+     */
+    get: () => Promise<string>;
+};
+export type PingResource = ReturnType<typeof createPingResource>;
+export type PingDataResource = ReturnType<typeof createPingDataResource>;
+export {};
+//# sourceMappingURL=ping.d.ts.map

package/dist/cjs/services/logistics/resources/ping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ping.d.ts","sourceRoot":"","sources":["../../../../../src/services/logistics/resources/ping.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,KAAK,cAAc,GAAG,eAAe,CAAC,gBAAgB,CAAC,CAAC;AAExD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,cAAc;IAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;;;;;;;;;;;EAYN;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC;IAE9E;;;OAGG;;EAMN;AAED,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACjE,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/cjs/services/logistics/resources/ping.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPingResource = createPingResource;
+exports.createPingDataResource = createPingDataResource;
+const schemas_1 = require("../schemas");
+/**
+ * Creates the ping resource methods
+ * OpenAPI Path: /ping → ping.*
+ * @description Ping endpoint for connectivity test
+ */
+function createPingResource(executeRequest) {
+    return {
+        /**
+         * Ping the logistics service for basic connectivity testing
+         *
+         * @fullPath api.logistics.ping.get
+         * @service logistics
+         * @domain system-connectivity
+         * @dataMethod pingData.get
+         * @discoverable true
+         * @searchTerms ["ping", "pong", "connectivity", "test", "network", "response", "logistics"]
+         * @relatedEndpoints ["api.logistics.healthCheck.get", "api.logistics.speedship.freight.get", "api.commerce.ping.get"]
+         * @commonPatterns ["Ping test", "Network connectivity", "Service response test", "Basic connectivity check"]
+         * @workflow ["connectivity-testing", "network-diagnostics", "service-verification", "latency-measurement"]
+         * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header", "Network connectivity"]
+         * @nextSteps ["Measure response time", "Verify network stability", "Test full service endpoints"]
+         * @businessRules ["Returns pong response", "Requires standard authentication", "Minimal response format"]
+         * @functionalArea "system-monitoring"
+         * @caching "No caching - real-time connectivity test required"
+         * @performance "Extremely fast response, use for latency testing and connectivity verification"
+         *
+         * @returns Promise<PingResponse> Pong response confirming connectivity
+         *
+         * @example
+         * ```typescript
+         * // Test logistics service connectivity
+         * const response = await client.ping.get();
+         * console.log(response.data); // "pong" response
+         * console.log(response.status); // HTTP status code
+         *
+         * // Get just the ping response
+         * const pong = await client.pingData.get();
+         * console.log(pong); // Direct pong string
+         *
+         * // Measure response time
+         * const start = Date.now();
+         * await client.ping.get();
+         * const responseTime = Date.now() - start;
+         * console.log(`Logistics service response time: ${responseTime}ms`);
+         * ```
+         */
+        get: async () => {
+            return executeRequest({
+                method: 'GET',
+                path: '/ping',
+                responseSchema: schemas_1.PingResponseSchema,
+            }, undefined);
+        },
+    };
+}
+/**
+ * Creates the pingData resource methods (data-only versions)
+ */
+function createPingDataResource(ping) {
+    return {
+        /**
+         * Get ping response data only
+         * @returns Promise<string> Pong response string
+         */
+        get: async () => {
+            const response = await ping.get();
+            return response.data;
+        },
+    };
+}
+//# sourceMappingURL=ping.js.map

package/dist/cjs/services/logistics/resources/ping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ping.js","sourceRoot":"","sources":["../../../../../src/services/logistics/resources/ping.ts"],"names":[],"mappings":";;AAUA,gDAoDC;AAKD,wDAWC;AA9ED,wCAAgD;AAKhD;;;;GAIG;AACH,SAAgB,kBAAkB,CAAC,cAA8B;IAC/D,OAAO;QACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAsCG;QACH,GAAG,EAAE,KAAK,IAAI,EAAE;YACd,OAAO,cAAc,CACnB;gBACE,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,OAAO;gBACb,cAAc,EAAE,4BAAkB;aACnC,EACD,SAAS,CACV,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,sBAAsB,CAAC,IAA2C;IAChF,OAAO;QACL;;;WAGG;QACH,GAAG,EAAE,KAAK,IAAI,EAAE;YACd,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC;YAClC,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/cjs/services/logistics/resources/shipvia.d.ts

@@ -0,0 +1,176 @@
+import { ShipviaRatesParams, ShipviaRatesData, ShipviaRatesLtlParams } from '../schemas';
+import type { LogisticsClient } from '../client';
+type ExecuteRequest = LogisticsClient['executeRequest'];
+/**
+ * Creates the shipvia resource methods
+ * OpenAPI Path: /shipvia/* → shipvia.*
+ * @description ShipVia shipping rate endpoints for standard and LTL freight
+ */
+export declare function createShipviaResource(executeRequest: ExecuteRequest): {
+    rates: {
+        /**
+         * Get shipping rates from available carriers
+         *
+         * @fullPath api.logistics.shipvia.rates.list
+         * @service logistics
+         * @domain shipping-rates
+         * @dataMethod shipviaData.rates.list
+         * @discoverable true
+         * @searchTerms ["shipping", "rates", "carriers", "shipvia", "freight", "delivery", "cost"]
+         * @relatedEndpoints ["api.logistics.shipvia.rates.ltl.list", "api.logistics.speedship.freight.get"]
+         * @commonPatterns ["Get shipping rates", "Compare carriers", "Calculate shipping costs"]
+         * @workflow ["order-fulfillment", "shipping-calculation", "carrier-selection"]
+         * @prerequisites ["Valid postal codes", "Weight and dimensions", "Location ID"]
+         * @nextSteps ["Select carrier", "Create shipment", "Generate label"]
+         * @businessRules ["Requires valid origin and destination postal codes", "Weight must be positive"]
+         * @functionalArea "shipping-and-fulfillment"
+         *
+         * @param params Shipping rate request parameters
+         * @returns Promise<ShipviaRatesResponse> Available shipping rates from carriers
+         *
+         * @example
+         * ```typescript
+         * const rates = await client.shipvia.rates.list({
+         *   fromPostalCode: '90210',
+         *   toPostalCode: '10001',
+         *   totalWeight: 10,
+         *   weightUnit: 'LB',
+         *   locationId: 1
+         * });
+         * console.log(rates.data); // Array of carrier rates
+         * ```
+         */
+        list: (params: ShipviaRatesParams) => Promise<{
+            params: Record<string, unknown> | unknown[];
+            data: import("zod").objectInputType<{
+                carrier: import("zod").ZodOptional<import("zod").ZodString>;
+                carrierCode: import("zod").ZodOptional<import("zod").ZodString>;
+                carrierName: import("zod").ZodOptional<import("zod").ZodString>;
+                service: import("zod").ZodOptional<import("zod").ZodString>;
+                serviceCode: import("zod").ZodOptional<import("zod").ZodString>;
+                serviceName: import("zod").ZodOptional<import("zod").ZodString>;
+                shipViaId: import("zod").ZodOptional<import("zod").ZodNumber>;
+                rate: import("zod").ZodOptional<import("zod").ZodNumber>;
+                baseRate: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalRate: import("zod").ZodOptional<import("zod").ZodNumber>;
+                discountedRate: import("zod").ZodOptional<import("zod").ZodNumber>;
+                currency: import("zod").ZodOptional<import("zod").ZodString>;
+                fuelSurcharge: import("zod").ZodOptional<import("zod").ZodNumber>;
+                accessorialCharges: import("zod").ZodOptional<import("zod").ZodNumber>;
+                handlingFee: import("zod").ZodOptional<import("zod").ZodNumber>;
+                transitTime: import("zod").ZodOptional<import("zod").ZodString>;
+                transitDays: import("zod").ZodOptional<import("zod").ZodNumber>;
+                deliveryDate: import("zod").ZodOptional<import("zod").ZodString>;
+                estimatedDelivery: import("zod").ZodOptional<import("zod").ZodString>;
+                zone: import("zod").ZodOptional<import("zod").ZodString>;
+                originZip: import("zod").ZodOptional<import("zod").ZodString>;
+                destinationZip: import("zod").ZodOptional<import("zod").ZodString>;
+                commodityClass: import("zod").ZodOptional<import("zod").ZodString>;
+                guaranteed: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod").ZodTypeAny, "passthrough">[];
+            options: Record<string, unknown> | unknown[];
+            status: number;
+            message: string;
+            count: number;
+            total: number;
+            totalResults: number;
+        }>;
+        ltl: {
+            /**
+             * Get LTL (Less Than Truckload) freight rates
+             *
+             * @fullPath api.logistics.shipvia.rates.ltl.list
+             * @service logistics
+             * @domain ltl-freight
+             * @dataMethod shipviaData.rates.ltl.list
+             * @discoverable true
+             * @searchTerms ["ltl", "freight", "truckload", "rates", "shipping", "commodity"]
+             * @relatedEndpoints ["api.logistics.shipvia.rates.list", "api.logistics.speedship.freight.get"]
+             * @commonPatterns ["Get LTL rates", "Freight quotes", "Heavy shipping"]
+             * @workflow ["freight-shipping", "ltl-fulfillment", "carrier-selection"]
+             * @prerequisites ["Valid postal codes", "Commodity class", "Packaging type"]
+             * @nextSteps ["Select LTL carrier", "Book freight", "Schedule pickup"]
+             * @businessRules ["Requires commodity class and description", "Packaging type required for LTL"]
+             * @functionalArea "freight-shipping"
+             *
+             * @param params LTL rate request parameters including commodity details
+             * @returns Promise<ShipviaRatesLtlResponse> Available LTL freight rates
+             *
+             * @example
+             * ```typescript
+             * const ltlRates = await client.shipvia.rates.ltl.list({
+             *   fromPostalCode: '90210',
+             *   toPostalCode: '10001',
+             *   totalWeight: 500,
+             *   weightUnit: 'LB',
+             *   locationId: 1,
+             *   commodityClass: '70',
+             *   commodityDescription: 'General freight',
+             *   packagingType: 'PALLET'
+             * });
+             * console.log(ltlRates.data); // Array of LTL carrier rates
+             * ```
+             */
+            list: (params: ShipviaRatesLtlParams) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: import("zod").objectInputType<{
+                    carrier: import("zod").ZodOptional<import("zod").ZodString>;
+                    carrierCode: import("zod").ZodOptional<import("zod").ZodString>;
+                    carrierName: import("zod").ZodOptional<import("zod").ZodString>;
+                    service: import("zod").ZodOptional<import("zod").ZodString>;
+                    serviceCode: import("zod").ZodOptional<import("zod").ZodString>;
+                    serviceName: import("zod").ZodOptional<import("zod").ZodString>;
+                    shipViaId: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    rate: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    baseRate: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    totalRate: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    discountedRate: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    currency: import("zod").ZodOptional<import("zod").ZodString>;
+                    fuelSurcharge: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    accessorialCharges: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    handlingFee: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    transitTime: import("zod").ZodOptional<import("zod").ZodString>;
+                    transitDays: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    deliveryDate: import("zod").ZodOptional<import("zod").ZodString>;
+                    estimatedDelivery: import("zod").ZodOptional<import("zod").ZodString>;
+                    zone: import("zod").ZodOptional<import("zod").ZodString>;
+                    originZip: import("zod").ZodOptional<import("zod").ZodString>;
+                    destinationZip: import("zod").ZodOptional<import("zod").ZodString>;
+                    commodityClass: import("zod").ZodOptional<import("zod").ZodString>;
+                    guaranteed: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod").ZodTypeAny, "passthrough">[];
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+        };
+    };
+};
+/**
+ * Creates the shipviaData resource methods (data-only versions)
+ */
+export declare function createShipviaDataResource(shipvia: ReturnType<typeof createShipviaResource>): {
+    rates: {
+        /**
+         * Get shipping rates data only
+         * @param params Shipping rate request parameters
+         * @returns Promise<ShipviaRatesData> Shipping rate data array
+         */
+        list: (params: ShipviaRatesParams) => Promise<ShipviaRatesData>;
+        ltl: {
+            /**
+             * Get LTL freight rates data only
+             * @param params LTL rate request parameters
+             * @returns Promise<ShipviaRatesData> LTL rate data array
+             */
+            list: (params: ShipviaRatesLtlParams) => Promise<ShipviaRatesData>;
+        };
+    };
+};
+export type ShipviaResource = ReturnType<typeof createShipviaResource>;
+export type ShipviaDataResource = ReturnType<typeof createShipviaDataResource>;
+export {};
+//# sourceMappingURL=shipvia.d.ts.map

package/dist/cjs/services/logistics/resources/shipvia.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shipvia.d.ts","sourceRoot":"","sources":["../../../../../src/services/logistics/resources/shipvia.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,kBAAkB,EAElB,gBAAgB,EAEhB,qBAAqB,EAEtB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,KAAK,cAAc,GAAG,eAAe,CAAC,gBAAgB,CAAC,CAAC;AAExD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,cAAc;;QAG9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA+BG;uBACkB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAarC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAkCG;2BACkB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcjD;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC;;QAGrF;;;;WAIG;uBACkB,kBAAkB,KAAG,OAAO,CAAC,gBAAgB,CAAC;;YAMjE;;;;eAIG;2BACkB,qBAAqB,KAAG,OAAO,CAAC,gBAAgB,CAAC;;;EAO7E;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACvE,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/cjs/services/logistics/resources/shipvia.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createShipviaResource = createShipviaResource;
+exports.createShipviaDataResource = createShipviaDataResource;
+const schemas_1 = require("../schemas");
+/**
+ * Creates the shipvia resource methods
+ * OpenAPI Path: /shipvia/* → shipvia.*
+ * @description ShipVia shipping rate endpoints for standard and LTL freight
+ */
+function createShipviaResource(executeRequest) {
+    return {
+        rates: {
+            /**
+             * Get shipping rates from available carriers
+             *
+             * @fullPath api.logistics.shipvia.rates.list
+             * @service logistics
+             * @domain shipping-rates
+             * @dataMethod shipviaData.rates.list
+             * @discoverable true
+             * @searchTerms ["shipping", "rates", "carriers", "shipvia", "freight", "delivery", "cost"]
+             * @relatedEndpoints ["api.logistics.shipvia.rates.ltl.list", "api.logistics.speedship.freight.get"]
+             * @commonPatterns ["Get shipping rates", "Compare carriers", "Calculate shipping costs"]
+             * @workflow ["order-fulfillment", "shipping-calculation", "carrier-selection"]
+             * @prerequisites ["Valid postal codes", "Weight and dimensions", "Location ID"]
+             * @nextSteps ["Select carrier", "Create shipment", "Generate label"]
+             * @businessRules ["Requires valid origin and destination postal codes", "Weight must be positive"]
+             * @functionalArea "shipping-and-fulfillment"
+             *
+             * @param params Shipping rate request parameters
+             * @returns Promise<ShipviaRatesResponse> Available shipping rates from carriers
+             *
+             * @example
+             * ```typescript
+             * const rates = await client.shipvia.rates.list({
+             *   fromPostalCode: '90210',
+             *   toPostalCode: '10001',
+             *   totalWeight: 10,
+             *   weightUnit: 'LB',
+             *   locationId: 1
+             * });
+             * console.log(rates.data); // Array of carrier rates
+             * ```
+             */
+            list: async (params) => {
+                return executeRequest({
+                    method: 'GET',
+                    path: '/shipvia/rates',
+                    paramsSchema: schemas_1.ShipviaRatesParamsSchema,
+                    responseSchema: schemas_1.ShipviaRatesResponseSchema,
+                }, params);
+            },
+            ltl: {
+                /**
+                 * Get LTL (Less Than Truckload) freight rates
+                 *
+                 * @fullPath api.logistics.shipvia.rates.ltl.list
+                 * @service logistics
+                 * @domain ltl-freight
+                 * @dataMethod shipviaData.rates.ltl.list
+                 * @discoverable true
+                 * @searchTerms ["ltl", "freight", "truckload", "rates", "shipping", "commodity"]
+                 * @relatedEndpoints ["api.logistics.shipvia.rates.list", "api.logistics.speedship.freight.get"]
+                 * @commonPatterns ["Get LTL rates", "Freight quotes", "Heavy shipping"]
+                 * @workflow ["freight-shipping", "ltl-fulfillment", "carrier-selection"]
+                 * @prerequisites ["Valid postal codes", "Commodity class", "Packaging type"]
+                 * @nextSteps ["Select LTL carrier", "Book freight", "Schedule pickup"]
+                 * @businessRules ["Requires commodity class and description", "Packaging type required for LTL"]
+                 * @functionalArea "freight-shipping"
+                 *
+                 * @param params LTL rate request parameters including commodity details
+                 * @returns Promise<ShipviaRatesLtlResponse> Available LTL freight rates
+                 *
+                 * @example
+                 * ```typescript
+                 * const ltlRates = await client.shipvia.rates.ltl.list({
+                 *   fromPostalCode: '90210',
+                 *   toPostalCode: '10001',
+                 *   totalWeight: 500,
+                 *   weightUnit: 'LB',
+                 *   locationId: 1,
+                 *   commodityClass: '70',
+                 *   commodityDescription: 'General freight',
+                 *   packagingType: 'PALLET'
+                 * });
+                 * console.log(ltlRates.data); // Array of LTL carrier rates
+                 * ```
+                 */
+                list: async (params) => {
+                    return executeRequest({
+                        method: 'GET',
+                        path: '/shipvia/rates/ltl',
+                        paramsSchema: schemas_1.ShipviaRatesLtlParamsSchema,
+                        responseSchema: schemas_1.ShipviaRatesLtlResponseSchema,
+                    }, params);
+                },
+            },
+        },
+    };
+}
+/**
+ * Creates the shipviaData resource methods (data-only versions)
+ */
+function createShipviaDataResource(shipvia) {
+    return {
+        rates: {
+            /**
+             * Get shipping rates data only
+             * @param params Shipping rate request parameters
+             * @returns Promise<ShipviaRatesData> Shipping rate data array
+             */
+            list: async (params) => {
+                const response = await shipvia.rates.list(params);
+                return response.data;
+            },
+            ltl: {
+                /**
+                 * Get LTL freight rates data only
+                 * @param params LTL rate request parameters
+                 * @returns Promise<ShipviaRatesData> LTL rate data array
+                 */
+                list: async (params) => {
+                    const response = await shipvia.rates.ltl.list(params);
+                    return response.data;
+                },
+            },
+        },
+    };
+}
+//# sourceMappingURL=shipvia.js.map