@de./types 1.0.0

package/src/shared/operator.ts

@@ -0,0 +1,159 @@
+import { Type, Static, type TSchema } from '@sinclair/typebox'
+import {
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory,
+	FetchByQueryRequestSchema
+} from '../api'
+import { OperatorSchema, OperatorUpdateSchema } from '../operator'
+import { type ContextType, CSPOperatorRoleSchema, DEVOperatorRoleSchema, LSPOperatorRoleSchema } from '..'
+
+// ─── Builder ──────────────────────────────────────────────────────────────────
+
+const buildOperatorRVS = <Role extends TSchema, Update extends TSchema>(
+	roleSchema: Role,
+	updateSchema: Update
+) => ({
+	retrieve: {
+		headers: APIHeadersSchema,
+		params: Type.Object({ id: Type.String() }),
+		response: APIResponseDataSchemaFactory({ operator: roleSchema })
+	},
+	fetch: {
+		headers: APIHeadersSchema,
+		querystring: FetchByQueryRequestSchema,
+		response: APIResponseDataSchemaFactory({ operators: Type.Array(roleSchema) })
+	},
+	update: {
+		headers: APIHeadersSchema,
+		params: Type.Object({ id: Type.String() }),
+		body: updateSchema,
+		response: APIResponseDataSchemaFactory({ operator: roleSchema })
+	},
+	remove: {
+		headers: APIHeadersSchema,
+		params: Type.Object({ id: Type.String() }),
+		response: APIResponseBaseSchema
+	}
+})
+
+// ─── Per-context RVS ──────────────────────────────────────────────────────────
+
+export const DEVSharedOperatorRVS = buildOperatorRVS(
+	OperatorSchema(DEVOperatorRoleSchema),
+	OperatorUpdateSchema(DEVOperatorRoleSchema)
+)
+export const CSPSharedOperatorRVS = buildOperatorRVS(
+	OperatorSchema(CSPOperatorRoleSchema),
+	OperatorUpdateSchema(CSPOperatorRoleSchema)
+)
+export const LSPSharedOperatorRVS = buildOperatorRVS(
+	OperatorSchema(LSPOperatorRoleSchema),
+	OperatorUpdateSchema(LSPOperatorRoleSchema)
+)
+export const IoTSPSharedOperatorRVS = buildOperatorRVS(
+	OperatorSchema(Type.String()),
+	OperatorUpdateSchema(Type.String())
+)
+
+// ─── ctype dispatcher ─────────────────────────────────────────────────────────
+
+export const SharedOperatorRVS = ( ctype: ContextType ) => {
+	switch( ctype ){
+		case 'DEV':   return DEVSharedOperatorRVS
+		case 'CSP':   return CSPSharedOperatorRVS
+		case 'LSP':   return LSPSharedOperatorRVS
+		case 'IoTSP': return IoTSPSharedOperatorRVS
+		default: return buildOperatorRVS(OperatorSchema(Type.String()), OperatorUpdateSchema(Type.String()))
+	}
+}
+
+// ─── Validation types ─────────────────────────────────────────────────────────
+
+export type DEVSharedOperatorRetrieveValidation = {
+	headers: Static<typeof DEVSharedOperatorRVS.retrieve.headers>
+	params: Static<typeof DEVSharedOperatorRVS.retrieve.params>
+	response: Static<typeof DEVSharedOperatorRVS.retrieve.response>
+}
+export type DEVSharedOperatorFetchValidation = {
+	headers: Static<typeof DEVSharedOperatorRVS.fetch.headers>
+	querystring: Static<typeof DEVSharedOperatorRVS.fetch.querystring>
+	response: Static<typeof DEVSharedOperatorRVS.fetch.response>
+}
+export type DEVSharedOperatorUpdateValidation = {
+	headers: Static<typeof DEVSharedOperatorRVS.update.headers>
+	params: Static<typeof DEVSharedOperatorRVS.update.params>
+	body: Static<typeof DEVSharedOperatorRVS.update.body>
+	response: Static<typeof DEVSharedOperatorRVS.update.response>
+}
+export type DEVSharedOperatorRemoveValidation = {
+	headers: Static<typeof DEVSharedOperatorRVS.remove.headers>
+	params: Static<typeof DEVSharedOperatorRVS.remove.params>
+	response: Static<typeof DEVSharedOperatorRVS.remove.response>
+}
+
+export type CSPSharedOperatorRetrieveValidation = {
+	headers: Static<typeof CSPSharedOperatorRVS.retrieve.headers>
+	params: Static<typeof CSPSharedOperatorRVS.retrieve.params>
+	response: Static<typeof CSPSharedOperatorRVS.retrieve.response>
+}
+export type CSPSharedOperatorFetchValidation = {
+	headers: Static<typeof CSPSharedOperatorRVS.fetch.headers>
+	querystring: Static<typeof CSPSharedOperatorRVS.fetch.querystring>
+	response: Static<typeof CSPSharedOperatorRVS.fetch.response>
+}
+export type CSPSharedOperatorUpdateValidation = {
+	headers: Static<typeof CSPSharedOperatorRVS.update.headers>
+	params: Static<typeof CSPSharedOperatorRVS.update.params>
+	body: Static<typeof CSPSharedOperatorRVS.update.body>
+	response: Static<typeof CSPSharedOperatorRVS.update.response>
+}
+export type CSPSharedOperatorRemoveValidation = {
+	headers: Static<typeof CSPSharedOperatorRVS.remove.headers>
+	params: Static<typeof CSPSharedOperatorRVS.remove.params>
+	response: Static<typeof CSPSharedOperatorRVS.remove.response>
+}
+
+export type LSPSharedOperatorRetrieveValidation = {
+	headers: Static<typeof LSPSharedOperatorRVS.retrieve.headers>
+	params: Static<typeof LSPSharedOperatorRVS.retrieve.params>
+	response: Static<typeof LSPSharedOperatorRVS.retrieve.response>
+}
+export type LSPSharedOperatorFetchValidation = {
+	headers: Static<typeof LSPSharedOperatorRVS.fetch.headers>
+	querystring: Static<typeof LSPSharedOperatorRVS.fetch.querystring>
+	response: Static<typeof LSPSharedOperatorRVS.fetch.response>
+}
+export type LSPSharedOperatorUpdateValidation = {
+	headers: Static<typeof LSPSharedOperatorRVS.update.headers>
+	params: Static<typeof LSPSharedOperatorRVS.update.params>
+	body: Static<typeof LSPSharedOperatorRVS.update.body>
+	response: Static<typeof LSPSharedOperatorRVS.update.response>
+}
+export type LSPSharedOperatorRemoveValidation = {
+	headers: Static<typeof LSPSharedOperatorRVS.remove.headers>
+	params: Static<typeof LSPSharedOperatorRVS.remove.params>
+	response: Static<typeof LSPSharedOperatorRVS.remove.response>
+}
+
+export type IoTSPSharedOperatorRetrieveValidation = {
+	headers: Static<typeof IoTSPSharedOperatorRVS.retrieve.headers>
+	params: Static<typeof IoTSPSharedOperatorRVS.retrieve.params>
+	response: Static<typeof IoTSPSharedOperatorRVS.retrieve.response>
+}
+export type IoTSPSharedOperatorFetchValidation = {
+	headers: Static<typeof IoTSPSharedOperatorRVS.fetch.headers>
+	querystring: Static<typeof IoTSPSharedOperatorRVS.fetch.querystring>
+	response: Static<typeof IoTSPSharedOperatorRVS.fetch.response>
+}
+export type IoTSPSharedOperatorUpdateValidation = {
+	headers: Static<typeof IoTSPSharedOperatorRVS.update.headers>
+	params: Static<typeof IoTSPSharedOperatorRVS.update.params>
+	body: Static<typeof IoTSPSharedOperatorRVS.update.body>
+	response: Static<typeof IoTSPSharedOperatorRVS.update.response>
+}
+export type IoTSPSharedOperatorRemoveValidation = {
+	headers: Static<typeof IoTSPSharedOperatorRVS.remove.headers>
+	params: Static<typeof IoTSPSharedOperatorRVS.remove.params>
+	response: Static<typeof IoTSPSharedOperatorRVS.remove.response>
+}

