@de./types 1.0.0

package/src/csp/analytics.ts

@@ -0,0 +1,238 @@
+import { Type, Static } from '@sinclair/typebox'
+import {
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory,
+	APIHeadersSchema,
+	APIErrorSchema
+} from '../api'
+
+export const AnalyticsTimeRangeSchema = Type.Object({
+	startDate: Type.Number({ description: 'Unix timestamp in milliseconds' }),
+	endDate: Type.Number({ description: 'Unix timestamp in milliseconds' })
+})
+
+export const AnalyticsGroupBySchema = Type.Union([
+	Type.Literal('HOUR'),
+	Type.Literal('DAY'),
+	Type.Literal('WEEK'),
+	Type.Literal('MONTH')
+])
+
+export const OrderAnalyticsRequestSchema = Type.Object({
+	timeRange: AnalyticsTimeRangeSchema,
+	groupBy: Type.Optional(AnalyticsGroupBySchema),
+	status: Type.Optional(Type.Array(Type.String())),
+	channel: Type.Optional(Type.String())
+})
+
+export const FulfillmentAnalyticsRequestSchema = Type.Object({
+	timeRange: AnalyticsTimeRangeSchema,
+	groupBy: Type.Optional(AnalyticsGroupBySchema),
+	provider: Type.Optional(Type.String())
+})
+
+export const ProviderAnalyticsRequestSchema = Type.Object({
+	timeRange: AnalyticsTimeRangeSchema,
+	providerId: Type.Optional(Type.String())
+})
+
+export const ReportTypeSchema = Type.Union([
+	Type.Literal('ORDER_SUMMARY'),
+	Type.Literal('FULFILLMENT_PERFORMANCE'),
+	Type.Literal('INVENTORY_STATUS'),
+	Type.Literal('PROVIDER_COMPARISON'),
+	Type.Literal('EXCEPTION_REPORT'),
+	Type.Literal('CUSTOM')
+])
+
+export const ReportFormatSchema = Type.Union([
+	Type.Literal('JSON'),
+	Type.Literal('CSV'),
+	Type.Literal('PDF')
+])
+
+export const ReportStatusSchema = Type.Union([
+	Type.Literal('PENDING'),
+	Type.Literal('GENERATING'),
+	Type.Literal('COMPLETED'),
+	Type.Literal('FAILED')
+])
+
+export const GenerateReportRequestSchema = Type.Object({
+	type: ReportTypeSchema,
+	format: ReportFormatSchema,
+	timeRange: AnalyticsTimeRangeSchema,
+	filters: Type.Optional(Type.Record(Type.String(), Type.Any())),
+	includeCharts: Type.Optional(Type.Boolean())
+})
+
+export const ReportSchema = Type.Object({
+	id: Type.String(),
+	type: ReportTypeSchema,
+	format: ReportFormatSchema,
+	status: ReportStatusSchema,
+	timeRange: AnalyticsTimeRangeSchema,
+	filters: Type.Optional(Type.Record(Type.String(), Type.Any())),
+	fileUrl: Type.Optional(Type.String()),
+	fileSize: Type.Optional(Type.Number()),
+	error: Type.Optional(Type.String()),
+	generatedAt: Type.Optional(Type.Number()),
+	expiresAt: Type.Optional(Type.Number()),
+	requestedAt: Type.Number()
+})
+
+export type AnalyticsTimeRange = Static<typeof AnalyticsTimeRangeSchema>
+export type AnalyticsGroupBy = Static<typeof AnalyticsGroupBySchema>
+export type OrderAnalyticsRequest = Static<typeof OrderAnalyticsRequestSchema>
+export type FulfillmentAnalyticsRequest = Static<typeof FulfillmentAnalyticsRequestSchema>
+export type ProviderAnalyticsRequest = Static<typeof ProviderAnalyticsRequestSchema>
+export type ReportType = Static<typeof ReportTypeSchema>
+export type ReportFormat = Static<typeof ReportFormatSchema>
+export type ReportStatus = Static<typeof ReportStatusSchema>
+export type GenerateReportRequest = Static<typeof GenerateReportRequestSchema>
+export type Report = Static<typeof ReportSchema>
+
+// ─── CSP Analytics RVS ───────────────────────────────────────────────────────
+
+export const CSPAnalyticsOrdersRVS = {
+	headers: APIHeadersSchema,
+	body: OrderAnalyticsRequestSchema,
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			metrics: Type.Object({
+				totalOrders: Type.Number(),
+				completedOrders: Type.Number(),
+				cancelledOrders: Type.Number(),
+				pendingOrders: Type.Number(),
+				averageValue: Type.Optional(Type.Number()),
+				completionRate: Type.Number()
+			}),
+			timeSeries: Type.Optional(Type.Array(Type.Object({
+				timestamp: Type.Number(),
+				count: Type.Number(),
+				value: Type.Optional(Type.Number())
+			}))),
+			breakdown: Type.Optional(Type.Record(Type.String(), Type.Number()))
+		})
+	])
+}
+export type CSPAnalyticsOrdersValidation = {
+	body: Static<typeof CSPAnalyticsOrdersRVS.body>
+	response: Static<typeof CSPAnalyticsOrdersRVS.response>
+}
+
+export const CSPAnalyticsFulfillmentRVS = {
+	headers: APIHeadersSchema,
+	body: FulfillmentAnalyticsRequestSchema,
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			metrics: Type.Object({
+				totalOrders: Type.Number(),
+				onTimeDeliveries: Type.Number(),
+				lateDeliveries: Type.Number(),
+				averageLeadTime: Type.Optional(Type.Number()),
+				onTimeRate: Type.Number()
+			}),
+			timeSeries: Type.Optional(Type.Array(Type.Object({
+				timestamp: Type.Number(),
+				onTime: Type.Number(),
+				late: Type.Number()
+			}))),
+			providerBreakdown: Type.Optional(Type.Array(Type.Object({
+				providerId: Type.String(),
+				providerName: Type.String(),
+				totalOrders: Type.Number(),
+				onTimeRate: Type.Number()
+			})))
+		})
+	])
+}
+export type CSPAnalyticsFulfillmentValidation = {
+	body: Static<typeof CSPAnalyticsFulfillmentRVS.body>
+	response: Static<typeof CSPAnalyticsFulfillmentRVS.response>
+}
+
+export const CSPAnalyticsProvidersRVS = {
+	headers: APIHeadersSchema,
+	body: ProviderAnalyticsRequestSchema,
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			providers: Type.Array(Type.Object({
+				providerId: Type.String(),
+				providerName: Type.String(),
+				providerType: Type.String(),
+				metrics: Type.Object({
+					totalOrders: Type.Number(),
+					completedOrders: Type.Number(),
+					failedOrders: Type.Number(),
+					averageCost: Type.Optional(Type.Number()),
+					averageLeadTime: Type.Optional(Type.Number()),
+					successRate: Type.Number(),
+					reliability: Type.Number()
+				}),
+				rating: Type.Optional(Type.Number())
+			}))
+		})
+	])
+}
+export type CSPAnalyticsProvidersValidation = {
+	body: Static<typeof CSPAnalyticsProvidersRVS.body>
+	response: Static<typeof CSPAnalyticsProvidersRVS.response>
+}
+
+export const CSPAnalyticsGenerateReportRVS = {
+	headers: APIHeadersSchema,
+	body: GenerateReportRequestSchema,
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			reportId: Type.String(),
+			status: Type.String()
+		})
+	])
+}
+export type CSPAnalyticsGenerateReportValidation = {
+	body: Static<typeof CSPAnalyticsGenerateReportRVS.body>
+	response: Static<typeof CSPAnalyticsGenerateReportRVS.response>
+}
+
+export const CSPAnalyticsGetReportRVS = {
+	headers: APIHeadersSchema,
+	params: Type.Object({ id: Type.String() }),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			report: ReportSchema
+		})
+	])
+}
+export type CSPAnalyticsGetReportValidation = {
+	params: Static<typeof CSPAnalyticsGetReportRVS.params>
+	response: Static<typeof CSPAnalyticsGetReportRVS.response>
+}
+
+export const CSPAnalyticsListReportsRVS = {
+	headers: APIHeadersSchema,
+	querystring: Type.Object({
+		page: Type.Optional(Type.Number({ minimum: 1 })),
+		limit: Type.Optional(Type.Number({ minimum: 1, maximum: 100 })),
+		type: Type.Optional(Type.String()),
+		status: Type.Optional(Type.String())
+	}),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			reports: Type.Array(ReportSchema),
+			total: Type.Number(),
+			page: Type.Number(),
+			limit: Type.Number()
+		})
+	])
+}
+export type CSPAnalyticsListReportsValidation = {
+	querystring: Static<typeof CSPAnalyticsListReportsRVS.querystring>
+	response: Static<typeof CSPAnalyticsListReportsRVS.response>
+}

