@de./types 1.0.0

package/src/lsp/hub/index.ts

@@ -0,0 +1,298 @@
+import { Type, Static } from '@sinclair/typebox'
+import { MoneySchema, LengthSchema, ServiceLevelSchema } from '../../measure'
+import {
+	BaseServiceDefinitionSchema,
+	BaseServiceDefinitionUpdateSchema
+} from '../../service'
+import { PSLSchema, PSLAccessibleSchema, PSLZoneTypeSchema } from '../psl'
+import { HubPerformanceSchema } from './performance'
+import { EntityStatusSchema } from '../../entity'
+import {
+	APIErrorSchema,
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory
+} from '../../api'
+
+// Hub Partition Schema
+export const HubZoneSchema = Type.Composite([
+  PSLSchema,
+  Type.Object({
+    type: Type.Literal('ZONE'),
+    zoneType: PSLZoneTypeSchema,
+    parentId: Type.String({ description: 'Must belong to a hub' }),
+    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 HubAisleSchema = Type.Composite([
+  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 HubBaySchema = Type.Composite([
+  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 HubSlotSchema = Type.Composite([
+  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())
+  })
+])
+
+// Hub Type Schema - Industry standard hub classifications
+export const HubTypeSchema = Type.Union([
+  Type.Literal('SORTING'),        // Central sorting facility
+  Type.Literal('DISTRIBUTION'),   // Regional distribution center
+  Type.Literal('TRANSIT'),        // Mid-route transfer point
+  Type.Literal('CROSS_DOCK'),     // Direct transfer without storage
+  Type.Literal('LAST_MILE'),      // Final delivery preparation
+  Type.Literal('CONSOLIDATION'),  // Package consolidation center
+  Type.Literal('GATEWAY')         // International/customs hub
+])
+
+export const HubSchema = Type.Composite([
+  BaseServiceDefinitionSchema,
+  Type.Object({
+    type: HubTypeSchema,
+    
+    // Hub capability, 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(HubPerformanceSchema)
+  })
+])
+export const HubUpdateSchema = Type.Composite([
+  BaseServiceDefinitionUpdateSchema,
+  Type.Object({
+    type: Type.Optional(HubTypeSchema)
+  })
+])
+
+export type HubZone = Static<typeof HubZoneSchema>
+export type HubAisle = Static<typeof HubAisleSchema>
+export type HubBay = Static<typeof HubBaySchema>
+export type HubSlot = Static<typeof HubSlotSchema>
+export type HubType = Static<typeof HubTypeSchema>
+export type Hub = Static<typeof HubSchema>
+export type HubUpdate = Static<typeof HubUpdateSchema>
+
+// ===== UTILITY SCHEMAS =====
+
+// Hub Performance Analytics Schema
+export const HubAnalyticsSchema = Type.Object({
+  hubId: Type.String(),
+  period: Type.Object({
+    start: Type.Number(),
+    end: Type.Number()
+  }),
+  metrics: HubPerformanceSchema,
+  trends: Type.Object({
+    throughputTrend: Type.Number({ description: 'percentage change' }),
+    efficiencyTrend: Type.Number({ description: 'percentage change' }),
+    qualityTrend: Type.Number({ description: 'percentage change' })
+  }),
+  benchmarks: Type.Optional(Type.Object({
+    industryAverage: Type.Partial(HubPerformanceSchema),
+    networkAverage: Type.Partial(HubPerformanceSchema),
+    bestPerforming: Type.Partial(HubPerformanceSchema)
+  })),
+  recommendations: Type.Optional(Type.Array(Type.Object({
+    type: Type.String(),
+    priority: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH')
+    ]),
+    description: Type.String(),
+    expectedImpact: Type.String()
+  })))
+})
+
+// Hub Capacity Planning Schema
+export const HubCapacityPlanningSchema = Type.Object({
+  hubId: Type.String(),
+  currentCapacity: Type.Object({
+    processing: Type.Number({ description: 'packages per hour' }),
+    storage: Type.Number({ description: 'packages' }),
+    sorting: Type.Number({ description: 'packages per hour' })
+  }),
+  forecastedDemand: Type.Array(Type.Object({
+    period: Type.String(),
+    expectedVolume: Type.Number(),
+    peakVolume: Type.Number(),
+    serviceLevel: ServiceLevelSchema
+  })),
+  capacityGaps: Type.Array(Type.Object({
+    period: Type.String(),
+    gapType: Type.Union([
+      Type.Literal('PROCESSING'),
+      Type.Literal('STORAGE'),
+      Type.Literal('SORTING'),
+      Type.Literal('STAFFING')
+    ]),
+    gapSize: Type.Number(),
+    severity: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH'),
+      Type.Literal('CRITICAL')
+    ])
+  })),
+  recommendations: Type.Array(Type.Object({
+    action: Type.String(),
+    investment: Type.Optional(MoneySchema),
+    timeline: Type.String(),
+    expectedBenefit: Type.String()
+  }))
+})
+
+export type HubAnalytics         = Static<typeof HubAnalyticsSchema>
+export type HubCapacityPlanning  = Static<typeof HubCapacityPlanningSchema>
+
+// ─── Request Validation Schemas ───────────────────────────────────────────────
+
+export const HubCreateBodySchema = Type.Omit(HubSchema, [
+	'id', 'context',
+	'status', 'alerts',
+	'created', 'updated'
+])
+
+export const HubStatusUpdateBodySchema = Type.Object({
+	status: EntityStatusSchema,
+	reason: Type.Optional(Type.String({ maxLength: 500 }))
+})
+
+export const HubListQuerySchema = Type.Object({
+	status: Type.Optional(EntityStatusSchema),
+	type:   Type.Optional(HubTypeSchema),
+	limit:  Type.Optional(Type.Number({ minimum: 1, maximum: 200, default: 20 })),
+	offset: Type.Optional(Type.Number({ minimum: 0, default: 0 }))
+})
+
+export const LSPHubCreateRVS = {
+	headers:  APIHeadersSchema,
+	body:     HubCreateBodySchema,
+	response: APIResponseDataSchemaFactory({ hubId: Type.String() })
+}
+
+export const LSPHubRetrieveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseDataSchemaFactory({ hub: HubSchema })
+}
+
+export const LSPHubListRVS = {
+	headers:     APIHeadersSchema,
+	querystring: HubListQuerySchema,
+	response:    APIResponseDataSchemaFactory({
+		hubs:   Type.Array(HubSchema),
+		total:  Type.Number(),
+		limit:  Type.Number(),
+		offset: Type.Number()
+	})
+}
+
+export const LSPHubUpdateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     HubUpdateSchema,
+	response: APIResponseDataSchemaFactory({ hub: HubSchema })
+}
+
+export const LSPHubUpdateStatusRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     HubStatusUpdateBodySchema,
+	response: APIResponseDataSchemaFactory({ hub: HubSchema })
+}
+
+export const LSPHubRemoveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseBaseSchema
+}
+
+export type LSPHubCreateValidation       = { headers: Static<typeof LSPHubCreateRVS.headers>, body: Static<typeof LSPHubCreateRVS.body>, response: Static<typeof LSPHubCreateRVS.response> }
+export type LSPHubRetrieveValidation     = { headers: Static<typeof LSPHubRetrieveRVS.headers>, params: Static<typeof LSPHubRetrieveRVS.params>, response: Static<typeof LSPHubRetrieveRVS.response> }
+export type LSPHubListValidation         = { headers: Static<typeof LSPHubListRVS.headers>, querystring: Static<typeof LSPHubListRVS.querystring>, response: Static<typeof LSPHubListRVS.response> }
+export type LSPHubUpdateValidation       = { headers: Static<typeof LSPHubUpdateRVS.headers>, params: Static<typeof LSPHubUpdateRVS.params>, body: Static<typeof LSPHubUpdateRVS.body>, response: Static<typeof LSPHubUpdateRVS.response> }
+export type LSPHubUpdateStatusValidation = { headers: Static<typeof LSPHubUpdateStatusRVS.headers>, params: Static<typeof LSPHubUpdateStatusRVS.params>, body: Static<typeof LSPHubUpdateStatusRVS.body>, response: Static<typeof LSPHubUpdateStatusRVS.response> }
+export type LSPHubRemoveValidation       = { headers: Static<typeof LSPHubRemoveRVS.headers>, params: Static<typeof LSPHubRemoveRVS.params>, response: Static<typeof LSPHubRemoveRVS.response> }
+
+// Re-export all hub capability schemas and types
+export * from './capabilities'
+
+// Re-export all hub capacity schemas and types
+export * from './capacities'
+
+// Re-export all hub performance schemas and types
+export * from './performance'
+
+// Re-export all hub analytics, utility, and integration schemas and types
+export * from './analytics'
+export * from './utilities'

