@de./types 1.0.0

package/src/lsp/warehouse/index.ts

@@ -0,0 +1,298 @@
+import { Type, Static } from '@sinclair/typebox'
+import { LengthSchema } from '../../measure'
+import {
+	PSLSchema,
+	PSLAccessibleSchema,
+	PSLZoneTypeSchema
+} from '../psl'
+import {
+	BaseServiceDefinitionSchema,
+	BaseServiceDefinitionUpdateSchema
+} from '../../service'
+import { WarehousePerformanceSchema } from './performance'
+import { EntityStatusSchema } from '../../entity'
+import {
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory
+} from '../../api'
+
+// Warehouse Type Schema
+export 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 Schema
+export const WarehouseSchema = Type.Intersect([
+  BaseServiceDefinitionSchema,
+  Type.Object({
+    type: WarehouseTypeSchema,
+    
+    // Warehouse capabilities, Capacity
+    capabilities: Type.Array(Type.String()), // Capability Composite IDs
+    capacities: Type.Array(Type.String()), // Capacity Composite IDs
+    pricing: Type.Array(Type.String()), // Pricing rules Codes
+
+    // Performance
+    performance: Type.Optional(WarehousePerformanceSchema)
+  })
+])
+export const WarehouseUpdateSchema = Type.Composite([
+  BaseServiceDefinitionUpdateSchema,
+  Type.Object({
+    type: Type.Optional(WarehouseTypeSchema)
+  })
+])
+
+// Warehouse Partitions Schema
+export const WarehouseZoneSchema = Type.Intersect([
+  PSLSchema,
+  Type.Object({
+    type: Type.Literal('ZONE'),
+    zoneType: PSLZoneTypeSchema,
+    parentId: Type.String({ description: 'Must belong to a warehouse' }),
+    name: Type.String({ minLength: 1, maxLength: 100 }),
+    pickingMethod: Type.Optional(Type.Union([
+      Type.Literal('PIECE'),
+      Type.Literal('CASE'),
+      Type.Literal('PALLET'),
+      Type.Literal('BULK')
+    ])),
+    storageMethod: Type.Optional(Type.Union([
+      Type.Literal('RANDOM'),
+      Type.Literal('FIXED'),
+      Type.Literal('DIRECTED')
+    ])),
+    flowPattern: Type.Optional(Type.Union([
+      Type.Literal('FIFO'),
+      Type.Literal('LIFO'),
+      Type.Literal('FEFO')
+    ], { description: 'First/Last In First Out, First Expired First Out' }))
+  })
+])
+export const WarehouseAisleSchema = Type.Intersect([
+  PSLSchema,
+  Type.Object({
+    type: Type.Literal('AISLE'),
+    parentId: Type.String({ description: 'Must belong to a zone' }),
+    width: LengthSchema,
+    trafficDirection: Type.Union([
+      Type.Literal('ONE_WAY'),
+      Type.Literal('TWO_WAY')
+    ]),
+    equipmentAccess: Type.Array(PSLAccessibleSchema),
+    pickDirection: Type.Union([
+      Type.Literal('FORWARD'),
+      Type.Literal('REVERSE'),
+      Type.Literal('SERPENTINE')
+    ]),
+    pickSequenceStart: Type.Number({ minimum: 1 })
+  })
+])
+export const WarehouseBaySchema = Type.Intersect([
+  PSLSchema,
+  Type.Object({
+    type: Type.Literal('BAY'),
+    parentId: Type.String({ description: 'Must belong to an aisle' }),
+    structureType: Type.Union([
+      Type.Literal('RACK'),
+      Type.Literal('SHELF'),
+      Type.Literal('FLOOR'),
+      Type.Literal('CANTILEVER'),
+      Type.Literal('CAROUSEL')
+    ]),
+    maxLevels: Type.Number({ minimum: 1 }),
+    levelHeight: LengthSchema,
+    safetyRating: Type.Number({ 
+      minimum: 0,
+      description: 'max weight per level'
+    }),
+    requiresEquipment: Type.Boolean()
+  })
+])
+export const WarehouseSlotSchema = Type.Intersect([
+  PSLSchema,
+  Type.Object({
+    type: Type.Literal('SLOT'),
+    parentId: Type.String({ description: 'Must belong to a bay' }),
+    pickFace: Type.Boolean({ description: 'Is this a primary pick location?' }),
+    replenishmentSource: Type.Optional(Type.String({ 
+      description: 'Source slot for replenishment'
+    })),
+    dedicatedProduct: Type.Optional(Type.String({ 
+      description: 'Product ID if dedicated slot'
+    })),
+    allowMixedProducts: Type.Boolean(),
+    currentProduct: Type.Optional(Type.String({ 
+      description: 'Currently stored product'
+    })),
+    lastInventoryDate: Type.Optional(Type.Number()),
+    cycleCountDue: Type.Optional(Type.Boolean())
+  })
+])
+
+// Generate TypeScript types from schemas
+export type WarehouseZone = Static<typeof WarehouseZoneSchema>
+export type WarehouseAisle = Static<typeof WarehouseAisleSchema>
+export type WarehouseBay = Static<typeof WarehouseBaySchema>
+export type WarehouseSlot = Static<typeof WarehouseSlotSchema>
+export type WarehouseType = Static<typeof WarehouseTypeSchema>
+export type Warehouse = Static<typeof WarehouseSchema>
+export type WarehouseUpdate = Static<typeof WarehouseUpdateSchema>
+
+// Utility schemas for warehouse operations
+export const WarehouseLayoutSchema = Type.Object({
+  warehouseId: Type.String(),
+  totalZones: Type.Number({ minimum: 0 }),
+  totalAisles: Type.Number({ minimum: 0 }),
+  totalBays: Type.Number({ minimum: 0 }),
+  totalSlots: Type.Number({ minimum: 0 }),
+  utilizationRate: Type.Number({ minimum: 0, maximum: 100, description: 'Percentage' }),
+  layout: Type.Object({
+    zones: Type.Array(WarehouseZoneSchema),
+    aisles: Type.Array(WarehouseAisleSchema),
+    bays: Type.Array(WarehouseBaySchema),
+    slots: Type.Array(WarehouseSlotSchema)
+  }),
+  optimization: Type.Optional(Type.Object({
+    pickPathOptimized: Type.Boolean(),
+    slottingOptimized: Type.Boolean(),
+    lastOptimized: Type.Optional(Type.Number()),
+    optimizationScore: Type.Optional(Type.Number({ minimum: 0, maximum: 100 }))
+  }))
+})
+
+export const WarehouseOptimizationRecommendationSchema = Type.Object({
+  warehouseId: Type.String(),
+  type: Type.Union([
+    Type.Literal('SLOTTING'),
+    Type.Literal('LAYOUT'),
+    Type.Literal('PICK_PATH'),
+    Type.Literal('REPLENISHMENT'),
+    Type.Literal('CAPACITY')
+  ]),
+  priority: Type.Union([
+    Type.Literal('LOW'),
+    Type.Literal('MEDIUM'),
+    Type.Literal('HIGH'),
+    Type.Literal('CRITICAL')
+  ]),
+  title: Type.String({ maxLength: 200 }),
+  description: Type.String({ maxLength: 1000 }),
+  expectedBenefit: Type.Object({
+    efficiencyGain: Type.Optional(Type.Number({ minimum: 0, maximum: 100 })),
+    costReduction: Type.Optional(Type.Number({ minimum: 0 })),
+    capacityIncrease: Type.Optional(Type.Number({ minimum: 0, maximum: 100 }))
+  }),
+  implementation: Type.Object({
+    effort: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH')
+    ]),
+    estimatedDuration: Type.Number({ minimum: 0, description: 'Days to implement' }),
+    requiredResources: Type.Array(Type.String())
+  }),
+  generatedAt: Type.Number(),
+  status: Type.Union([
+    Type.Literal('PENDING'),
+    Type.Literal('APPROVED'),
+    Type.Literal('IN_PROGRESS'),
+    Type.Literal('COMPLETED'),
+    Type.Literal('REJECTED')
+  ])
+})
+
+export type WarehouseLayout                     = Static<typeof WarehouseLayoutSchema>
+export type WarehouseOptimizationRecommendation = Static<typeof WarehouseOptimizationRecommendationSchema>
+
+// ─── Request Validation Schemas ───────────────────────────────────────────────
+
+export const WarehouseCreateBodySchema = Type.Omit(WarehouseSchema, [
+	'id', 'context',
+	'status', 'alerts',
+	'created', 'updated'
+])
+
+export const WarehouseStatusUpdateBodySchema = Type.Object({
+	status: EntityStatusSchema,
+	reason: Type.Optional(Type.String({ maxLength: 500 }))
+})
+
+export const WarehouseListQuerySchema = Type.Object({
+	status: Type.Optional(EntityStatusSchema),
+	type:   Type.Optional(WarehouseTypeSchema),
+	limit:  Type.Optional(Type.Number({ minimum: 1, maximum: 200, default: 20 })),
+	offset: Type.Optional(Type.Number({ minimum: 0, default: 0 }))
+})
+
+export const LSPWarehouseCreateRVS = {
+	headers:  APIHeadersSchema,
+	body:     WarehouseCreateBodySchema,
+	response: APIResponseDataSchemaFactory({ warehouseId: Type.String() })
+}
+
+export const LSPWarehouseRetrieveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseDataSchemaFactory({ warehouse: WarehouseSchema })
+}
+
+export const LSPWarehouseListRVS = {
+	headers:     APIHeadersSchema,
+	querystring: WarehouseListQuerySchema,
+	response: APIResponseDataSchemaFactory({
+		warehouses: Type.Array(WarehouseSchema),
+		total:      Type.Number(),
+		limit:      Type.Number(),
+		offset:     Type.Number()
+	})
+}
+
+export const LSPWarehouseUpdateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     WarehouseUpdateSchema,
+	response: APIResponseDataSchemaFactory({ warehouse: WarehouseSchema })
+}
+
+export const LSPWarehouseUpdateStatusRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     WarehouseStatusUpdateBodySchema,
+	response: APIResponseDataSchemaFactory({ warehouse: WarehouseSchema })
+}
+
+export const LSPWarehouseRemoveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseBaseSchema
+}
+
+export type LSPWarehouseCreateValidation       = { headers: Static<typeof LSPWarehouseCreateRVS.headers>, body: Static<typeof LSPWarehouseCreateRVS.body>, response: Static<typeof LSPWarehouseCreateRVS.response> }
+export type LSPWarehouseRetrieveValidation     = { headers: Static<typeof LSPWarehouseRetrieveRVS.headers>, params: Static<typeof LSPWarehouseRetrieveRVS.params>, response: Static<typeof LSPWarehouseRetrieveRVS.response> }
+export type LSPWarehouseListValidation         = { headers: Static<typeof LSPWarehouseListRVS.headers>, querystring: Static<typeof LSPWarehouseListRVS.querystring>, response: Static<typeof LSPWarehouseListRVS.response> }
+export type LSPWarehouseUpdateValidation       = { headers: Static<typeof LSPWarehouseUpdateRVS.headers>, params: Static<typeof LSPWarehouseUpdateRVS.params>, body: Static<typeof LSPWarehouseUpdateRVS.body>, response: Static<typeof LSPWarehouseUpdateRVS.response> }
+export type LSPWarehouseUpdateStatusValidation = { headers: Static<typeof LSPWarehouseUpdateStatusRVS.headers>, params: Static<typeof LSPWarehouseUpdateStatusRVS.params>, body: Static<typeof LSPWarehouseUpdateStatusRVS.body>, response: Static<typeof LSPWarehouseUpdateStatusRVS.response> }
+export type LSPWarehouseRemoveValidation       = { headers: Static<typeof LSPWarehouseRemoveRVS.headers>, params: Static<typeof LSPWarehouseRemoveRVS.params>, response: Static<typeof LSPWarehouseRemoveRVS.response> }
+
+// Re-export all warehouse capability schemas and types
+export * from './capabilities'
+
+// Re-export all warehouse capacity schemas and types
+export * from './capacities'
+
+// Re-export all warehouse performance schemas and types
+export * from './performance'
+
+// Re-export all warehouse analytics schemas and types
+export * from './analytics'
+
+// Re-export all warehouse utilities schemas and types
+export * from './utilities'