package/src/shared/tracking.ts

@@ -0,0 +1,30 @@
+import { Static, Type } from '@sinclair/typebox'
+import {
+	APIHeadersSchema,
+	APIResponseDataSchemaFactory
+} from '../api'
+import { RTLocationSchema } from '../geo'
+
+export const SharedTrackingSessionRVS = {
+	headers: APIHeadersSchema,
+	params: Type.Object({ reference: Type.String({ example: 'ORD-XK9M2P' }) }),
+	querystring: Type.Object({
+		role: Type.Union([
+			Type.Literal('agent'),
+			Type.Literal('customer')
+		], { description: 'Must match the utype used at Socket.IO connect time' })
+	}),
+	response: APIResponseDataSchemaFactory({
+		jrtoken: Type.String({ description: 'Join Room Token for Socket.IO order room', example: 'jrt.eyJyb29tIjoiT1JELVhLOU0yUCIsInJvbGUiOiJjdXN0b21lciJ9.sig' }),
+		lastLocation: Type.Optional(RTLocationSchema),
+		agentOnline: Type.Boolean({ example: true }),
+		since: Type.Number({ description: 'Timestamp to use for REPLAY event since param', example: 1741219200000 })
+	})
+}
+
+export type SharedTrackingSessionValidation = {
+	headers: Static<typeof SharedTrackingSessionRVS.headers>,
+	params: Static<typeof SharedTrackingSessionRVS.params>,
+	querystring: Static<typeof SharedTrackingSessionRVS.querystring>,
+	response: Static<typeof SharedTrackingSessionRVS.response>
+}