package/src/lsp/hub/performance.ts

@@ -0,0 +1,89 @@
+import { Type, Static } from '@sinclair/typebox'
+import { DurationSchema } from '../../time'
+import { MoneySchema } from '../../measure'
+import { SPPerformanceSummarySchema } from '../../context'
+
+// Current performance metrics
+export const HubCurrentPerformanceSchema = Type.Object({
+  dailyThroughput: Type.Number({ minimum: 0 }),
+  hourlyThroughput: Type.Number({ minimum: 0 }),
+  sortingEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+  processingEfficiency: Type.Number({ minimum: 0, maximum: 100 }),
+  overallUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+  equipmentUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+  staffUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+  facilityUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+  networkUtilization: Type.Number({ minimum: 0, maximum: 100 })
+})
+
+// Peak performance metrics
+export const HubPeakPerformanceSchema = Type.Object({
+  peakDailyThroughput: Type.Number({ minimum: 0 }),
+  peakHourlyThroughput: Type.Number({ minimum: 0 }),
+  peakUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+  peakCapacityMultiplier: Type.Number({ minimum: 1 }),
+  sustainablePeakDuration: DurationSchema,
+  peakSeasonCapacity: Type.Number({ minimum: 0, maximum: 200, description: 'percentage of normal' }),
+  lastPeakDate: Type.Optional(Type.Number()),
+  peakTriggerThreshold: Type.Number({ minimum: 0, maximum: 100 })
+})
+
+// Quality and accuracy metrics
+export const HubQualityPerformanceSchema = Type.Object({
+  overallAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+  sortingAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+  scanningAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+  handlingAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+  routingAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+  labelingAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+  documentationAccuracy: Type.Number({ minimum: 0, maximum: 100 }),
+  damageRate: Type.Number({ minimum: 0, maximum: 100 }),
+  lossRate: Type.Number({ minimum: 0, maximum: 100 }),
+  misrouteRate: Type.Number({ minimum: 0, maximum: 100 })
+})
+
+// Time-based performance
+export const HubTimingPerformanceSchema = Type.Object({
+  averageDwellTime: DurationSchema,
+  averageProcessingTime: DurationSchema,
+  averageSortingTime: DurationSchema,
+  averageLoadingTime: DurationSchema,
+  averageUnloadingTime: DurationSchema,
+  onTimePerformance: Type.Number({ minimum: 0, maximum: 100 }),
+  transitTimeCompliance: Type.Number({ minimum: 0, maximum: 100 }),
+  cutoffCompliance: Type.Number({ minimum: 0, maximum: 100 }),
+  slaCompliance: Type.Number({ minimum: 0, maximum: 100 })
+})
+
+// Cost performance
+export const HubCostPerformanceSchema = Type.Object({
+  costPerPackage: MoneySchema,
+  costPerSort: MoneySchema,
+  costPerPound: MoneySchema,
+  laborCostPerHour: MoneySchema,
+  equipmentCostPerHour: MoneySchema,
+  facilityCostPerSqFt: MoneySchema,
+  totalOperatingCost: MoneySchema,
+  costEfficiency: Type.Number({ minimum: 0, maximum: 100 })
+})
+
+// Combined performance schema
+export const HubPerformanceSchema = Type.Object({
+  summary: SPPerformanceSummarySchema,
+  metrics: Type.Object({
+    current: HubCurrentPerformanceSchema,
+    peak: HubPeakPerformanceSchema,
+    quality: HubQualityPerformanceSchema,
+    timing: HubTimingPerformanceSchema,
+    costs: Type.Optional(HubCostPerformanceSchema)
+  })
+})
+
+// TypeScript type exports
+export type HubCurrentPerformance = Static<typeof HubCurrentPerformanceSchema>
+export type HubPeakPerformance = Static<typeof HubPeakPerformanceSchema>
+export type HubQualityPerformance = Static<typeof HubQualityPerformanceSchema>
+export type HubTimingPerformance = Static<typeof HubTimingPerformanceSchema>
+export type HubCostPerformance = Static<typeof HubCostPerformanceSchema>
+export type HubPerformance = Static<typeof HubPerformanceSchema>
+