package/src/lsp/warehouse/performance.ts

@@ -0,0 +1,83 @@
+import { Type, Static } from '@sinclair/typebox'
+import { DurationSchema } from '../../time'
+import { MoneySchema } from '../../measure'
+import { SPPerformanceSummarySchema } from '../../context'
+
+// ===== WAREHOUSE PERFORMANCE SECTION =====
+
+// Current performance metrics
+export const WarehouseCurrentPerformanceSchema = Type.Object({
+  dailyThroughput: Type.Number({ minimum: 0 }),
+  hourlyThroughput: Type.Number({ minimum: 0 }),
+  orderFulfillmentRate: Type.Number({ minimum: 0, maximum: 100 }),
+  inventoryTurnover: Type.Number({ minimum: 0 }),
+  spaceUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+  equipmentUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+  laborUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+  costPerOrder: Type.Optional(MoneySchema),
+  costPerSqFt: Type.Optional(MoneySchema)
+})
+
+// Historical peak performance
+export const WarehousePeakPerformanceSchema = Type.Object({
+  peakDailyThroughput: Type.Number({ minimum: 0 }),
+  peakHourlyThroughput: Type.Number({ minimum: 0 }),
+  peakUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+  peakSeasonMultiplier: Type.Number({ minimum: 1 }),
+  sustainablePeakDuration: DurationSchema,
+  lastPeakDate: Type.Optional(Type.Number())
+})
+
+// Quality metrics
+export const WarehouseQualityPerformanceSchema = Type.Object({
+  overallAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+  receivingAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+  putawayAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+  pickingAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+  shippingAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+  inventoryAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+  damageRate: Type.Number({ minimum: 0, maximum: 100 }),
+  lossRate: Type.Number({ minimum: 0, maximum: 100 }),
+  customerComplaintRate: Type.Number({ minimum: 0, maximum: 100 })
+})
+
+// Time-based performance
+export const WarehouseTimingPerformanceSchema = Type.Object({
+  averageOrderCycleTime: DurationSchema,
+  averagePickTime: DurationSchema,
+  averagePackTime: DurationSchema,
+  averageReceivingTime: DurationSchema,
+  averagePutawayTime: DurationSchema,
+  onTimeShipment: Type.Number({ minimum: 0, maximum: 100 }),
+  orderFillRate: Type.Number({ minimum: 0, maximum: 100 })
+})
+
+// Efficiency metrics
+export const WarehouseEfficiencyPerformanceSchema = Type.Object({
+  operationalEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+  resourceEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+  energyEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+  costEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+  timeEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+  qualityEfficiency: Type.Number({ minimum: 0, maximum: 100 })
+})
+
+// Combined performance schema
+export const WarehousePerformanceSchema = Type.Object({
+  summary: SPPerformanceSummarySchema,
+  metrics: Type.Object({
+    current: WarehouseCurrentPerformanceSchema,
+    peak: WarehousePeakPerformanceSchema,
+    quality: WarehouseQualityPerformanceSchema,
+    timing: WarehouseTimingPerformanceSchema,
+    efficiency: WarehouseEfficiencyPerformanceSchema
+  })
+})
+
+// TypeScript type exports
+export type WarehouseCurrentPerformance = Static<typeof WarehouseCurrentPerformanceSchema>
+export type WarehousePeakPerformance = Static<typeof WarehousePeakPerformanceSchema>
+export type WarehouseQualityPerformance = Static<typeof WarehouseQualityPerformanceSchema>
+export type WarehouseTimingPerformance = Static<typeof WarehouseTimingPerformanceSchema>
+export type WarehouseEfficiencyPerformance = Static<typeof WarehouseEfficiencyPerformanceSchema>
+export type WarehousePerformance = Static<typeof WarehousePerformanceSchema>