package/src/csp/base.ts

@@ -0,0 +1,18 @@
+import { Type, Static } from '@sinclair/typebox'
+
+export const CSPTypeSchema = Type.Union([
+	Type.Literal('RETAIL'),
+	Type.Literal('VENDOR'),
+	Type.Literal('SHIPPER'),
+	Type.Literal('MANUFACTURER')
+])
+
+export const CSPServiceContextSchema = Type.Object({
+	providerType: CSPTypeSchema,
+	type: Type.String({ description: 'External client system type identifier' }),
+	id: Type.String(),
+	description: Type.Optional(Type.String({ minLength: 10, maxLength: 250 }))
+})
+
+export type CSPType = Static<typeof CSPTypeSchema>
+export type CSPServiceContext = Static<typeof CSPServiceContextSchema>

package/src/csp/index.ts

@@ -0,0 +1,41 @@
+import { Type, Static } from '@sinclair/typebox'
+import {
+	SPProfileSchema,
+	SPProfileUpdateSchema
+} from '../context'
+import { CSPTypeSchema } from './base'
+
+export * from './base'
+
+// LSP Schema
+export const CSPSchema = Type.Composite([
+	SPProfileSchema,
+	Type.Object({
+		type: CSPTypeSchema
+	})
+])
+export const CSPUpdateSchema = Type.Composite([
+	SPProfileUpdateSchema,
+	Type.Object({
+		type: Type.Optional(CSPTypeSchema)
+	})
+])
+
+export const CSPOperatorRoleSchema = Type.Union([
+	Type.Literal('ADMIN'),
+	Type.Literal('READONLY'),
+	Type.Literal('MANAGER'),
+	Type.Literal('SUPERVISOR'),
+	Type.Literal('COORDINATOR'),
+	Type.Literal('DISPATCHER'),
+	Type.Literal('TECHNICIAN')
+])
+
+export type CSP = Static<typeof CSPSchema>
+export type CSPUpdate = Static<typeof CSPUpdateSchema>
+export type CSPOperatorRole = Static<typeof CSPOperatorRoleSchema>
+
+export * from './order'
+export * from './webhook'
+export * from './analytics'
+export * from './inventory'

