@de./types 1.0.0

package/src/lsp/psl.ts

@@ -0,0 +1,399 @@
+/**
+ * PSL - Physical Storate Location
+ */
+import { Type, Static } from '@sinclair/typebox'
+import { AreaSchema, CapacityRecordSchema, DimensionsSchema, TemperatureSchema, VolumeSchema, WeightSchema } from '../measure'
+import { ContextSchema } from '../context'
+import { ComplianceFlagSchema } from '../entity'
+import { ActionRecordSchema } from '../time'
+
+// Basic enums
+export const PSLVelocitySchema = Type.Union([
+  Type.Literal('A'),
+  Type.Literal('B'),
+  Type.Literal('C')
+])
+
+export const PSLStatusSchema = Type.Union([
+  Type.Literal('AVAILABLE'),
+  Type.Literal('OCCUPIED'),
+  Type.Literal('RESERVED'),
+  Type.Literal('BLOCKED'),
+  Type.Literal('DAMAGED'),
+  Type.Literal('MAINTENANCE')
+])
+
+export const PSLAccessibleSchema = Type.Union([
+  Type.Literal('MANUAL'),
+  Type.Literal('FORKLIFT'),
+  Type.Literal('CRANE'),
+  Type.Literal('ROBOT'),
+  Type.Literal('AGV')
+])
+
+export const PSLRestrictionSchema = Type.Union([
+  Type.Literal('FRAGILE'),
+  Type.Literal('HEAVY_ONLY'),
+  Type.Literal('FOOD_GRADE'),
+  Type.Literal('HAZMAT_ONLY'),
+  Type.Literal('TEMP_CONTROLLED')
+])
+
+export const PSLHierarchyTypeSchema = Type.Union([
+  // Type.Literal('WAREHOUSE'),
+  Type.Literal('ZONE'),
+  Type.Literal('AISLE'),
+  Type.Literal('BAY'),
+  Type.Literal('SLOT')
+])
+
+export const PSLZoneTypeSchema = Type.Union([
+  Type.Literal('PICK'),
+  Type.Literal('RESERVE'),
+  Type.Literal('RECEIVING'),
+  Type.Literal('SHIPPING'),
+  Type.Literal('STAGING'),
+  Type.Literal('RETURNS'),
+  Type.Literal('QUARANTINE'),
+  Type.Literal('HAZMAT'),
+  Type.Literal('CROSSDOCK')
+])
+
+// Address format types
+export const NumericAddressFormatSchema = Type.Union([
+  Type.Literal('NUMERIC'),      // ZZ-AA-BB-LL-PP
+  Type.Literal('ALPHANUMERIC')  // [Zone][Aisle][Bay]-[Level][Position]
+])
+
+export const RoboticAddressFormatSchema = Type.Union([
+  Type.Literal('COORDINATE'),   // X-Y-Z
+  Type.Literal('GRID'),
+  Type.Literal('POLAR'),
+  Type.Literal('MATRIX')
+])
+
+// Address structures
+export const PSLNumericAddressSchema = Type.Object({
+  warehouse: Type.String({ description: 'WH01' }),
+  zone: Type.String({ description: 'PICK, BULK, RECEIVING' }),
+  aisle: Type.String({ description: 'A, B, C' }),
+  bay: Type.String({ description: '01, 02, 03' }),
+  level: Type.Number({ minimum: 1, description: '1, 2, 3 (floor = 1)' }),
+  position: Type.String({ description: 'A, B, C' })
+})
+
+export const PSLCoordinateAddressSchema = Type.Object({
+  x: Type.Number(),
+  y: Type.Number(),
+  z: Type.Number(),
+  unit: Type.Union([
+    Type.Literal('mm'),
+    Type.Literal('cm'),
+    Type.Literal('m')
+  ]),
+  rotation: Type.Optional(Type.Number({ description: 'For robotic systems (degrees)' }))
+})
+
+export const PSLGridAddressSchema = Type.Object({
+  gridX: Type.Number(),
+  gridY: Type.Number(),
+  level: Type.Number(),
+  position: Type.Optional(Type.String())
+})
+
+export const PSLPolarAddressSchema = Type.Object({
+  radius: Type.Number(),
+  angle: Type.Number({ description: 'degrees' }),
+  height: Type.Number(),
+  unit: Type.Union([
+    Type.Literal('mm'),
+    Type.Literal('cm'),
+    Type.Literal('m')
+  ])
+})
+
+export const PSLMatrixAddressSchema = Type.Object({
+  bay: Type.Number(),
+  row: Type.Number(),
+  tier: Type.Number(),
+  depth: Type.Optional(Type.Number())
+})
+
+// Capacity schema
+export const PSLCapacitySchema = Type.Object({
+  area: Type.Optional(CapacityRecordSchema(AreaSchema)),
+  items: CapacityRecordSchema(Type.Number()),
+  weight: CapacityRecordSchema(WeightSchema),
+  volume: Type.Optional(CapacityRecordSchema(VolumeSchema)),
+  pallets: Type.Optional(CapacityRecordSchema(Type.Number())),
+  dimensions: Type.Optional(CapacityRecordSchema(DimensionsSchema)),
+  utilizationPercentage: Type.Number({ minimum: 0, maximum: 100 })
+})
+
+// Environmental controls schema
+export const PSLEnvironmentalControlsSchema = Type.Object({
+  temperature: TemperatureSchema,
+  humidity: Type.Optional(Type.Number({ minimum: 0, maximum: 100, description: '%' })),
+  airflow: Type.Optional(Type.Boolean()),
+  lightLevel: Type.Optional(Type.Number({ minimum: 0, description: 'lux' })),
+  cleanroomClass: Type.Optional(Type.String({ description: 'ISO 14644 standards' }))
+})
+
+// Location address schema
+export const PSLAddressSchema = Type.Object({
+  numeric: Type.Optional(PSLNumericAddressSchema),
+  alphanumeric: Type.Optional(PSLCoordinateAddressSchema),
+  coordinate: Type.Optional(PSLCoordinateAddressSchema),
+  grid: Type.Optional(PSLGridAddressSchema),
+  polar: Type.Optional(PSLPolarAddressSchema),
+  matrix: Type.Optional(PSLMatrixAddressSchema),
+  primaryFormat: NumericAddressFormatSchema,
+  roboticFormat: Type.Optional(RoboticAddressFormatSchema),
+  value: Type.String({ description: 'Generated: P-A12-3B or 01-05-12-03-02' }),
+  machineReadable: Type.Optional(Type.String({ description: 'Base64 or delimited format' }))
+})
+
+// Slotting stats schema
+export const PSLSlottingStatsSchema = Type.Object({
+  velocity: PSLVelocitySchema,
+  pickSequence: Type.Optional(Type.Number()),
+  pickFrequency: Type.Optional(Type.Number({ description: 'picks per day' })),
+  lastOptimized: Type.Optional(Type.Number({ description: 'timestamp' })),
+  utilizationScore: Type.Optional(Type.Number({ minimum: 0, maximum: 100 })),
+  preferredProductTypes: Type.Optional(Type.Array(Type.String())),
+  seasonalityFactor: Type.Optional(Type.Number()),
+  throughputTarget: Type.Optional(Type.Number({ description: 'items per hour' })),
+  accuracyTarget: Type.Optional(Type.Number({ description: 'percentage' }))
+})
+
+// Physical Storage Location schema
+export const PSLSchema = Type.Object({
+  id: Type.String(),
+  code: Type.String(),
+  context: ContextSchema,
+  address: PSLAddressSchema,
+  type: PSLHierarchyTypeSchema,
+  parentId: Type.Optional(Type.String({ description: 'Parent location ID' })),
+  children: Type.Optional(Type.Array(Type.String(), { description: 'Child location IDs' })),
+  depth: Type.Number({ minimum: 0, description: 'Hierarchy depth (0 = warehouse, 1 = zone, etc.)' }),
+  capacity: PSLCapacitySchema,
+  accessible: PSLAccessibleSchema,
+  pickable: Type.Boolean(),
+  replenishable: Type.Boolean(),
+  receivable: Type.Boolean({ description: 'Can receive goods' }),
+  shippable: Type.Boolean({ description: 'Can ship from' }),
+  environmental: PSLEnvironmentalControlsSchema,
+  hazmat: Type.Boolean(),
+  restrictions: Type.Optional(Type.Array(PSLRestrictionSchema)),
+  complianceFlags: Type.Optional(Type.Array(ComplianceFlagSchema)),
+  status: PSLStatusSchema,
+  slotting: Type.Optional(PSLSlottingStatsSchema),
+  notes: Type.Optional(Type.String({ maxLength: 1000 })),
+  tags: Type.Optional(Type.Array(Type.String())),
+  customAttributes: Type.Optional(Type.Record(Type.String(), Type.Any())),
+  created: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+
+// Helper schemas
+export const PSLRequestSchema = Type.Object({
+  context: ContextSchema,
+  type: PSLHierarchyTypeSchema,
+  parentId: Type.Optional(Type.String()),
+  addressConfig: Type.Object({
+    primaryFormat: NumericAddressFormatSchema,
+    roboticFormat: Type.Optional(RoboticAddressFormatSchema),
+    coordinates: Type.Optional(Type.Partial(PSLCoordinateAddressSchema))
+  }),
+  properties: Type.Object({
+    dimensions: DimensionsSchema,
+    maxWeight: WeightSchema,
+    accessible: PSLAccessibleSchema,
+    environmental: Type.Optional(Type.Partial(PSLEnvironmentalControlsSchema)),
+    restrictions: Type.Optional(Type.Array(PSLRestrictionSchema))
+  }),
+  metadata: Type.Optional(Type.Object({
+    name: Type.Optional(Type.String()),
+    code: Type.Optional(Type.String()),
+    notes: Type.Optional(Type.String()),
+    tags: Type.Optional(Type.Array(Type.String()))
+  }))
+})
+
+export const PSLFilterSchema = Type.Object({
+  contextId: Type.Optional(Type.String()),
+  type: Type.Optional(PSLHierarchyTypeSchema),
+  status: Type.Optional(Type.Array(PSLStatusSchema)),
+  zoneType: Type.Optional(PSLZoneTypeSchema),
+  accessible: Type.Optional(Type.Array(PSLAccessibleSchema)),
+  velocity: Type.Optional(Type.Array(PSLVelocitySchema)),
+  hasCapacity: Type.Optional(Type.Boolean()),
+  environmentalMatch: Type.Optional(Type.Partial(PSLEnvironmentalControlsSchema)),
+  restrictions: Type.Optional(Type.Array(PSLRestrictionSchema))
+})
+
+export const PSLOperationSchema = Type.Object({
+  type: Type.Union([
+    Type.Literal('BLOCK'),
+    Type.Literal('UNBLOCK'),
+    Type.Literal('MAINTENANCE'),
+    Type.Literal('OPTIMIZE'),
+    Type.Literal('RELOCATE')
+  ]),
+  locationId: Type.String(),
+  reason: Type.String({ maxLength: 500 }),
+  performedBy: Type.String(),
+  timestamp: Type.Number(),
+  metadata: Type.Optional(Type.Record(Type.String(), Type.Any()))
+})
+
+export const PSLMetricsSchema = Type.Object({
+  locationId: Type.String(),
+  utilizationRate: Type.Number({ minimum: 0, maximum: 100, description: '%' }),
+  throughput: Type.Number({ minimum: 0, description: 'items per hour' }),
+  accuracy: Type.Number({ minimum: 0, maximum: 100, description: '%' }),
+  cycleTime: Type.Number({ minimum: 0, description: 'minutes' }),
+  pickEfficiency: Type.Number({ minimum: 0, maximum: 100, description: '%' }),
+  replenishmentFrequency: Type.Number({ minimum: 0, description: 'times per week' }),
+  lastOptimized: Type.Number({ description: 'timestamp' })
+})
+
+// Generate TypeScript types from schemas
+export type PSLVelocity = Static<typeof PSLVelocitySchema>
+export type PSLStatus = Static<typeof PSLStatusSchema>
+export type PSLAccessible = Static<typeof PSLAccessibleSchema>
+export type PSLRestriction = Static<typeof PSLRestrictionSchema>
+export type PSLHierarchyType = Static<typeof PSLHierarchyTypeSchema>
+export type PSLZoneType = Static<typeof PSLZoneTypeSchema>
+export type NumericAddressFormat = Static<typeof NumericAddressFormatSchema>
+export type RoboticAddressFormat = Static<typeof RoboticAddressFormatSchema>
+export type PSLNumericAddress = Static<typeof PSLNumericAddressSchema>
+export type PSLCoordinateAddress = Static<typeof PSLCoordinateAddressSchema>
+export type PSLGridAddress = Static<typeof PSLGridAddressSchema>
+export type PSLPolarAddress = Static<typeof PSLPolarAddressSchema>
+export type PSLMatrixAddress = Static<typeof PSLMatrixAddressSchema>
+export type PSLCapacity = Static<typeof PSLCapacitySchema>
+export type PSLEnvironmentalControls = Static<typeof PSLEnvironmentalControlsSchema>
+export type PSLAddress = Static<typeof PSLAddressSchema>
+export type PSLSlottingStats = Static<typeof PSLSlottingStatsSchema>
+export type PSL = Static<typeof PSLSchema>
+export type PSLRequest = Static<typeof PSLRequestSchema>
+export type PSLFilter = Static<typeof PSLFilterSchema>
+export type PSLOperation = Static<typeof PSLOperationSchema>
+export type PSLMetrics = Static<typeof PSLMetricsSchema>
+
+// ─── Request Validation Schemas ───────────────────────────────────────────────
+
+import {
+	APIErrorSchema,
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory
+} from '../api'
+
+export const LSPPSLCreateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     PSLRequestSchema,
+	response: {
+		201:   APIResponseDataSchemaFactory({ locationId: Type.String(), address: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPSLFetchRVS = {
+	headers:     APIHeadersSchema,
+	querystring: Type.Object({
+		type:       Type.Optional(Type.String()),
+		status:     Type.Optional(Type.Array(Type.String())),
+		parentId:   Type.Optional(Type.String()),
+		accessible: Type.Optional(Type.Array(Type.String())),
+		velocity:   Type.Optional(Type.Array(Type.String())),
+		hasCapacity: Type.Optional(Type.Boolean()),
+		limit:      Type.Optional(Type.Number()),
+		offset:     Type.Optional(Type.Number())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ locations: Type.Array(PSLSchema), total: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPSLRetrieveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ locationId: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ location: PSLSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPSLUpdateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ locationId: Type.String() }),
+	body:     Type.Object({
+		status:        Type.Optional(PSLStatusSchema),
+		capacity:      Type.Optional(Type.Any()),
+		environmental: Type.Optional(Type.Any()),
+		metadata:      Type.Optional(Type.Any()),
+		restrictions:  Type.Optional(Type.Any())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ message: Type.String(), location: PSLSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPSLUpdateStatusRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ locationId: Type.String() }),
+	body:     Type.Object({ status: PSLStatusSchema }),
+	response: {
+		200:   APIResponseBaseSchema,
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPSLRemoveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ locationId: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ message: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPSLHierarchyRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ locationId: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ hierarchy: Type.Array(PSLSchema) }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const LSPPSLAvailableRVS = {
+	headers:     APIHeadersSchema,
+	querystring: Type.Object({
+		type:         Type.Optional(Type.String()),
+		minWeight:    Type.Optional(Type.Number()),
+		minVolume:    Type.Optional(Type.Number()),
+		accessible:   Type.Optional(Type.String()),
+		temperature:  Type.Optional(Type.Any()),
+		restrictions: Type.Optional(Type.Array(Type.String())),
+		limit:        Type.Optional(Type.Number())
+	}),
+	response: {
+		200:   APIResponseDataSchemaFactory({ locations: Type.Array(PSLSchema), total: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export type LSPPSLCreateValidation       = { params: Static<typeof LSPPSLCreateRVS.params>, body: Static<typeof LSPPSLCreateRVS.body>, response: Static<(typeof LSPPSLCreateRVS.response)[201]> }
+export type LSPPSLFetchValidation        = { querystring: Static<typeof LSPPSLFetchRVS.querystring>, response: Static<(typeof LSPPSLFetchRVS.response)[200]> }
+export type LSPPSLRetrieveValidation     = { params: Static<typeof LSPPSLRetrieveRVS.params>, response: Static<(typeof LSPPSLRetrieveRVS.response)[200]> }
+export type LSPPSLUpdateValidation       = { params: Static<typeof LSPPSLUpdateRVS.params>, body: Static<typeof LSPPSLUpdateRVS.body>, response: Static<(typeof LSPPSLUpdateRVS.response)[200]> }
+export type LSPPSLUpdateStatusValidation = { params: Static<typeof LSPPSLUpdateStatusRVS.params>, body: Static<typeof LSPPSLUpdateStatusRVS.body>, response: Static<(typeof LSPPSLUpdateStatusRVS.response)[200]> }
+export type LSPPSLRemoveValidation       = { params: Static<typeof LSPPSLRemoveRVS.params>, response: Static<(typeof LSPPSLRemoveRVS.response)[200]> }
+export type LSPPSLHierarchyValidation    = { params: Static<typeof LSPPSLHierarchyRVS.params>, response: Static<(typeof LSPPSLHierarchyRVS.response)[200]> }
+export type LSPPSLAvailableValidation    = { querystring: Static<typeof LSPPSLAvailableRVS.querystring>, response: Static<(typeof LSPPSLAvailableRVS.response)[200]> }