package/src/shared/user.ts

@@ -0,0 +1,42 @@
+import { Type, Static } from '@sinclair/typebox'
+import {
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory,
+	FetchByQueryRequestSchema
+} from '../api'
+import { UserAccountPublicSchema } from '../user'
+
+export const SharedUserRetrieveRVS = {
+	headers: APIHeadersSchema,
+	params: Type.Object({ uid: Type.String() }),
+	response: APIResponseDataSchemaFactory({ user: Type.Omit(UserAccountPublicSchema, ['_id', 'contexts']) })
+}
+
+export const SharedUserFetchRVS = {
+	headers: APIHeadersSchema,
+	querystring: FetchByQueryRequestSchema,
+	response: APIResponseDataSchemaFactory({ users: Type.Array(Type.Omit(UserAccountPublicSchema, ['_id', 'contexts'])) })
+}
+
+export const SharedUserRemoveRVS = {
+	headers: APIHeadersSchema,
+	params: Type.Object({ uid: Type.String() }),
+	response: APIResponseBaseSchema
+}
+
+export type SharedUserRetrieveValidation = {
+	headers: Static<typeof SharedUserRetrieveRVS.headers>,
+	params: Static<typeof SharedUserRetrieveRVS.params>,
+	response: Static<typeof SharedUserRetrieveRVS.response>
+}
+export type SharedUserFetchValidation = {
+	headers: Static<typeof SharedUserFetchRVS.headers>,
+	querystring: Static<typeof SharedUserFetchRVS.querystring>,
+	response: Static<typeof SharedUserFetchRVS.response>
+}
+export type SharedUserRemoveValidation = {
+	headers: Static<typeof SharedUserRemoveRVS.headers>,
+	params: Static<typeof SharedUserRemoveRVS.params>,
+	response: Static<typeof SharedUserRemoveRVS.response>
+}

package/src/sync.ts