package/src/csp/inventory.ts

@@ -0,0 +1,325 @@
+import { Type, Static } from '@sinclair/typebox'
+import { LSPServiceContextSchema } from '../lsp'
+import {
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory,
+	APIHeadersSchema,
+	APIErrorSchema
+} from '../api'
+import { SyncConflictSchema, BatchOperationItemSchema } from '../sync'
+
+// ─── CSP Inventory RVS ───────────────────────────────────────────────────────
+
+export const CSPInventorySyncCatalogRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({
+		provider: LSPServiceContextSchema,
+		externalCatalog: Type.Array(
+			Type.Object({
+				sku: Type.String(),
+				expectedQuantity: Type.Number({ minimum: 0 })
+			}),
+			{ minItems: 1, maxItems: 1000 }
+		),
+		options: Type.Optional(Type.Object({
+			autoResolve: Type.Optional(Type.Boolean()),
+			conflictStrategy: Type.Optional(Type.Union([
+				Type.Literal('PROVIDER_WINS'),
+				Type.Literal('CLIENT_WINS'),
+				Type.Literal('MANUAL')
+			]))
+		}))
+	}),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			syncId: Type.String(),
+			conflicts: Type.Array(SyncConflictSchema),
+			missingInLSP: Type.Array(Type.String()),
+			orphanedInLSP: Type.Array(Type.String()),
+			resolution: Type.Object({
+				adjustments: Type.Number(),
+				creates: Type.Number(),
+				noAction: Type.Number()
+			})
+		})
+	])
+}
+export type CSPInventorySyncCatalogValidation = {
+	body: Static<typeof CSPInventorySyncCatalogRVS.body>
+	response: Static<typeof CSPInventorySyncCatalogRVS.response>
+}
+
+export const CSPInventoryCheckAvailabilityRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({
+		items: Type.Array(
+			Type.Object({
+				sku: Type.String(),
+				quantity: Type.Number({ minimum: 1 })
+			}),
+			{ minItems: 1 }
+		),
+		options: Type.Optional(Type.Object({
+			providers: Type.Optional(Type.Array(Type.String())),
+			preferredRegion: Type.Optional(Type.String()),
+			allocateOptimally: Type.Optional(Type.Boolean())
+		}))
+	}),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			items: Type.Array(Type.Object({
+				sku: Type.String(),
+				requestedQuantity: Type.Number(),
+				totalAvailable: Type.Number(),
+				allocation: Type.Array(Type.Object({
+					providerId: Type.String(),
+					providerType: Type.String(),
+					available: Type.Number(),
+					allocated: Type.Number(),
+					region: Type.Optional(Type.String())
+				})),
+				fulfillable: Type.Boolean(),
+				estimatedShipTime: Type.Optional(Type.String())
+			})),
+			allFulfillable: Type.Boolean()
+		})
+	])
+}
+export type CSPInventoryCheckAvailabilityValidation = {
+	body: Static<typeof CSPInventoryCheckAvailabilityRVS.body>
+	response: Static<typeof CSPInventoryCheckAvailabilityRVS.response>
+}
+
+export const CSPInventoryBulkPushRVS = {
+	headers: Type.Intersect([
+		APIHeadersSchema,
+		Type.Object({
+			'x-idempotency-key': Type.Optional(Type.String())
+		})
+	]),
+	body: Type.Object({
+		provider: LSPServiceContextSchema,
+		batchId: Type.String(),
+		operations: Type.Array(BatchOperationItemSchema, { minItems: 1, maxItems: 1000 }),
+		options: Type.Optional(Type.Object({
+			continueOnError: Type.Optional(Type.Boolean()),
+			validateOnly: Type.Optional(Type.Boolean())
+		}))
+	}),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			batchId: Type.String(),
+			totalOperations: Type.Number(),
+			successful: Type.Number(),
+			failed: Type.Number(),
+			errors: Type.Optional(Type.Array(Type.Object({
+				sku: Type.String(),
+				error: Type.String(),
+				action: Type.String()
+			}))),
+			syncLogId: Type.String()
+		})
+	])
+}
+export type CSPInventoryBulkPushValidation = {
+	body: Static<typeof CSPInventoryBulkPushRVS.body>
+	response: Static<typeof CSPInventoryBulkPushRVS.response>
+}
+
+export const CSPInventoryBulkPullRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({
+		provider: LSPServiceContextSchema,
+		skus: Type.Optional(Type.Array(Type.String(), { maxItems: 1000 })),
+		filters: Type.Optional(Type.Object({
+			status: Type.Optional(Type.Array(Type.String())),
+			minQuantity: Type.Optional(Type.Number({ minimum: 0 })),
+			updatedSince: Type.Optional(Type.Number())
+		})),
+		pagination: Type.Optional(Type.Object({
+			limit: Type.Number({ minimum: 1, maximum: 1000, default: 1000 }),
+			offset: Type.Number({ minimum: 0, default: 0 })
+		}))
+	}),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			items: Type.Array(Type.Object({
+				sku: Type.String(),
+				productId: Type.String(),
+				quantity: Type.Object({
+					total: Type.Number(),
+					available: Type.Number(),
+					reserved: Type.Number()
+				}),
+				providerId: Type.String(),
+				status: Type.String(),
+				lastUpdated: Type.Number()
+			})),
+			total: Type.Number(),
+			hasMore: Type.Boolean(),
+			nextOffset: Type.Optional(Type.Number())
+		})
+	])
+}
+export type CSPInventoryBulkPullValidation = {
+	body: Static<typeof CSPInventoryBulkPullRVS.body>
+	response: Static<typeof CSPInventoryBulkPullRVS.response>
+}
+
+export const CSPInventoryGetSyncStatusRVS = {
+	headers: APIHeadersSchema,
+	params: Type.Object({ syncId: Type.String() }),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			syncId: Type.String(),
+			status: Type.Union([
+				Type.Literal('IN_PROGRESS'),
+				Type.Literal('COMPLETED'),
+				Type.Literal('FAILED'),
+				Type.Literal('PARTIAL')
+			]),
+			progress: Type.Object({
+				total: Type.Number(),
+				processed: Type.Number(),
+				successful: Type.Number(),
+				failed: Type.Number(),
+				percentage: Type.Number()
+			}),
+			startedAt: Type.Number(),
+			estimatedCompletion: Type.Optional(Type.Number()),
+			errors: Type.Optional(Type.Array(Type.String()))
+		})
+	])
+}
+export type CSPInventoryGetSyncStatusValidation = {
+	params: Static<typeof CSPInventoryGetSyncStatusRVS.params>
+	response: Static<typeof CSPInventoryGetSyncStatusRVS.response>
+}
+
+export const CSPInventoryReserveRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({
+		provider: LSPServiceContextSchema,
+		orderReference: Type.String(),
+		items: Type.Array(Type.Object({
+			sku: Type.String(),
+			quantity: Type.Number({ minimum: 1 })
+		})),
+		ttl: Type.Optional(Type.Number({ minimum: 60, maximum: 3600 }))
+	}),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			reservationId: Type.String(),
+			items: Type.Array(Type.Object({
+				sku: Type.String(),
+				requested: Type.Number(),
+				reserved: Type.Number(),
+				providerId: Type.String(),
+				expiresAt: Type.Number()
+			})),
+			expiresAt: Type.Number()
+		})
+	])
+}
+export type CSPInventoryReserveValidation = {
+	body: Static<typeof CSPInventoryReserveRVS.body>
+	response: Static<typeof CSPInventoryReserveRVS.response>
+}
+
+export const CSPInventoryCommitRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({
+		reservationId: Type.String(),
+		orderReference: Type.String()
+	}),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			success: Type.Boolean(),
+			items: Type.Array(Type.Object({
+				sku: Type.String(),
+				committedQuantity: Type.Number(),
+				remainingAvailable: Type.Number()
+			}))
+		})
+	])
+}
+export type CSPInventoryCommitValidation = {
+	body: Static<typeof CSPInventoryCommitRVS.body>
+	response: Static<typeof CSPInventoryCommitRVS.response>
+}
+
+export const CSPInventoryReleaseRVS = {
+	headers: APIHeadersSchema,
+	body: Type.Object({
+		reservationId: Type.String(),
+		reason: Type.Optional(Type.Union([
+			Type.Literal('TIMEOUT'),
+			Type.Literal('CANCELLED'),
+			Type.Literal('PAYMENT_FAILED')
+		]))
+	}),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			success: Type.Boolean(),
+			releasedItems: Type.Array(Type.Object({
+				sku: Type.String(),
+				quantity: Type.Number()
+			}))
+		})
+	])
+}
+export type CSPInventoryReleaseValidation = {
+	body: Static<typeof CSPInventoryReleaseRVS.body>
+	response: Static<typeof CSPInventoryReleaseRVS.response>
+}
+
+export const CSPInventoryListReservationsRVS = {
+	headers: APIHeadersSchema,
+	querystring: Type.Object({
+		page: Type.Optional(Type.Number({ minimum: 1 })),
+		limit: Type.Optional(Type.Number({ minimum: 1, maximum: 100 })),
+		status: Type.Optional(Type.Union([
+			Type.Literal('ACTIVE'),
+			Type.Literal('COMMITTED'),
+			Type.Literal('RELEASED'),
+			Type.Literal('EXPIRED')
+		])),
+		orderReference: Type.Optional(Type.String())
+	}),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			reservations: Type.Array(Type.Any()),
+			total: Type.Number(),
+			page: Type.Number(),
+			limit: Type.Number()
+		})
+	])
+}
+export type CSPInventoryListReservationsValidation = {
+	querystring: Static<typeof CSPInventoryListReservationsRVS.querystring>
+	response: Static<typeof CSPInventoryListReservationsRVS.response>
+}
+
+export const CSPInventoryGetReservationRVS = {
+	headers: APIHeadersSchema,
+	params: Type.Object({ id: Type.String() }),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			reservation: Type.Any()
+		})
+	])
+}
+export type CSPInventoryGetReservationValidation = {
+	params: Static<typeof CSPInventoryGetReservationRVS.params>
+	response: Static<typeof CSPInventoryGetReservationRVS.response>
+}