@de./types 1.0.0

package/src/lsp/pricing.ts

@@ -0,0 +1,1097 @@
+import { Type, Static } from '@sinclair/typebox'
+import { ContextSchema } from '../context'
+import { CurrencySchema } from '../measure'
+import { ActionRecordSchema, DateTimeRangeSchema, DateTimeZoneSchema } from '../time'
+import {
+	APIErrorSchema,
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory
+} from '../api'
+
+
+// Labor & Personnel
+export const LaborChargeTypeSchema = Type.Union([
+  Type.Literal('STANDARD_LABOR'),
+  Type.Literal('SKILLED_LABOR'),
+  Type.Literal('SPECIALIZED_LABOR'),
+  Type.Literal('SUPERVISORY_LABOR'),
+  Type.Literal('OVERTIME_LABOR'),
+  Type.Literal('HOLIDAY_LABOR'),
+  Type.Literal('LABOR_SURCHARGE')
+])
+// Transportation & Delivery
+export const TransportationChargeTypeSchema = Type.Union([
+  Type.Literal('BASE_RATE'),
+  Type.Literal('FUEL_SURCHARGE'),
+  Type.Literal('DELIVERY_CONFIRMATION'),
+  Type.Literal('RESIDENTIAL_DELIVERY'),
+  Type.Literal('OVERSIZE_FEE'),
+  Type.Literal('HAZMAT_FEE'),
+  Type.Literal('PEAK_SEASON_SURCHARGE'),
+  Type.Literal('INSURANCE')
+])
+// Ride Hailing
+export const RideHailingChargeTypeSchema = Type.Union([
+  Type.Literal('PASSENGER_FARE'),
+  Type.Literal('SEAT_RESERVATION_FEE'),
+  Type.Literal('ROUTE_PREMIUM'),
+  Type.Literal('EXPRESS_SERVICE_FEE'),
+  Type.Literal('COMFORT_CLASS_UPGRADE'),
+  Type.Literal('BOOKING_FEE'),
+  Type.Literal('CANCELLATION_FEE'),
+  Type.Literal('PEAK_HOUR_SURCHARGE'),
+  Type.Literal('DYNAMIC_PRICING_ADJUSTMENT')
+])
+
+// Warehouse Operations - Inbound
+export const InboundOperationsChargeTypeSchema = Type.Union([
+  Type.Literal('RECEIVING_FEE'),
+  Type.Literal('PUTAWAY_FEE'),
+  Type.Literal('INVENTORY_COUNT_FEE'),
+  Type.Literal('QUALITY_CONTROL_FEE'),
+  Type.Literal('DECONSOLIDATION_FEE')
+])
+// Warehouse Operations - Storage
+export const StorageChargeTypeSchema = Type.Union([
+  Type.Literal('STORAGE_FEE'),
+  Type.Literal('AMBIENT_STORAGE_FEE'),
+  Type.Literal('REFRIGERATED_STORAGE_FEE'),
+  Type.Literal('FROZEN_STORAGE_FEE'),
+  Type.Literal('CLIMATE_CONTROLLED_STORAGE_FEE'),
+  Type.Literal('HAZMAT_STORAGE_FEE'),
+  Type.Literal('SECURE_STORAGE_FEE')
+])
+// Warehouse Operations - Outbound
+export const OutboundOperationsChargeTypeSchema = Type.Union([
+  Type.Literal('PICKING_FEE'),
+  Type.Literal('PACKING_FEE'),
+  Type.Literal('SHIPPING_FEE'),
+  Type.Literal('KITTING_FEE'),
+  Type.Literal('ASSEMBLY_FEE'),
+  Type.Literal('LABELING_FEE'),
+  Type.Literal('CONSOLIDATION_FEE'),
+  Type.Literal('CROSS_DOCK_FEE')
+])
+// Value-Added Services
+export const ValueAddedServicesChargeTypeSchema = Type.Union([
+  Type.Literal('SORTING_FEE'),
+  Type.Literal('RETURNS_PROCESSING_FEE'),
+  Type.Literal('HANDLING_FEE'),
+  Type.Literal('SPECIALIZED_HANDLING'),
+  Type.Literal('RUSH_ORDER_FEE')
+])
+// Equipment & Space
+export const EquipmentSpaceChargeTypeSchema = Type.Union([
+  Type.Literal('EQUIPMENT_RENTAL'),
+  Type.Literal('SPACE_RENTAL'),
+  Type.Literal('FORKLIFT'),
+  Type.Literal('PALLET_JACK'),
+  Type.Literal('CONVEYOR'),
+  Type.Literal('DOCK_EQUIPMENT'),
+  Type.Literal('PACKAGING_EQUIPMENT'),
+  Type.Literal('SCANNING_EQUIPMENT')
+])
+// Administrative & Compliance
+export const AdministrativeChargeTypeSchema = Type.Union([
+  Type.Literal('DOCUMENTATION_FEE'),
+  Type.Literal('CUSTOMS_DUTY'),
+  Type.Literal('CUSTOMS_CLEARANCE_FEE'),
+  Type.Literal('SETUP_FEE'),
+  Type.Literal('ACCOUNT_MANAGEMENT_FEE'),
+  Type.Literal('TECHNOLOGY_FEE'),
+  Type.Literal('MINIMUM_ACTIVITY_FEE')
+])
+
+// Main charge category schema
+export const ChargeCategorySchema = Type.Union([
+  Type.Literal('LABOR'),
+  Type.Literal('RIDE_HAILING'),
+  Type.Literal('TRANSPORTATION'),
+  Type.Literal('INBOUND_OPERATIONS'),
+  Type.Literal('STORAGE'),
+  Type.Literal('OUTBOUND_OPERATIONS'),
+  Type.Literal('VALUE_ADDED_SERVICES'),
+  Type.Literal('EQUIPMENT_SPACE'),
+  Type.Literal('ADMINISTRATIVE')
+])
+// Combined charge types
+export const ChargeTypeSchema = Type.Union([
+  LaborChargeTypeSchema,
+  RideHailingChargeTypeSchema,
+  TransportationChargeTypeSchema,
+  InboundOperationsChargeTypeSchema,
+  StorageChargeTypeSchema,
+  OutboundOperationsChargeTypeSchema,
+  ValueAddedServicesChargeTypeSchema,
+  EquipmentSpaceChargeTypeSchema,
+  AdministrativeChargeTypeSchema
+])
+
+// Type exports
+export type LaborChargeType = Static<typeof LaborChargeTypeSchema>
+export type RideHailingChargeType = Static<typeof RideHailingChargeTypeSchema>
+export type TransportationChargeType = Static<typeof TransportationChargeTypeSchema>
+export type InboundOperationsChargeType = Static<typeof InboundOperationsChargeTypeSchema>
+export type StorageChargeType = Static<typeof StorageChargeTypeSchema>
+export type OutboundOperationsChargeType = Static<typeof OutboundOperationsChargeTypeSchema>
+export type ValueAddedServicesChargeType = Static<typeof ValueAddedServicesChargeTypeSchema>
+export type EquipmentSpaceChargeType = Static<typeof EquipmentSpaceChargeTypeSchema>
+export type AdministrativeChargeType = Static<typeof AdministrativeChargeTypeSchema>
+export type ChargeCategory = Static<typeof ChargeCategorySchema>
+export type ChargeType = Static<typeof ChargeTypeSchema>
+
+// Helper function for UI/API consumers
+export const ChargeTypeToCategory = {
+  // Labor
+  'STANDARD_LABOR': 'LABOR',
+  'SKILLED_LABOR': 'LABOR',
+  'SPECIALIZED_LABOR': 'LABOR',
+  'SUPERVISORY_LABOR': 'LABOR',
+  'OVERTIME_LABOR': 'LABOR',
+  'HOLIDAY_LABOR': 'LABOR',
+  'LABOR_SURCHARGE': 'LABOR',
+
+  // Add to ChargeTypeToCategory mapping
+  'PASSENGER_FARE': 'RIDE_HAILING',
+  'SEAT_RESERVATION_FEE': 'RIDE_HAILING',
+  'ROUTE_PREMIUM': 'RIDE_HAILING',
+  'EXPRESS_SERVICE_FEE': 'RIDE_HAILING',
+  'COMFORT_CLASS_UPGRADE': 'RIDE_HAILING',
+  'BOOKING_FEE': 'RIDE_HAILING',
+  'CANCELLATION_FEE': 'RIDE_HAILING',
+  'PEAK_HOUR_SURCHARGE': 'RIDE_HAILING',
+  'DYNAMIC_PRICING_ADJUSTMENT': 'RIDE_HAILING',
+
+  // Transportation
+  'BASE_RATE': 'TRANSPORTATION',
+  'FUEL_SURCHARGE': 'TRANSPORTATION',
+  'DELIVERY_CONFIRMATION': 'TRANSPORTATION',
+  'RESIDENTIAL_DELIVERY': 'TRANSPORTATION',
+  'OVERSIZE_FEE': 'TRANSPORTATION',
+  'HAZMAT_FEE': 'TRANSPORTATION',
+  'PEAK_SEASON_SURCHARGE': 'TRANSPORTATION',
+  'INSURANCE': 'TRANSPORTATION',
+  
+  // Inbound Operations
+  'RECEIVING_FEE': 'INBOUND_OPERATIONS',
+  'PUTAWAY_FEE': 'INBOUND_OPERATIONS',
+  'INVENTORY_COUNT_FEE': 'INBOUND_OPERATIONS',
+  'QUALITY_CONTROL_FEE': 'INBOUND_OPERATIONS',
+  'DECONSOLIDATION_FEE': 'INBOUND_OPERATIONS',
+  
+  // Storage
+  'STORAGE_FEE': 'STORAGE',
+  'AMBIENT_STORAGE_FEE': 'STORAGE',
+  'REFRIGERATED_STORAGE_FEE': 'STORAGE',
+  'FROZEN_STORAGE_FEE': 'STORAGE',
+  'CLIMATE_CONTROLLED_STORAGE_FEE': 'STORAGE',
+  'HAZMAT_STORAGE_FEE': 'STORAGE',
+  'SECURE_STORAGE_FEE': 'STORAGE',
+  
+  // Outbound Operations
+  'PICKING_FEE': 'OUTBOUND_OPERATIONS',
+  'PACKING_FEE': 'OUTBOUND_OPERATIONS',
+  'SHIPPING_FEE': 'OUTBOUND_OPERATIONS',
+  'KITTING_FEE': 'OUTBOUND_OPERATIONS',
+  'ASSEMBLY_FEE': 'OUTBOUND_OPERATIONS',
+  'LABELING_FEE': 'OUTBOUND_OPERATIONS',
+  'CONSOLIDATION_FEE': 'OUTBOUND_OPERATIONS',
+  'CROSS_DOCK_FEE': 'OUTBOUND_OPERATIONS',
+  
+  // Value-Added Services
+  'SORTING_FEE': 'VALUE_ADDED_SERVICES',
+  'RETURNS_PROCESSING_FEE': 'VALUE_ADDED_SERVICES',
+  'HANDLING_FEE': 'VALUE_ADDED_SERVICES',
+  'SPECIALIZED_HANDLING': 'VALUE_ADDED_SERVICES',
+  'RUSH_ORDER_FEE': 'VALUE_ADDED_SERVICES',
+  
+  // Equipment & Space
+  'EQUIPMENT_RENTAL': 'EQUIPMENT_SPACE',
+  'SPACE_RENTAL': 'EQUIPMENT_SPACE',
+  'FORKLIFT': 'EQUIPMENT_SPACE',
+  'PALLET_JACK': 'EQUIPMENT_SPACE',
+  'CONVEYOR': 'EQUIPMENT_SPACE',
+  'DOCK_EQUIPMENT': 'EQUIPMENT_SPACE',
+  'PACKAGING_EQUIPMENT': 'EQUIPMENT_SPACE',
+  'SCANNING_EQUIPMENT': 'EQUIPMENT_SPACE',
+  
+  // Administrative
+  'DOCUMENTATION_FEE': 'ADMINISTRATIVE',
+  'CUSTOMS_DUTY': 'ADMINISTRATIVE',
+  'CUSTOMS_CLEARANCE_FEE': 'ADMINISTRATIVE',
+  'SETUP_FEE': 'ADMINISTRATIVE',
+  'ACCOUNT_MANAGEMENT_FEE': 'ADMINISTRATIVE',
+  'TECHNOLOGY_FEE': 'ADMINISTRATIVE',
+  'MINIMUM_ACTIVITY_FEE': 'ADMINISTRATIVE'
+} as const
+
+// Core pricing components
+export const PricingTierCommodityMultiplierSchema = Type.Object({
+  multiplier: Type.Number(),
+  additionalFee: Type.Optional(Type.Number()),
+  specialHandlingRequired: Type.Optional(Type.Boolean())
+})
+export const PricingTierDimensionMultiplierSchema = Type.Object({
+  multiplier: Type.Number(), // Default: 1.0 - Eg. Dimensional weight pricing => cubic cm per kg
+  applyIfGreater: Type.Boolean()
+})
+export const PricingTierTimeMultiplierSchema = Type.Object({
+  timeSlot: Type.Union([
+    Type.Literal('AFTER_HOURS'),
+    Type.Literal('PEAK_HOURS'),
+    Type.Literal('OFF_HOURS'),
+    Type.Literal('WEEKEND'),
+    Type.Literal('HOLIDAY')
+  ]),
+  minimumFee: Type.Optional(Type.Number()),
+  minimumHours: Type.Optional(Type.Number()),
+  multiplier: Type.Number()
+})
+
+export const PricingTierSchema = Type.Object({
+  type: ChargeTypeSchema,
+  category: ChargeCategorySchema,
+  title: Type.String(),
+  description: Type.Optional(Type.String()),
+  minThreshold: Type.Number(),
+  maxThreshold: Type.Optional(Type.Number()),
+  multipliers: Type.Optional(Type.Array(Type.Union([
+    PricingTierCommodityMultiplierSchema,
+    PricingTierDimensionMultiplierSchema,
+    PricingTierTimeMultiplierSchema
+  ]))),
+  unit: Type.String(), // 'kg', 'km', 'cbm', 'pallet', 'shipment', 'sqm', 'units', 'orders'
+  rate: Type.Number(),
+  conditions: Type.Optional(Type.Array(Type.String())),
+  isOptional: Type.Boolean()
+})
+export const PricingModelSchema = Type.Union([
+  // General models
+  Type.Literal('FLAT_RATE'),
+  Type.Literal('TIERED'),
+  Type.Literal('ZONE_BASED'),
+  Type.Literal('WEIGHT_BASED'),
+  Type.Literal('DISTANCE_BASED'),
+  Type.Literal('PRODUCTIVITY_BASED'),
+  Type.Literal('DIMENSIONAL_WEIGHT'),
+  Type.Literal('THROUGHPUT_BASED'),
+  Type.Literal('ACTIVITY_BASED'),
+  Type.Literal('RENTAL_BASED'),
+  Type.Literal('VALUE_BASED'),
+  Type.Literal('USAGE_BASED'),
+  Type.Literal('TIME_BASED'),
+  Type.Literal('HYBRID'),
+  
+  // Warehouse/Hub specific models
+  Type.Literal('PER_ORDER'),
+  Type.Literal('PER_HOUR'),
+  Type.Literal('PER_DAY'),
+  Type.Literal('PER_UNIT'),
+  Type.Literal('PER_PALLET'),
+  Type.Literal('PER_CUBIC_METER'),
+  Type.Literal('PER_SQUARE_METER'),
+  Type.Literal('PER_TRANSACTION'),
+  Type.Literal('PER_LABOR_HOUR'),
+  Type.Literal('PER_HANDLING_UNIT'),
+  Type.Literal('STORAGE_DURATION'),
+  Type.Literal('TIERED_DURATION')
+])
+
+export const AdditionalFeeSchema = Type.Object({
+  type: Type.String(),
+  amount: Type.Number()
+})
+
+export const FuelSurchargeAdjustmentSchema = Type.Object({
+  effectiveDate: Type.String({ format: 'date' }),
+  percentage: Type.Number(),
+  basePrice: Type.Number(), // fuel price baseline
+  calculationMethod: Type.String(),
+  currency: CurrencySchema
+})
+export const SeasonalPricingAdjustmentSchema = Type.Composite([
+  DateTimeRangeSchema,
+  Type.Object({
+    adjustmentType: Type.Union([
+      Type.Literal('MULTIPLIER'),
+      Type.Literal('FIXED_AMOUNT')
+    ]),
+    value: Type.Number(),
+    description: Type.String()
+  })
+])
+export const ContractTermsSchema = Type.Object({
+  type: Type.Union([
+    Type.Literal('SPOT'),
+    Type.Literal('CONTRACT'),
+    Type.Literal('FRAMEWORK')
+  ]),
+  minimumVolume: Type.Optional(Type.Object({
+    quantity: Type.Number(),
+    unit: Type.String(),
+    period: Type.String() // 'monthly', 'quarterly', 'annually'
+  })),
+  currency: CurrencySchema,
+  payment: Type.Object({
+    net: Type.Number(), // Default: 30
+    invoiceFrequency: Type.String() // Default: monthly
+  }),
+  sla: Type.Object({
+    onTimeDelivery: Type.Number(), // percentage
+    damageRate: Type.Number(), // percentage
+    lossRate: Type.Number(), // percentage
+    penalties: Type.Optional(Type.Array(Type.Object({
+      metric: Type.String(),
+      threshold: Type.Number(),
+      penalty: Type.Number(),
+      unit: Type.String()
+    })))
+  }),
+  liabilityLimits: Type.Object({
+    maxLiabilityPerShipment: Type.Number(),
+    maxLiabilityPerIncident: Type.Number()
+  })
+})
+
+// Competitor Pricing Integration && Adjustments
+export const CompetitorPricingSchema = Type.Object({
+  id: Type.String(),
+  serviceName: Type.String(),
+  pricePoint: Type.Number(),
+  currency: Type.String(),
+  route: Type.Optional(Type.String()),
+  serviceLevel: Type.String(),
+  lastUpdated: DateTimeZoneSchema,
+  source: Type.Union([
+    Type.Literal('API_INTEGRATION'),
+    Type.Literal('MANUAL_ENTRY'),
+    Type.Literal('WEB_SCRAPING'),
+    Type.Literal('MARKET_RESEARCH')
+  ]),
+  reliability: Type.Number({ minimum: 0, maximum: 100 }) // Data reliability score
+})
+export const CompetitivePricingAdjustmentSchema = Type.Object({
+  isEnabled: Type.Boolean(),
+  strategy: Type.Union([
+    Type.Literal('MATCH'),           // Match competitor prices
+    Type.Literal('UNDERCUT'),        // Price below competitors
+    Type.Literal('PREMIUM'),         // Price above competitors
+    Type.Literal('DYNAMIC_RESPONSE') // Respond based on market position
+  ]),
+  adjustmentPercentage: Type.Number({ minimum: -50, maximum: 50 }),
+  minimumMargin: Type.Number({ minimum: 0 }), // Don't go below this margin
+  competitorWeights: Type.Record(Type.String(), Type.Number()), // Competitor importance weighting
+  priceFloor: Type.Number({ minimum: 0 }),
+  priceCeiling: Type.Number({ minimum: 0 }),
+  updateTriggers: Type.Array(Type.Object({
+    competitorId: Type.String(),
+    priceChangeThreshold: Type.Number() // Percentage change to trigger adjustment
+  }))
+})
+
+// Pricing rule structure
+export const PricingRuleSchema = Type.Object({
+  context: ContextSchema,
+  id: Type.String(),
+  code: Type.String(),
+  name: Type.String(),
+  version: Type.String(), // Default: 1.0
+  model: PricingModelSchema,
+  // Base pricing
+  currency: CurrencySchema,
+  baseRate: Type.Number(),
+  minimumCharge: Type.Optional(Type.Number()),
+  /**
+   * Pricing tiers
+   * 
+   * Transportation => Weight, distance, volume, value, dimension
+   * Hub/Warehouse => inbound, sorting, routing, packaging, ...
+   */
+  tiers: Type.Array(PricingTierSchema),
+  // Conditions
+  conditions: Type.Optional(Type.Array(Type.String())),
+  exclusions: Type.Optional(Type.Array(Type.String())),
+  // Special handling
+  additionalFees: Type.Optional(Type.Array(AdditionalFeeSchema)),
+  // Seasonal/time-based adjustments
+  seasonalAdjustments: Type.Optional(Type.Array(SeasonalPricingAdjustmentSchema)),
+  // Contact terms
+  contractTerms: Type.Optional(ContractTermsSchema),
+
+  // Metadata
+  tags: Type.Optional(Type.Array(Type.String())),
+  metadata: Type.Optional(Type.Record(Type.String(), Type.Any())),
+
+  // Validity
+  effective: DateTimeZoneSchema,
+  expiry: Type.Optional(DateTimeZoneSchema),
+  
+  added: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+export const PricingRuleTemplateSchema = Type.Object({
+  id: Type.String(),
+  name: Type.String(),
+  description: Type.Optional(Type.String()),
+  category: ChargeCategorySchema,
+  rule: Type.Omit(PricingRuleSchema, ['id', 'context', 'name', 'code', 'added', 'updated'])
+})
+
+// Validation Body schema
+export const PricingRuleValidationScenarioSchema = Type.Array(Type.Object({
+  description: Type.String(),
+  input: Type.Record(Type.String(), Type.Any()), // By tier unit - 'kg', 'km', 'cbm', 'pallet', 'shipment', 'sqm', 'units', 'orders'
+  expectedOutput: Type.Optional(Type.Number())
+}))
+
+// Real - time Market Factors Schema
+export const MarketFactorSchema = Type.Object({
+  factorType: Type.Union([
+    Type.Literal('DEMAND_SURGE'),
+    Type.Literal('CAPACITY_UTILIZATION'),
+    Type.Literal('FUEL_PRICE_FLUCTUATION'),
+    Type.Literal('COMPETITOR_RATE_CHANGE'),
+    Type.Literal('WEATHER_IMPACT'),
+    Type.Literal('TRAFFIC_CONGESTION'),
+    Type.Literal('DRIVER_AVAILABILITY'),
+    Type.Literal('EQUIPMENT_SHORTAGE'),
+    Type.Literal('MARKET_VOLATILITY')
+  ]),
+  currentValue: Type.Number(),
+  threshold: Type.Object({
+    min: Type.Number(),
+    max: Type.Number(),
+    trigger: Type.Number() // Value that triggers pricing adjustment
+  }),
+  multiplier: Type.Number({ minimum: 0.1, maximum: 10 }),
+  maxImpact: Type.Number({ minimum: 0, maximum: 500 }), // Max percentage impact
+  refreshInterval: Type.Number({ description: 'minutes' }),
+  isActive: Type.Boolean(),
+  validityPeriod: Type.Optional(Type.Object({
+    start: DateTimeZoneSchema,
+    end: DateTimeZoneSchema
+  }))
+})
+export const DynamicPricingEngineSchema = Type.Object({
+  id: Type.String(),
+  name: Type.String(),
+  isEnabled: Type.Boolean(),
+
+  // Market-driven adjustments
+  marketFactors: Type.Array(MarketFactorSchema),
+
+  // Surge pricing configuration
+  surgePricing: Type.Object({
+    isEnabled: Type.Boolean(),
+    demandThresholds: Type.Array(Type.Object({
+      demandLevel: Type.Number({ minimum: 0, maximum: 100 }),
+      multiplier: Type.Number({ minimum: 1, maximum: 5 }),
+      description: Type.String()
+    })),
+    maxSurgeMultiplier: Type.Number({ minimum: 1, maximum: 10 }),
+    cooldownPeriod: Type.Number({ description: 'minutes after surge ends' })
+  }),
+
+  // Capacity-based adjustments
+  capacityPricing: Type.Object({
+    utilizationBands: Type.Array(Type.Object({
+      minUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+      maxUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+      priceAdjustment: Type.Number(), // Positive or negative percentage
+      description: Type.String()
+    })),
+    realTimeCapacityTracking: Type.Boolean()
+  }),
+
+  updateFrequency: Type.Number({ description: 'seconds between price recalculations' }),
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Performance-based Pricing Adjustments
+export const PricingPerformanceMetricSchema = Type.Object({
+  metricType: Type.Union([
+    Type.Literal('ON_TIME_PERFORMANCE'),
+    Type.Literal('DELIVERY_SUCCESS_RATE'),
+    Type.Literal('DAMAGE_RATE'),
+    Type.Literal('CUSTOMER_SATISFACTION'),
+    Type.Literal('VEHICLE_UTILIZATION'),
+    Type.Literal('FUEL_EFFICIENCY'),
+    Type.Literal('DRIVER_RATING'),
+    Type.Literal('RESPONSE_TIME')
+  ]),
+  currentValue: Type.Number(),
+  targetValue: Type.Number(),
+  benchmark: Type.Number(), // Industry or company benchmark
+  trend: Type.Union([
+    Type.Literal('IMPROVING'),
+    Type.Literal('DECLINING'),
+    Type.Literal('STABLE')
+  ]),
+  impact: Type.Union([
+    Type.Literal('POSITIVE'), // Good performance = lower prices or premium service
+    Type.Literal('NEGATIVE')  // Poor performance = higher prices or discounts
+  ])
+})
+export const PricingPerformanceBasedAdjustmentSchema = Type.Object({
+  isEnabled: Type.Boolean(),
+  metrics: Type.Array(PricingPerformanceMetricSchema),
+  adjustmentRules: Type.Array(Type.Object({
+    metricType: Type.String(),
+    threshold: Type.Number(),
+    operator: Type.Union([
+      Type.Literal('GREATER_THAN'),
+      Type.Literal('LESS_THAN'),
+      Type.Literal('EQUALS'),
+      Type.Literal('BETWEEN')
+    ]),
+    adjustment: Type.Object({
+      type: Type.Union([
+        Type.Literal('PERCENTAGE'),
+        Type.Literal('FIXED_AMOUNT'),
+        Type.Literal('TIER_CHANGE')
+      ]),
+      value: Type.Number(),
+      maxImpact: Type.Number() // Maximum adjustment allowed
+    }),
+    duration: Type.Optional(Type.Number()) // How long adjustment lasts (hours)
+  })),
+  evaluationFrequency: Type.Number({ description: 'hours between performance evaluations' })
+})
+
+// Advanced Real - time Capacity Management
+export const PricingRealTimeCapacitySchema = Type.Object({
+  resourceType: Type.Union([
+    Type.Literal('VEHICLES'),
+    Type.Literal('DRIVERS'),
+    Type.Literal('WAREHOUSE_SPACE'),
+    Type.Literal('LOADING_DOCKS'),
+    Type.Literal('EQUIPMENT'),
+    Type.Literal('ROUTE_SLOTS')
+  ]),
+  totalCapacity: Type.Number(),
+  availableCapacity: Type.Number(),
+  reservedCapacity: Type.Number(),
+  utilizationRate: Type.Number({ minimum: 0, maximum: 100 }),
+
+  // Forecasting
+  projectedDemand: Type.Object({
+    nextHour: Type.Number(),
+    next4Hours: Type.Number(),
+    next24Hours: Type.Number()
+  }),
+
+  // Capacity constraints
+  constraints: Type.Array(Type.Object({
+    constraintType: Type.String(),
+    description: Type.String(),
+    impact: Type.Number(), // Percentage reduction in effective capacity
+    startTime: Type.Optional(DateTimeZoneSchema),
+    endTime: Type.Optional(DateTimeZoneSchema)
+  })),
+
+  lastUpdated: DateTimeZoneSchema
+})
+
+// Dynamic Pricing Rule Capability
+export const DynamicPricingRuleSchema = Type.Composite([
+  PricingRuleSchema,
+  Type.Object({
+    engine: Type.Optional(Type.String()), // Reference to DynamicPricingEngine ID
+
+    // Real-time adjustments
+    realTimeFactors: Type.Optional(Type.Array(Type.String())), // MarketFactor IDs
+    competitivePricing: Type.Optional(CompetitivePricingAdjustmentSchema),
+    performanceAdjustments: Type.Optional(PricingPerformanceBasedAdjustmentSchema),
+
+    // Advanced constraints
+    constraints: Type.Object({
+      maxDailyAdjustments: Type.Optional(Type.Number()),
+      maxAdjustmentPercentage: Type.Optional(Type.Number()),
+      priceStabilityPeriod: Type.Optional(Type.Number()), // Minutes before new adjustment
+      blackoutPeriods: Type.Optional(Type.Array(Type.Object({
+        start: DateTimeZoneSchema,
+        end: DateTimeZoneSchema,
+        reason: Type.String()
+      })))
+    }),
+
+    // A/B Testing support
+    experimentalPricing: Type.Optional(Type.Object({
+      isActive: Type.Boolean(),
+      testVariants: Type.Array(Type.Object({
+        variantId: Type.String(),
+        name: Type.String(),
+        adjustmentPercentage: Type.Number(),
+        trafficAllocation: Type.Number({ minimum: 0, maximum: 100 }),
+        startDate: DateTimeZoneSchema,
+        endDate: DateTimeZoneSchema
+      })),
+      successMetric: Type.String()
+    }))
+  })
+])
+
+// Pricing Analytics and Monitoring
+export const PricingAnalyticsSchema = Type.Object({
+  ruleId: Type.String(),
+  period: Type.Object({
+    start: DateTimeZoneSchema,
+    end: DateTimeZoneSchema
+  }),
+
+  // Performance metrics
+  metrics: Type.Object({
+    totalQuotes: Type.Number(),
+    acceptanceRate: Type.Number({ minimum: 0, maximum: 100 }),
+    averagePricePoint: Type.Number(),
+    revenueGenerated: Type.Number(),
+    marginPercentage: Type.Number(),
+    competitivenessScore: Type.Number({ minimum: 0, maximum: 100 })
+  }),
+
+  // Dynamic adjustments made
+  adjustments: Type.Array(Type.Object({
+    timestamp: DateTimeZoneSchema,
+    triggerType: Type.String(),
+    triggerValue: Type.Number(),
+    adjustmentPercentage: Type.Number(),
+    duration: Type.Number(), // Minutes adjustment was active
+    impact: Type.Object({
+      quoteVolume: Type.Number(),
+      acceptanceRate: Type.Number()
+    })
+  })),
+
+  // Optimization recommendations
+  recommendations: Type.Optional(Type.Array(Type.Object({
+    type: Type.Union([
+      Type.Literal('PRICE_INCREASE'),
+      Type.Literal('PRICE_DECREASE'),
+      Type.Literal('TIER_ADJUSTMENT'),
+      Type.Literal('TIME_MULTIPLIER_CHANGE'),
+      Type.Literal('CAPACITY_OPTIMIZATION')
+    ]),
+    confidence: Type.Number({ minimum: 0, maximum: 100 }),
+    expectedImpact: Type.String(),
+    implementation: Type.String()
+  })))
+})
+
+// Type exports
+export type PricingTierCommodityMultiplier = Static<typeof PricingTierCommodityMultiplierSchema>
+export type PricingTierDimensionMultiplier = Static<typeof PricingTierDimensionMultiplierSchema>
+export type PricingTierTimeMultiplier = Static<typeof PricingTierTimeMultiplierSchema>
+export type PricingTier = Static<typeof PricingTierSchema>
+export type PricingModel = Static<typeof PricingModelSchema>
+export type PricingRule = Static<typeof PricingRuleSchema>
+export type DynamicPricingEngine = Static<typeof DynamicPricingEngineSchema>
+export type DynamicPricingRule = Static<typeof DynamicPricingRuleSchema>
+export type PricingRuleTemplate = Static<typeof PricingRuleTemplateSchema>
+export type PricingRuleValidationScenario = Static<typeof PricingRuleValidationScenarioSchema>
+export type MarketFactor = Static<typeof MarketFactorSchema>
+export type CompetitorPricing = Static<typeof CompetitorPricingSchema>
+export type CompetitivePricingAdjustment = Static<typeof CompetitivePricingAdjustmentSchema>
+export type PricingPerformanceMetric = Static<typeof PricingPerformanceMetricSchema>
+export type PricingPerformanceBasedAdjustment = Static<typeof PricingPerformanceBasedAdjustmentSchema>
+export type PricingRealTimeCapacity = Static<typeof PricingRealTimeCapacitySchema>
+export type PricingAnalytics = Static<typeof PricingAnalyticsSchema>
+export type AdditionalFee = Static<typeof AdditionalFeeSchema>
+export type ContractTerms = Static<typeof ContractTermsSchema>
+export type FuelSurchargeAdjustment = Static<typeof FuelSurchargeAdjustmentSchema>
+export type SeasonalPricingAdjustment = Static<typeof SeasonalPricingAdjustmentSchema>
+
+// ─── Request Validation Schemas ───────────────────────────────────────────────
+
+const OMIT_PRICING_FIELDS = ['id', 'context', 'tiers', 'contactTerms', 'seasonnalAdjustments', 'added', 'updated'] as const
+
+const PricingRuleQuerySchema = Type.Object({
+	category: Type.Optional(ChargeCategorySchema),
+	model:    Type.Optional(PricingModelSchema),
+	active:   Type.Optional(Type.Boolean()),
+	tags:     Type.Optional(Type.String()),
+	limit:    Type.Optional(Type.Number({ minimum: 1, maximum: 100, default: 20 })),
+	offset:   Type.Optional(Type.Number({ minimum: 0, default: 0 }))
+})
+
+export const LSPPricingAddRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Omit(PricingRuleSchema, OMIT_PRICING_FIELDS),
+	response: {
+		201:   APIResponseDataSchemaFactory({ ruleId: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingRetrieveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ rule: PricingRuleSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingFetchRVS = {
+	headers:     APIHeadersSchema,
+	querystring: PricingRuleQuerySchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ rules: Type.Array(PricingRuleSchema), total: Type.Number(), hasMore: Type.Boolean() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingUpdateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Partial(Type.Omit(PricingRuleSchema, OMIT_PRICING_FIELDS)),
+	response: {
+		200:   APIResponseDataSchemaFactory({ rule: PricingRuleSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingRemoveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: {
+		200:   APIResponseBaseSchema,
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingAddTierRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     PricingTierSchema,
+	response: {
+		201:   APIResponseBaseSchema,
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingUpdateTierRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String(), index: Type.Number() }),
+	body:     Type.Partial(PricingTierSchema),
+	response: {
+		200:   APIResponseDataSchemaFactory({ tier: PricingTierSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingRemoveTierRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String(), index: Type.Number() }),
+	response: {
+		200:   APIResponseBaseSchema,
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingAddSeasonalAdjustmentRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     SeasonalPricingAdjustmentSchema,
+	response: {
+		201:   APIResponseBaseSchema,
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingRemoveSeasonalAdjustmentRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String(), index: Type.Number() }),
+	response: {
+		200:   APIResponseBaseSchema,
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingUpdateFuelSurchargeRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     FuelSurchargeAdjustmentSchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({ fuelSurcharge: FuelSurchargeAdjustmentSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingBulkUpdateByCategoryRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Object({
+		category: ChargeCategorySchema,
+		updates:  Type.Object({
+			multiplier:    Type.Optional(Type.Number()),
+			additionalFee: Type.Optional(Type.Number()),
+			tags:          Type.Optional(Type.Array(Type.String()))
+		}),
+		filters: Type.Optional(Type.Object({
+			tags:  Type.Optional(Type.Array(Type.String())),
+			model: Type.Optional(PricingModelSchema)
+		}))
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ updatedCount: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingAddContractTermsRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     ContractTermsSchema,
+	response: {
+		201:   APIResponseBaseSchema,
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingUpdateContractTermsRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Partial(ContractTermsSchema),
+	response: {
+		200:   APIResponseDataSchemaFactory({ contract: ContractTermsSchema, message: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingValidateRVS = {
+	headers:  APIHeadersSchema,
+	body:     PricingRuleValidationScenarioSchema,
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			isValid:  Type.Boolean(),
+			errors:   Type.Array(Type.String()),
+			warnings: Type.Array(Type.String()),
+			results:  Type.Optional(Type.Array(Type.Object({
+				scenario:       Type.String(),
+				passed:         Type.Boolean(),
+				calculatedPrice: Type.Number(),
+				expectedPrice:  Type.Optional(Type.Number()),
+				details:        Type.String()
+			})))
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingGetTemplatesRVS = {
+	headers:     APIHeadersSchema,
+	querystring: Type.Object({
+		category: Type.Optional(ChargeCategorySchema),
+		tag:      Type.Optional(Type.String())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({
+			templates: Type.Array(Type.Object({
+				id:          Type.String(),
+				name:        Type.String(),
+				description: Type.String(),
+				category:    ChargeCategorySchema,
+				template:    PricingRuleSchema
+			}))
+		}),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingCreateFromTemplateRVS = {
+	headers:  APIHeadersSchema,
+	body:     Type.Object({
+		templateId:     Type.String(),
+		customizations: Type.Optional(Type.Record(Type.String(), Type.Any())),
+		name:           Type.String(),
+		code:           Type.String()
+	}),
+	response: {
+		201:   APIResponseDataSchemaFactory({ ruleId: Type.String(), rule: PricingRuleSchema, message: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPricingBindToRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({
+		id:     Type.String(),
+		action: Type.Union([Type.Literal('add'), Type.Literal('remove')])
+	}),
+	body:     Type.Object({
+		id:   Type.Optional(Type.String()),
+		code: Type.Optional(Type.String())
+	}),
+	response: {
+		200:   APIResponseBaseSchema,
+		'4XX': APIErrorSchema
+	}
+}
+
+export type LSPPricingAddValidation                      = { body: Static<typeof LSPPricingAddRVS.body>, response: Static<(typeof LSPPricingAddRVS.response)[201]> }
+export type LSPPricingRetrieveValidation                = { params: Static<typeof LSPPricingRetrieveRVS.params>, response: Static<(typeof LSPPricingRetrieveRVS.response)[200]> }
+export type LSPPricingFetchValidation                   = { querystring: Static<typeof LSPPricingFetchRVS.querystring>, response: Static<(typeof LSPPricingFetchRVS.response)[200]> }
+export type LSPPricingUpdateValidation                  = { params: Static<typeof LSPPricingUpdateRVS.params>, body: Static<typeof LSPPricingUpdateRVS.body>, response: Static<(typeof LSPPricingUpdateRVS.response)[200]> }
+export type LSPPricingRemoveValidation                  = { params: Static<typeof LSPPricingRemoveRVS.params>, response: Static<(typeof LSPPricingRemoveRVS.response)[200]> }
+export type LSPPricingAddTierValidation                 = { params: Static<typeof LSPPricingAddTierRVS.params>, body: Static<typeof LSPPricingAddTierRVS.body>, response: Static<(typeof LSPPricingAddTierRVS.response)[201]> }
+export type LSPPricingUpdateTierValidation              = { params: Static<typeof LSPPricingUpdateTierRVS.params>, body: Static<typeof LSPPricingUpdateTierRVS.body>, response: Static<(typeof LSPPricingUpdateTierRVS.response)[200]> }
+export type LSPPricingRemoveTierValidation              = { params: Static<typeof LSPPricingRemoveTierRVS.params>, response: Static<(typeof LSPPricingRemoveTierRVS.response)[200]> }
+export type LSPPricingAddSeasonalAdjustmentValidation   = { params: Static<typeof LSPPricingAddSeasonalAdjustmentRVS.params>, body: Static<typeof LSPPricingAddSeasonalAdjustmentRVS.body>, response: Static<(typeof LSPPricingAddSeasonalAdjustmentRVS.response)[201]> }
+export type LSPPricingRemoveSeasonalAdjustmentValidation = { params: Static<typeof LSPPricingRemoveSeasonalAdjustmentRVS.params>, response: Static<(typeof LSPPricingRemoveSeasonalAdjustmentRVS.response)[200]> }
+export type LSPPricingUpdateFuelSurchargeValidation     = { params: Static<typeof LSPPricingUpdateFuelSurchargeRVS.params>, body: Static<typeof LSPPricingUpdateFuelSurchargeRVS.body>, response: Static<(typeof LSPPricingUpdateFuelSurchargeRVS.response)[200]> }
+export type LSPPricingBulkUpdateByCategoryValidation    = { body: Static<typeof LSPPricingBulkUpdateByCategoryRVS.body>, response: Static<(typeof LSPPricingBulkUpdateByCategoryRVS.response)[200]> }
+export type LSPPricingAddContractTermsValidation        = { params: Static<typeof LSPPricingAddContractTermsRVS.params>, body: Static<typeof LSPPricingAddContractTermsRVS.body>, response: Static<(typeof LSPPricingAddContractTermsRVS.response)[201]> }
+export type LSPPricingUpdateContractTermsValidation     = { params: Static<typeof LSPPricingUpdateContractTermsRVS.params>, body: Static<typeof LSPPricingUpdateContractTermsRVS.body>, response: Static<(typeof LSPPricingUpdateContractTermsRVS.response)[200]> }
+export type LSPPricingValidateValidation                = { body: Static<typeof LSPPricingValidateRVS.body>, response: Static<(typeof LSPPricingValidateRVS.response)[200]> }
+export type LSPPricingGetTemplatesValidation            = { querystring: Static<typeof LSPPricingGetTemplatesRVS.querystring>, response: Static<(typeof LSPPricingGetTemplatesRVS.response)[200]> }
+export type LSPPricingCreateFromTemplateValidation      = { body: Static<typeof LSPPricingCreateFromTemplateRVS.body>, response: Static<(typeof LSPPricingCreateFromTemplateRVS.response)[201]> }
+export type LSPPricingBindToValidation                  = { params: Static<typeof LSPPricingBindToRVS.params>, body: Static<typeof LSPPricingBindToRVS.body>, response: Static<(typeof LSPPricingBindToRVS.response)[200]> }
+
+// export type PricingQuote = Static<typeof PricingQuoteSchema>
+// export type StoragePricing = Static<typeof StoragePricingSchema>
+// export type LaborPricing = Static<typeof LaborPricingSchema>
+// export type EquipmentPricing = Static<typeof EquipmentPricingSchema>
+// export type ThroughputPricing = Static<typeof ThroughputPricingSchema>
+
+// Helper schemas for different LSP quote requests
+// export const TransportationQuoteRequestSchema = Type.Object({
+//   shipment: Type.Object({
+//     origin: Type.Object({
+//       postalCode: Type.String(),
+//       city: Type.String(),
+//       country: Type.String()
+//     }),
+//     destination: Type.Object({
+//       postalCode: Type.String(),
+//       city: Type.String(),
+//       country: Type.String()
+//     }),
+//     packages: Type.Array(Type.Object({
+//       weight: Type.Number(),
+//       weightUnit: Type.String({ default: 'kg' }),
+//       dimensions: Type.Object({
+//         length: Type.Number(),
+//         width: Type.Number(),
+//         height: Type.Number(),
+//         unit: Type.String({ default: 'cm' })
+//       }),
+//       value: Type.Optional(Type.Number()),
+//       commodityCode: Type.Optional(Type.String())
+//     })),
+//     serviceCode: Type.Optional(Type.String()),
+//     shipDate: Type.String({ format: 'date' }),
+//     deliveryDate: Type.Optional(Type.String({ format: 'date' }))
+//   }),
+//   options: Type.Optional(Type.Object({
+//     insurance: Type.Optional(Type.Boolean()),
+//     signatureRequired: Type.Optional(Type.Boolean()),
+//     residentialDelivery: Type.Optional(Type.Boolean()),
+//     customsClearance: Type.Optional(Type.Boolean())
+//   }))
+// })
+// export const WarehouseQuoteRequestSchema = Type.Object({
+//   services: Type.Array(Type.Object({
+//     serviceType: ServiceTypeSchema,
+//     quantity: Type.Number(),
+//     unit: Type.String(), // 'pallets', 'units', 'cbm', 'orders'
+//     duration: Type.Optional(Type.Object({
+//       value: Type.Number(),
+//       unit: Type.String() // 'days', 'months', 'ongoing'
+//     })),
+//     specialRequirements: Type.Optional(Type.Array(Type.String()))
+//   })),
+//   facilityRequirements: Type.Optional(Type.Object({
+//     storageType: Type.Optional(Type.Array(Type.String())),
+//     location: Type.Optional(Type.Object({
+//       city: Type.String(),
+//       country: Type.String(),
+//       proximityRequirements: Type.Optional(Type.Array(Type.String()))
+//     })),
+//     equipmentNeeded: Type.Optional(Type.Array(Type.String()))
+//   })),
+//   volumeProjections: Type.Optional(Type.Object({
+//     monthly: Type.Number(),
+//     seasonal: Type.Optional(Type.Array(Type.Object({
+//       month: Type.String(),
+//       multiplier: Type.Number()
+//     })))
+//   })),
+//   startDate: Type.String({ format: 'date' }),
+//   contractDuration: Type.Optional(Type.String())
+// })
+
+// Updated main quote request to handle both types
+// export const PriceRequestSchema = Type.Object({
+//   requestType: Type.Union([
+//     Type.Literal('TRANSPORTATION'),
+//     Type.Literal('WAREHOUSING'),
+//     Type.Literal('FULFILLMENT'),
+//     Type.Literal('MIXED_SERVICES')
+//   ]),
+//   transportationRequest: Type.Optional(TransportationQuoteRequestSchema),
+//   warehouseRequest: Type.Optional(WarehouseQuoteRequestSchema),
+//   requestId: Type.Optional(Type.String()),
+//   customerId: Type.Optional(Type.String()),
+//   urgency: Type.Optional(Type.Union([
+//     Type.Literal('STANDARD'),
+//     Type.Literal('URGENT'),
+//     Type.Literal('RUSH')
+//   ]))
+// })
+// export const PriceResponseSchema = Type.Object({
+//   quotes: Type.Array(Type.Object({
+//     serviceCode: Type.String(),
+//     serviceName: Type.String(),
+//     serviceType: ServiceTypeSchema,
+//     totalCost: Type.Number(),
+//     currency: Type.String(),
+//     transitTime: Type.Optional(Type.Object({
+//       min: Type.Number(),
+//       max: Type.Number(),
+//       unit: Type.String()
+//     })),
+//     breakdown: Type.Object({
+//       baseRate: Type.Number(),
+      
+//       // Transportation specific
+//       fuelSurcharge: Type.Optional(Type.Number()),
+      
+//       // Warehouse specific
+//       storageCosts: Type.Optional(Type.Array(Type.Object({
+//         storageType: Type.String(),
+//         amount: Type.Number(),
+//         unit: Type.String(),
+//         duration: Type.Optional(Type.String())
+//       }))),
+//       laborCosts: Type.Optional(Type.Array(Type.Object({
+//         laborType: Type.String(),
+//         amount: Type.Number(),
+//         hours: Type.Optional(Type.Number())
+//       }))),
+//       equipmentCosts: Type.Optional(Type.Array(Type.Object({
+//         equipmentType: Type.String(),
+//         amount: Type.Number(),
+//         usage: Type.Optional(Type.String())
+//       }))),
+      
+//       // Common
+//       accessorialCharges: Type.Array(Type.Object({
+//         chargeCode: Type.String(),
+//         chargeName: Type.String(),
+//         amount: Type.Number()
+//       })),
+//       taxes: Type.Optional(Type.Number())
+//     }),
+//     capacity: Type.Optional(Type.Object({
+//       available: Type.Boolean(),
+//       constraints: Type.Optional(Type.Array(Type.String()))
+//     })),
+//     validUntil: Type.String({ format: 'date-time' })
+//   }))
+// })
+
+// export type PriceRequest = Static<typeof PriceRequestSchema>
+// export type PriceResponse = Static<typeof PriceResponseSchema>
+// export type TransportationQuoteRequest = Static<typeof TransportationQuoteRequestSchema>
+// export type WarehouseQuoteRequest = Static<typeof WarehouseQuoteRequestSchema>