@@ -0,0 +1,364 @@
+import { Type, Static } from '@sinclair/typebox'
+import { ActionRecordSchema, DateTimeRangeSchema, DateTimeZoneSchema } from './time'
+import { ContextSchema } from './context'
+import { LSPServiceContextSchema } from './lsp'
+import { CSPServiceContextSchema } from './csp/base'
+
+export const SyncDirectionSchema = Type.Union([
+  Type.Literal('PUSH'),
+  Type.Literal('PULL')
+])
+
+// Sync Status Schema
+export const SyncStatusSchema = Type.Union([
+  Type.Literal('SYNCED'),
+  Type.Literal('PENDING'),
+  Type.Literal('IN_PROGRESS'),
+  Type.Literal('CONFLICT'),
+  Type.Literal('ERROR'),
+  Type.Literal('MANUAL_REVIEW')
+])
+
+// Sync Alert Type Schema
+export const SyncAlertTypeSchema = Type.Union([
+  Type.Literal('LOW_STOCK'),
+  Type.Literal('REORDER_POINT'),
+  Type.Literal('EXPIRY_WARNING'),
+  Type.Literal('SYNC_FAILURE'),
+  Type.Literal('QUALITY_ISSUE')
+])
+
+// Sync Alert Severity Schema
+export const SyncAlertSeveritySchema = Type.Union([
+  Type.Literal('INFO'),
+  Type.Literal('WARNING'),
+  Type.Literal('CRITICAL')
+])
+
+// Sync Conflict Type Schema
+export const SyncConflictTypeSchema = Type.Union([
+  Type.Literal('PRICE_MISMATCH'),
+  Type.Literal('DESCRIPTION_MISMATCH'),
+  Type.Literal('SKU_CONFLICT'),
+  Type.Literal('QUANTITY_MISMATCH'),
+  Type.Literal('STATUS_MISMATCH'),
+  Type.Literal('MISSING_IN_LSP'),
+  Type.Literal('ORPHANED_IN_LSP'),
+  Type.Literal('SKU_MAPPING_CONFLICT'),
+  Type.Literal('DUPLICATE_SKU')
+])
+
+// Sync Conflict Schema
+export const SyncConflictSchema = Type.Object({
+  id: Type.String(),
+  type: SyncConflictTypeSchema,
+  sku: Type.String(),
+  productId: Type.Optional(Type.String()),
+  field: Type.String(),
+  providerValue: Type.Any(),
+  clientValue: Type.Any(),
+  delta: Type.Optional(Type.Number()),
+  detected: ActionRecordSchema,
+  resolved: Type.Optional(ActionRecordSchema),
+  resolution: Type.Optional(Type.Object({
+    strategy: Type.Union([
+      Type.Literal('PROVIDER_WINS'),
+      Type.Literal('CLIENT_WINS'),
+      Type.Literal('MANUAL_OVERRIDE'),
+      Type.Literal('AVERAGE'),
+      Type.Literal('NO_ACTION')
+    ]),
+    action: Type.Optional(Type.String()),
+    performed: Type.Optional(ActionRecordSchema)
+  })),
+  notes: Type.Optional(Type.String({ maxLength: 1000 }))
+})
+
+// Sync Event Type Schema
+export const SyncEventTypeSchema = Type.Union([
+  Type.Literal('INVENTORY_UPDATE'),
+  Type.Literal('PRODUCT_UPDATE'),
+  Type.Literal('PRICE_CHANGE'),
+  Type.Literal('STATUS_CHANGE'),
+  Type.Literal('BULK_SYNC')
+])
+
+// Sync Event Schema
+export const SyncEventSchema = Type.Object({
+  id: Type.String(),
+  type: SyncEventTypeSchema,
+  provider: ContextSchema,
+  client: CSPServiceContextSchema,
+  system: Type.Object({
+    source: Type.Union([Type.Literal('PROVIDER'), Type.Literal('CLIENT')]),
+    target: Type.Union([Type.Literal('PROVIDER'), Type.Literal('CLIENT')])
+  }),
+  productIds: Type.Array(Type.String()),
+  inventoryItemIds: Type.Optional(Type.Array(Type.String())),
+  changes: Type.Record(Type.String(), Type.Any()),
+  conflicts: Type.Optional(Type.Array(SyncConflictSchema)),
+  status: Type.Union([
+    Type.Literal('PENDING'),
+    Type.Literal('IN_PROGRESS'),
+    Type.Literal('COMPLETED'),
+    Type.Literal('FAILED'),
+    Type.Literal('PARTIAL')
+  ]),
+  initiated: ActionRecordSchema,
+  completed: Type.Optional(ActionRecordSchema),
+  successCount: Type.Number({ minimum: 0 }),
+  failureCount: Type.Number({ minimum: 0 }),
+  conflictCount: Type.Number({ minimum: 0 }),
+  errors: Type.Optional(Type.Array(Type.String())),
+  retryCount: Type.Number({ minimum: 0 }),
+  maxRetries: Type.Number({ minimum: 0 }),
+  nextRetryAt: Type.Optional(DateTimeZoneSchema)
+})
+
+// Generate TypeScript types from schemas
+export type SyncDirection = Static<typeof SyncDirectionSchema>
+export type SyncStatus = Static<typeof SyncStatusSchema>
+export type SyncAlertType = Static<typeof SyncAlertTypeSchema>
+export type SyncAlertSeverity = Static<typeof SyncAlertSeveritySchema>
+export type SyncConflictType = Static<typeof SyncConflictTypeSchema>
+export type SyncConflict = Static<typeof SyncConflictSchema>
+export type SyncEventType = Static<typeof SyncEventTypeSchema>
+export type SyncEvent = Static<typeof SyncEventSchema>
+
+// Additional utility schemas for sync operations
+export const SyncConfigSchema = Type.Object({
+  provider: ContextSchema,
+  client: CSPServiceContextSchema,
+  connectorId: Type.String(),
+  syncDirection: Type.Union([
+    Type.Literal('PROVIDER_TO_CLIENT'),
+    Type.Literal('CLIENT_TO_PROVIDER'),
+    Type.Literal('BIDIRECTIONAL')
+  ]),
+  autoResolveConflicts: Type.Boolean(),
+  conflictResolutionStrategy: Type.Union([
+    Type.Literal('PROVIDER_PRIORITY'),
+    Type.Literal('CLIENT_PRIORITY'),
+    Type.Literal('MANUAL_REVIEW'),
+    Type.Literal('LATEST_WINS')
+  ]),
+  syncFrequency: Type.Object({
+    inventory: Type.String({ description: 'Cron expression for inventory sync' }),
+    products: Type.String({ description: 'Cron expression for product sync' }),
+    prices: Type.String({ description: 'Cron expression for price sync' })
+  }),
+  filters: Type.Optional(Type.Object({
+    productCategories: Type.Optional(Type.Array(Type.String())),
+    locationIds: Type.Optional(Type.Array(Type.String())),
+    minimumStock: Type.Optional(Type.Number({ minimum: 0 })),
+    syncOnlyActive: Type.Optional(Type.Boolean())
+  })),
+  retryPolicy: Type.Object({
+    maxRetries: Type.Number({ minimum: 0, maximum: 10 }),
+    retryDelay: Type.Number({ minimum: 1, description: 'Delay in seconds' }),
+    backoffMultiplier: Type.Number({ minimum: 1, maximum: 5 })
+  }),
+  notifications: Type.Object({
+    onSuccess: Type.Boolean(),
+    onFailure: Type.Boolean(),
+    onConflict: Type.Boolean(),
+    recipients: Type.Array(Type.String({ format: 'email' }))
+  })
+})
+
+export const SyncAlertSchema = Type.Object({
+  id: Type.String(),
+  type: SyncAlertTypeSchema,
+  severity: SyncAlertSeveritySchema,
+  title: Type.String({ maxLength: 200 }),
+  message: Type.String({ maxLength: 1000 }),
+  provider: ContextSchema,
+  client: Type.String(),
+  productIds: Type.Optional(Type.Array(Type.String())),
+  locationIds: Type.Optional(Type.Array(Type.String())),
+  metadata: Type.Optional(Type.Record(Type.String(), Type.Any())),
+  acknowledged: Type.Boolean(),
+  acknowledgedBy: Type.Optional(Type.String()),
+  acknowledgedAt: Type.Optional(DateTimeZoneSchema),
+  resolved: Type.Boolean(),
+  resolvedBy: Type.Optional(Type.String()),
+  resolvedAt: Type.Optional(DateTimeZoneSchema),
+  created: ActionRecordSchema,
+  expiresAt: Type.Optional(DateTimeZoneSchema)
+})
+
+export const SyncLogSchema = Type.Object({
+  id: Type.String(),
+  direction: SyncDirectionSchema,
+  provider: ContextSchema,
+  client: CSPServiceContextSchema,
+  status: SyncStatusSchema,
+  eventId: Type.String(),
+  level: Type.Union([
+    Type.Literal('DEBUG'),
+    Type.Literal('INFO'),
+    Type.Literal('WARN'),
+    Type.Literal('ERROR')
+  ]),
+  message: Type.String({ maxLength: 2000 }),
+  component: Type.String({ description: 'Sync component that generated the log' }),
+  metadata: Type.Optional(Type.Record(Type.String(), Type.Any())),
+  stackTrace: Type.Optional(Type.String()),
+  itemsProcessed: Type.Number({ minimum: 0 }),
+  itemsFailed: Type.Number({ minimum: 0 }),
+  errorLog: Type.Optional(Type.Array(Type.Object({
+    productId: Type.String(),
+    sku: Type.String(),
+    error: Type.String()
+  }))),
+  schedule: DateTimeRangeSchema
+})
+
+export const SyncStatsSchema = Type.Object({
+  provider: ContextSchema,
+  client: CSPServiceContextSchema,
+  period: Type.Object({
+    start: DateTimeZoneSchema,
+    end: DateTimeZoneSchema
+  }),
+  events: Type.Object({
+    total: Type.Number({ minimum: 0 }),
+    successful: Type.Number({ minimum: 0 }),
+    failed: Type.Number({ minimum: 0 }),
+    partial: Type.Number({ minimum: 0 }),
+    byType: Type.Record(SyncEventTypeSchema, Type.Number({ minimum: 0 }))
+  }),
+  conflicts: Type.Object({
+    total: Type.Number({ minimum: 0 }),
+    resolved: Type.Number({ minimum: 0 }),
+    pending: Type.Number({ minimum: 0 }),
+    byType: Type.Record(SyncConflictTypeSchema, Type.Number({ minimum: 0 }))
+  }),
+  performance: Type.Object({
+    averageSyncTime: Type.Number({ minimum: 0, description: 'Average sync time in seconds' }),
+    throughput: Type.Number({ minimum: 0, description: 'Records processed per minute' }),
+    errorRate: Type.Number({ minimum: 0, maximum: 100, description: 'Error rate percentage' }),
+    uptime: Type.Number({ minimum: 0, maximum: 100, description: 'Sync uptime percentage' })
+  }),
+  lastSync: Type.Optional(DateTimeZoneSchema),
+  nextScheduledSync: Type.Optional(DateTimeZoneSchema)
+})
+
+export const SyncHealthCheckSchema = Type.Object({
+  provider: ContextSchema,
+  client: CSPServiceContextSchema,
+  connectorId: Type.String(),
+  status: Type.Union([
+    Type.Literal('HEALTHY'),
+    Type.Literal('DEGRADED'),
+    Type.Literal('UNHEALTHY'),
+    Type.Literal('OFFLINE')
+  ]),
+  lastCheck: DateTimeZoneSchema,
+  checks: Type.Object({
+    connectivity: Type.Boolean(),
+    authentication: Type.Boolean(),
+    dataConsistency: Type.Boolean(),
+    performance: Type.Boolean()
+  }),
+  issues: Type.Optional(Type.Array(Type.String())),
+  recommendations: Type.Optional(Type.Array(Type.String())),
+  metrics: Type.Object({
+    responseTime: Type.Number({ minimum: 0, description: 'Response time in milliseconds' }),
+    lastSuccessfulSync: Type.Optional(DateTimeZoneSchema),
+    consecutiveFailures: Type.Number({ minimum: 0 }),
+    dataLag: Type.Optional(Type.Number({ minimum: 0, description: 'Data lag in minutes' }))
+  })
+})
+
+export type SyncConfig = Static<typeof SyncConfigSchema>
+export type SyncAlert = Static<typeof SyncAlertSchema>
+export type SyncLog = Static<typeof SyncLogSchema>
+export type SyncStats = Static<typeof SyncStatsSchema>
+export type SyncHealthCheck = Static<typeof SyncHealthCheckSchema>
+
+// ===== ENTERPRISE FEATURES =====
+
+// LSP Inventory Webhook Events
+export const LSPInventoryWebhookEventSchema = Type.Union([
+  Type.Literal('INVENTORY_RECEIVED'),
+  Type.Literal('INVENTORY_ADJUSTED'),
+  Type.Literal('INVENTORY_PICKED'),
+  Type.Literal('INVENTORY_DAMAGED'),
+  Type.Literal('INVENTORY_EXPIRED'),
+  Type.Literal('INVENTORY_TRANSFERRED'),
+  Type.Literal('LOW_STOCK_ALERT'),
+  Type.Literal('SYNC_CONFLICT'),
+  Type.Literal('RESERVATION_EXPIRED')
+])
+
+// Inventory Reservation Schema
+export const LSPInventoryReservationSchema = Type.Object({
+  id: Type.String(),
+  orderReference: Type.String(),
+  client: CSPServiceContextSchema,
+  provider: LSPServiceContextSchema,
+  items: Type.Array(Type.Object({
+    sku: Type.String(),
+    productId: Type.String(),
+    inventoryItemId: Type.String(),
+    requestedQuantity: Type.Number({ minimum: 0 }),
+    reservedQuantity: Type.Number({ minimum: 0 })
+  })),
+  status: Type.Union([
+    Type.Literal('ACTIVE'),
+    Type.Literal('COMMITTED'),
+    Type.Literal('RELEASED'),
+    Type.Literal('EXPIRED')
+  ]),
+  expiry: Type.Number(),
+  created: ActionRecordSchema,
+  committed: Type.Optional(ActionRecordSchema),
+  released: Type.Optional(ActionRecordSchema)
+})
+
+// Batch Operation Schema
+export const BatchOperationSchema = Type.Object({
+  batchId: Type.String(),
+  client: CSPServiceContextSchema,
+  provider: LSPServiceContextSchema,
+  totalOperations: Type.Number({ minimum: 0 }),
+  status: Type.Union([
+    Type.Literal('PENDING'),
+    Type.Literal('VALIDATING'),
+    Type.Literal('IN_PROGRESS'),
+    Type.Literal('COMPLETED'),
+    Type.Literal('FAILED'),
+    Type.Literal('PARTIAL')
+  ]),
+  progress: Type.Object({
+    processed: Type.Number({ minimum: 0 }),
+    successful: Type.Number({ minimum: 0 }),
+    failed: Type.Number({ minimum: 0 }),
+    percentage: Type.Number({ minimum: 0, maximum: 100 })
+  }),
+  errors: Type.Optional(Type.Array(Type.Object({
+    sku: Type.String(),
+    action: Type.String(),
+    error: Type.String()
+  }))),
+  started: ActionRecordSchema,
+  completed: Type.Optional(ActionRecordSchema)
+})
+
+// Batch Operation Item Schema
+export const BatchOperationItemSchema = Type.Object({
+  sku: Type.String(),
+  action: Type.Union([
+    Type.Literal('CREATE'),
+    Type.Literal('ADJUST'),
+    Type.Literal('UPDATE'),
+    Type.Literal('DELETE')
+  ]),
+  data: Type.Any()
+})
+
+export type LSPInventoryWebhookEvent = Static<typeof LSPInventoryWebhookEventSchema>
+export type LSPInventoryReservation = Static<typeof LSPInventoryReservationSchema>
+export type BatchOperation = Static<typeof BatchOperationSchema>
+export type BatchOperationItem = Static<typeof BatchOperationItemSchema>