@de./types 1.0.0

package/src/lsp/terminal/utilities.ts

@@ -0,0 +1,173 @@
+import { Type, Static } from '@sinclair/typebox'
+import { DurationSchema } from '../../time'
+import { DimensionsSchema, WeightSchema, ServiceLevelSchema, MoneySchema, AreaSchema, LengthSchema, DistanceSchema } from '../../measure'
+import { TerminalCapabilitySchema } from './capabilities'
+import { TerminalCapacitySchema } from './capacities'
+
+// Terminal matching and selection criteria
+export const TerminalMatchingCriteriaSchema = Type.Object({
+  requiredCapability: Type.Partial(TerminalCapabilitySchema),
+  requiredCapacity: Type.Partial(TerminalCapacitySchema),
+  
+  serviceRequirements: Type.Object({
+    serviceLevels: Type.Array(ServiceLevelSchema),
+    minimumThroughput: Type.Number({ minimum: 0 }),
+    maxVesselTurnaroundTime: DurationSchema,
+    maxCargoHandlingTime: DurationSchema,
+    minimumAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+    minimumReliability: Type.Number({ minimum: 0, maximum: 100 }),
+    geographicCoverage: Type.Array(Type.String())
+  }),
+  
+  vesselRequirements: Type.Optional(Type.Object({
+    maxVesselSize: DimensionsSchema,
+    vesselTypes: Type.Array(Type.String()),
+    maxDraft: LengthSchema,
+    berthRequirements: Type.Array(Type.String()),
+    pilotageRequired: Type.Boolean(),
+    tuggingRequired: Type.Boolean(),
+    vesselServicesRequired: Type.Array(Type.String())
+  })),
+  
+  cargoRequirements: Type.Optional(Type.Object({
+    cargoTypes: Type.Array(Type.String()),
+    containerTypes: Type.Array(Type.String()),
+    specialHandling: Type.Array(Type.String()),
+    storageRequirements: Type.Array(Type.String()),
+    temperatureControl: Type.Boolean(),
+    hazmatHandling: Type.Boolean(),
+    customsClearance: Type.Boolean(),
+    quarantineServices: Type.Boolean()
+  })),
+  
+  infrastructureRequirements: Type.Optional(Type.Object({
+    berthLength: LengthSchema,
+    channelDepth: LengthSchema,
+    craneCapacity: WeightSchema,
+    storageArea: AreaSchema,
+    railConnections: Type.Boolean(),
+    roadConnections: Type.Boolean(),
+    intermodalFacilities: Type.Boolean(),
+    refrigeratedStorage: Type.Boolean(),
+    warehouseFacilities: Type.Boolean()
+  })),
+  
+  technologyRequirements: Type.Optional(Type.Object({
+    terminalOperatingSystem: Type.Boolean(),
+    automationLevel: Type.Optional(Type.Union([
+      Type.Literal('MANUAL'),
+      Type.Literal('SEMI_AUTOMATED'),
+      Type.Literal('HIGHLY_AUTOMATED'),
+      Type.Literal('FULLY_AUTOMATED')
+    ])),
+    trackingCapabilities: Type.Boolean(),
+    apiIntegration: Type.Boolean(),
+    realTimeVisibility: Type.Boolean(),
+    portCommunitySystem: Type.Boolean(),
+    digitalDocumentation: Type.Boolean(),
+    mobileAccess: Type.Boolean()
+  })),
+  
+  complianceRequirements: Type.Optional(Type.Object({
+    requiredCertifications: Type.Array(Type.String()),
+    securityLevel: Type.Union([
+      Type.Literal('MARSEC_1'),
+      Type.Literal('MARSEC_2'),
+      Type.Literal('MARSEC_3')
+    ]),
+    customsBonded: Type.Boolean(),
+    freeTradeZone: Type.Boolean(),
+    hazmatCertified: Type.Boolean(),
+    environmentalCompliance: Type.Boolean(),
+    ispsCompliance: Type.Boolean(),
+    ctpatCertification: Type.Boolean()
+  })),
+  
+  locationRequirements: Type.Optional(Type.Object({
+    preferredRegions: Type.Array(Type.String()),
+    maxDistanceFromPort: DistanceSchema,
+    proximityToMarkets: DistanceSchema,
+    transportConnections: Type.Array(Type.String()),
+    timeZonePreference: Type.Optional(Type.String()),
+    proximityToAirports: Type.Optional(DistanceSchema),
+    proximityToRailheads: Type.Optional(DistanceSchema),
+    proximityToHighways: Type.Optional(DistanceSchema)
+  })),
+  
+  performanceRequirements: Type.Optional(Type.Object({
+    minimumEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+    minimumReliability: Type.Number({ minimum: 0, maximum: 100 }),
+    maximumTurnaroundTime: DurationSchema,
+    minimumProductivity: Type.Number({ minimum: 0 }),
+    minimumAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+    minimumUptime: Type.Number({ minimum: 0, maximum: 100 }),
+    slaRequirements: Type.Record(ServiceLevelSchema, Type.Object({
+      maxProcessingTime: DurationSchema,
+      minAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+      maxDowntime: DurationSchema
+    }))
+  })),
+  
+  weightings: Type.Optional(Type.Object({
+    capability: Type.Number({ minimum: 0, maximum: 100 }),
+    capacity: Type.Number({ minimum: 0, maximum: 100 }),
+    performance: Type.Number({ minimum: 0, maximum: 100 }),
+    cost: Type.Number({ minimum: 0, maximum: 100 }),
+    location: Type.Number({ minimum: 0, maximum: 100 }),
+    technology: Type.Number({ minimum: 0, maximum: 100 }),
+    compliance: Type.Number({ minimum: 0, maximum: 100 }),
+    reliability: Type.Number({ minimum: 0, maximum: 100 }),
+    sustainability: Type.Number({ minimum: 0, maximum: 100 })
+  })),
+  
+  mustHave: Type.Optional(Type.Array(Type.String())),
+  niceToHave: Type.Optional(Type.Array(Type.String())),
+  dealBreakers: Type.Optional(Type.Array(Type.String())),
+  
+  budgetConstraints: Type.Optional(Type.Object({
+    maxHandlingCost: MoneySchema,
+    maxServiceCost: MoneySchema,
+    maxTotalCost: MoneySchema,
+    maxBerthingCost: MoneySchema,
+    maxStorageCost: MoneySchema,
+    costModel: Type.Union([
+      Type.Literal('FIXED'),
+      Type.Literal('VARIABLE'),
+      Type.Literal('HYBRID'),
+      Type.Literal('PERFORMANCE_BASED')
+    ]),
+    paymentTerms: Type.Optional(Type.String()),
+    volumeCommitments: Type.Optional(Type.Object({
+      minimumVolume: Type.Number({ minimum: 0 }),
+      commitmentPeriod: Type.Number({ minimum: 0, description: 'months' })
+    }))
+  })),
+  
+  riskPreferences: Type.Optional(Type.Object({
+    riskTolerance: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH')
+    ]),
+    redundancyRequirement: Type.Boolean(),
+    backupTerminalRequired: Type.Boolean(),
+    businessContinuityRequirement: Type.Boolean(),
+    weatherRiskTolerance: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH')
+    ]),
+    politicalRiskTolerance: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH')
+    ]),
+    insuranceRequirements: Type.Optional(Type.Object({
+      minimumCoverage: MoneySchema,
+      liabilityRequirements: Type.Array(Type.String())
+    }))
+  }))
+})
+
+// Terminal Integration and Analytics Types
+export type TerminalMatchingCriteria = Static<typeof TerminalMatchingCriteriaSchema>

package/src/lsp/warehouse/analytics.ts

@@ -0,0 +1,248 @@
+import { Type, Static } from '@sinclair/typebox'
+import { EntityStatusSchema } from '../../entity'
+import { DurationSchema } from '../../time'
+import { MoneySchema, PerTimeSchema, AreaSchema, VolumeSchema, WeightSchema, DistanceSchema, PerAreaSchema } from '../../measure'
+import { WarehouseCapabilitiesSchema } from './capabilities'
+import { WarehouseCapacitySchema } from './capacities'
+
+// Local definition to avoid circular dependency with warehouse/index
+const WarehouseTypeSchema = Type.Union([
+  Type.Literal('STORAGE'),
+  Type.Literal('DISTRIBUTION'),
+  Type.Literal('FULFILLMENT'),
+  Type.Literal('CROSS_DOCK'),
+  Type.Literal('RETURNS'),
+  Type.Literal('CUSTOMS-BONDED'),
+  Type.Literal('VALUE-ADDED')
+])
+
+// ===== WAREHOUSE ANALYTICS SECTION =====
+
+// Demand analysis and forecasting
+export const WarehouseDemandAnalysisSchema = Type.Object({
+  historicalDemand: Type.Array(Type.Object({
+    period: Type.String(),
+    actualVolume: Type.Number(),
+    peakVolume: Type.Number(),
+    averageVolume: Type.Number(),
+    serviceLevel: Type.Optional(Type.String()),
+    seasonalityFactor: Type.Number()
+  })),
+  
+  forecastedDemand: Type.Array(Type.Object({
+    period: Type.String(),
+    forecastedVolume: Type.Number(),
+    confidenceLevel: Type.Number({ minimum: 0, maximum: 100 }),
+    seasonalityFactor: Type.Number(),
+    growthRate: Type.Number(),
+    demandVariability: Type.Number()
+  })),
+  
+  demandDrivers: Type.Array(Type.Object({
+    driver: Type.String(),
+    impact: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH'),
+      Type.Literal('CRITICAL')
+    ]),
+    description: Type.String(),
+    correlation: Type.Number({ minimum: -1, maximum: 1 })
+  })),
+  
+  seasonalPatterns: Type.Array(Type.Object({
+    season: Type.String(),
+    volumeMultiplier: Type.Number({ minimum: 0 }),
+    durationWeeks: Type.Number({ minimum: 0 }),
+    peakWeeks: Type.Array(Type.Number()),
+    resourceRequirements: Type.String()
+  }))
+})
+
+// Capacity gaps and constraints
+export const WarehouseCapacityGapsSchema = Type.Array(Type.Object({
+  gapId: Type.String(),
+  period: Type.String(),
+  gapType: Type.Union([
+    Type.Literal('STORAGE_SPACE'),
+    Type.Literal('THROUGHPUT'),
+    Type.Literal('EQUIPMENT'),
+    Type.Literal('STAFFING'),
+    Type.Literal('TECHNOLOGY'),
+    Type.Literal('ENVIRONMENTAL'),
+    Type.Literal('FINANCIAL'),
+    Type.Literal('SERVICE_LEVEL'),
+    Type.Literal('NETWORK_CAPACITY')
+  ]),
+  gapSize: Type.Number(),
+  gapUnit: Type.String(),
+  impact: Type.Union([
+    Type.Literal('LOW'),
+    Type.Literal('MEDIUM'),
+    Type.Literal('HIGH'),
+    Type.Literal('CRITICAL')
+  ]),
+  description: Type.String(),
+  rootCause: Type.String(),
+  urgency: Type.Union([
+    Type.Literal('LOW'),
+    Type.Literal('MEDIUM'),
+    Type.Literal('HIGH'),
+    Type.Literal('IMMEDIATE')
+  ]),
+  affectedServiceLevels: Type.Array(Type.String()),
+  estimatedRevenueLoss: Type.Optional(MoneySchema)
+}))
+
+// Optimization opportunities
+export const WarehouseOptimizationOpportunitiesSchema = Type.Array(Type.Object({
+  opportunityId: Type.String(),
+  category: Type.Union([
+    Type.Literal('SPACE_OPTIMIZATION'),
+    Type.Literal('PROCESS_IMPROVEMENT'),
+    Type.Literal('EQUIPMENT_UPGRADE'),
+    Type.Literal('TECHNOLOGY_ENHANCEMENT'),
+    Type.Literal('STAFFING_OPTIMIZATION'),
+    Type.Literal('LAYOUT_REDESIGN'),
+    Type.Literal('AUTOMATION_UPGRADE'),
+    Type.Literal('NETWORK_INTEGRATION'),
+    Type.Literal('SERVICE_LEVEL_OPTIMIZATION')
+  ]),
+  description: Type.String(),
+  currentState: Type.String(),
+  proposedState: Type.String(),
+  expectedBenefit: Type.Object({
+    capacityIncrease: Type.Optional(Type.Number({ description: 'percentage' })),
+    throughputIncrease: PerTimeSchema,
+    efficiencyGain: Type.Optional(Type.Number({ description: 'percentage' })),
+    costReduction: Type.Optional(MoneySchema),
+    qualityImprovement: Type.Optional(Type.Number({ description: 'percentage' })),
+    timeReduction: DurationSchema,
+    sustainabilityImpact: Type.Optional(Type.String())
+  }),
+  implementation: Type.Object({
+    effort: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH'),
+      Type.Literal('MAJOR')
+    ]),
+    duration: DurationSchema,
+    cost: Type.Optional(MoneySchema),
+    resources: Type.Array(Type.String()),
+    risks: Type.Array(Type.String()),
+    dependencies: Type.Array(Type.String()),
+    downtime: Type.Optional(DurationSchema)
+  }),
+  priority: Type.Union([
+    Type.Literal('LOW'),
+    Type.Literal('MEDIUM'),
+    Type.Literal('HIGH'),
+    Type.Literal('CRITICAL')
+  ]),
+  roi: Type.Optional(Type.Number({ description: 'percentage' })),
+  paybackPeriod: Type.Optional(DurationSchema)
+}))
+
+// Strategic recommendations
+export const WarehouseStrategicRecommendationsSchema = Type.Array(Type.Object({
+  recommendationId: Type.String(),
+  type: Type.Union([
+    Type.Literal('IMMEDIATE_ACTION'),
+    Type.Literal('SHORT_TERM_IMPROVEMENT'),
+    Type.Literal('MEDIUM_TERM_STRATEGY'),
+    Type.Literal('LONG_TERM_INVESTMENT'),
+    Type.Literal('CONTINGENCY_PLAN')
+  ]),
+  title: Type.String(),
+  description: Type.String(),
+  rationale: Type.String(),
+  expectedOutcome: Type.String(),
+  businessCase: Type.String(),
+  timeline: Type.Object({
+    startDate: Type.Optional(Type.Number()),
+    endDate: Type.Optional(Type.Number()),
+    duration: DurationSchema,
+    milestones: Type.Array(Type.Object({
+      milestone: Type.String(),
+      date: Type.Number(),
+      deliverable: Type.String()
+    }))
+  }),
+  resources: Type.Object({
+    budget: Type.Optional(MoneySchema),
+    staff: Type.Optional(Type.Number()),
+    equipment: Type.Optional(Type.Array(Type.String())),
+    technology: Type.Optional(Type.Array(Type.String())),
+    facilities: Type.Optional(Type.Array(Type.String())),
+    externalServices: Type.Optional(Type.Array(Type.String()))
+  }),
+  successMetrics: Type.Array(Type.Object({
+    metric: Type.String(),
+    currentValue: Type.Number(),
+    targetValue: Type.Number(),
+    unit: Type.String(),
+    measurementFrequency: Type.String(),
+    reportingMethod: Type.String()
+  })),
+  dependencies: Type.Array(Type.String()),
+  risks: Type.Array(Type.Object({
+    risk: Type.String(),
+    probability: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH')
+    ]),
+    impact: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH'),
+      Type.Literal('CRITICAL')
+    ]),
+    mitigation: Type.String(),
+    contingency: Type.String()
+  })),
+  approval: Type.Object({
+    approvalRequired: Type.Boolean(),
+    approvers: Type.Array(Type.String()),
+    estimatedApprovalTime: DurationSchema
+  })
+}))
+
+// Current capacity state and utilization
+export const WarehouseCapacityStateSchema = Type.Object({
+  capacity: WarehouseCapacitySchema,
+  utilizationSummary: Type.Object({
+    overallUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    storageUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    operationalUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    equipmentUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    staffUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    systemUtilization: Type.Number({ minimum: 0, maximum: 100 })
+  })
+})
+
+// Warehouse capacity analysis (broken down into sections)
+export const WarehouseCapacityAnalysisSchema = Type.Object({
+  warehouseId: Type.String(),
+  analysisDate: Type.Number(),
+  analysisPeriod: Type.Object({
+    start: Type.Number(),
+    end: Type.Number()
+  }),
+  
+  currentState: WarehouseCapacityStateSchema,
+  demandAnalysis: WarehouseDemandAnalysisSchema,
+  capacityGaps: WarehouseCapacityGapsSchema,
+  optimizationOpportunities: WarehouseOptimizationOpportunitiesSchema,
+  recommendations: WarehouseStrategicRecommendationsSchema
+})
+
+
+// TypeScript type exports
+export type WarehouseDemandAnalysis = Static<typeof WarehouseDemandAnalysisSchema>
+export type WarehouseCapacityGaps = Static<typeof WarehouseCapacityGapsSchema>
+export type WarehouseOptimizationOpportunities = Static<typeof WarehouseOptimizationOpportunitiesSchema>
+export type WarehouseStrategicRecommendations = Static<typeof WarehouseStrategicRecommendationsSchema>
+export type WarehouseCapacityState = Static<typeof WarehouseCapacityStateSchema>
+export type WarehouseCapacityAnalysis = Static<typeof WarehouseCapacityAnalysisSchema>