@de./types 1.0.0

package/src/csp/webhook.ts

@@ -0,0 +1,269 @@
+import { Type, Static } from '@sinclair/typebox'
+import { ActionRecordSchema } from '../time'
+import {
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory,
+	APIHeadersSchema,
+	APIErrorSchema
+} from '../api'
+import { LSPServiceContextSchema } from '../lsp'
+
+export const WebhookEventTypeSchema = Type.Union([
+	Type.Literal('ORDER_CREATED'),
+	Type.Literal('ORDER_UPDATED'),
+	Type.Literal('ORDER_CANCELLED'),
+	Type.Literal('ORDER_COMPLETED'),
+	Type.Literal('EXCEPTION_REPORTED'),
+	Type.Literal('INVENTORY_RECEIVED'),
+	Type.Literal('INVENTORY_ADJUSTED'),
+	Type.Literal('INVENTORY_LOW'),
+	Type.Literal('INVENTORY_SYNCED'),
+	Type.Literal('INVENTORY_RESERVED'),
+	Type.Literal('INVENTORY_RELEASED'),
+	Type.Literal('PIPELINE_STARTED'),
+	Type.Literal('PIPELINE_COMPLETED'),
+	Type.Literal('PIPELINE_FAILED')
+])
+
+export const WebhookStatusSchema = Type.Union([
+	Type.Literal('ACTIVE'),
+	Type.Literal('INACTIVE'),
+	Type.Literal('FAILED')
+])
+
+export const WebhookDeliveryStatusSchema = Type.Union([
+	Type.Literal('PENDING'),
+	Type.Literal('SUCCESS'),
+	Type.Literal('FAILED'),
+	Type.Literal('RETRYING')
+])
+
+export const WebhookSchema = Type.Object({
+	id: Type.String(),
+	url: Type.String({ format: 'uri' }),
+	events: Type.Array(WebhookEventTypeSchema),
+	secret: Type.Optional(Type.String()),
+	status: WebhookStatusSchema,
+	description: Type.Optional(Type.String({ maxLength: 500 })),
+	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+	retryPolicy: Type.Object({
+		maxRetries: Type.Number({ minimum: 0, maximum: 10 }),
+		retryDelay: Type.Number({ minimum: 1000, description: 'milliseconds' })
+	}),
+	stats: Type.Optional(Type.Object({
+		totalDeliveries: Type.Number({ minimum: 0 }),
+		successfulDeliveries: Type.Number({ minimum: 0 }),
+		failedDeliveries: Type.Number({ minimum: 0 }),
+		lastDeliveryAt: Type.Optional(Type.Number())
+	})),
+	created: ActionRecordSchema,
+	updated: Type.Optional(ActionRecordSchema)
+})
+
+export const CreateWebhookSchema = Type.Object({
+	url: Type.String({ format: 'uri' }),
+	events: Type.Array(WebhookEventTypeSchema, { minItems: 1 }),
+	description: Type.Optional(Type.String({ maxLength: 500 })),
+	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+	retryPolicy: Type.Optional(Type.Object({
+		maxRetries: Type.Number({ minimum: 0, maximum: 10 }),
+		retryDelay: Type.Number({ minimum: 1000 })
+	}))
+})
+
+export const UpdateWebhookSchema = Type.Partial(Type.Object({
+	url: Type.String({ format: 'uri' }),
+	events: Type.Array(WebhookEventTypeSchema, { minItems: 1 }),
+	status: WebhookStatusSchema,
+	description: Type.String({ maxLength: 500 }),
+	headers: Type.Record(Type.String(), Type.String()),
+	retryPolicy: Type.Object({
+		maxRetries: Type.Number({ minimum: 0, maximum: 10 }),
+		retryDelay: Type.Number({ minimum: 1000 })
+	})
+}))
+
+export const WebhookDeliveryLogSchema = Type.Object({
+	id: Type.String(),
+	webhookId: Type.String(),
+	event: WebhookEventTypeSchema,
+	status: WebhookDeliveryStatusSchema,
+	requestPayload: Type.Any(),
+	responseStatus: Type.Optional(Type.Number()),
+	responseBody: Type.Optional(Type.String()),
+	error: Type.Optional(Type.String()),
+	attempts: Type.Number({ minimum: 1 }),
+	deliveredAt: Type.Optional(ActionRecordSchema),
+	created: ActionRecordSchema
+})
+
+export type WebhookEventType = Static<typeof WebhookEventTypeSchema>
+export type WebhookStatus = Static<typeof WebhookStatusSchema>
+export type WebhookDeliveryStatus = Static<typeof WebhookDeliveryStatusSchema>
+export type Webhook = Static<typeof WebhookSchema>
+export type CreateWebhook = Static<typeof CreateWebhookSchema>
+export type UpdateWebhook = Static<typeof UpdateWebhookSchema>
+export type WebhookDeliveryLog = Static<typeof WebhookDeliveryLogSchema>
+
+// ─── CSP Webhook RVS ───────────────────────────────────────────────────────
+
+export const CSPWebhookCreateRVS = {
+	headers: APIHeadersSchema,
+	body: CreateWebhookSchema,
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			webhookId: Type.String(),
+			secret: Type.String()
+		})
+	])
+}
+export type CSPWebhookCreateValidation = {
+	body: Static<typeof CSPWebhookCreateRVS.body>
+	response: Static<typeof CSPWebhookCreateRVS.response>
+}
+
+export const CSPWebhookListRVS = {
+	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.String())
+	}),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			webhooks: Type.Array(WebhookSchema),
+			total: Type.Number(),
+			page: Type.Number(),
+			limit: Type.Number()
+		})
+	])
+}
+export type CSPWebhookListValidation = {
+	querystring: Static<typeof CSPWebhookListRVS.querystring>
+	response: Static<typeof CSPWebhookListRVS.response>
+}
+
+export const CSPWebhookRetrieveRVS = {
+	headers: APIHeadersSchema,
+	params: Type.Object({ id: Type.String() }),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			webhook: WebhookSchema
+		})
+	])
+}
+export type CSPWebhookRetrieveValidation = {
+	params: Static<typeof CSPWebhookRetrieveRVS.params>
+	response: Static<typeof CSPWebhookRetrieveRVS.response>
+}
+
+export const CSPWebhookUpdateRVS = {
+	headers: APIHeadersSchema,
+	params: Type.Object({ id: Type.String() }),
+	body: UpdateWebhookSchema,
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			webhookId: Type.String()
+		})
+	])
+}
+export type CSPWebhookUpdateValidation = {
+	params: Static<typeof CSPWebhookUpdateRVS.params>
+	body: Static<typeof CSPWebhookUpdateRVS.body>
+	response: Static<typeof CSPWebhookUpdateRVS.response>
+}
+
+export const CSPWebhookRemoveRVS = {
+	headers: APIHeadersSchema,
+	params: Type.Object({ id: Type.String() }),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			webhookId: Type.String()
+		})
+	])
+}
+export type CSPWebhookRemoveValidation = {
+	params: Static<typeof CSPWebhookRemoveRVS.params>
+	response: Static<typeof CSPWebhookRemoveRVS.response>
+}
+
+export const CSPWebhookLogsRVS = {
+	headers: APIHeadersSchema,
+	params: Type.Object({ id: Type.String() }),
+	querystring: Type.Object({
+		page: Type.Optional(Type.Number({ minimum: 1 })),
+		limit: Type.Optional(Type.Number({ minimum: 1, maximum: 100 })),
+		status: Type.Optional(Type.String())
+	}),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			logs: Type.Array(WebhookDeliveryLogSchema),
+			total: Type.Number(),
+			page: Type.Number(),
+			limit: Type.Number()
+		})
+	])
+}
+export type CSPWebhookLogsValidation = {
+	params: Static<typeof CSPWebhookLogsRVS.params>
+	querystring: Static<typeof CSPWebhookLogsRVS.querystring>
+	response: Static<typeof CSPWebhookLogsRVS.response>
+}
+
+export const CSPWebhookTestRVS = {
+	headers: APIHeadersSchema,
+	params: Type.Object({ id: Type.String() }),
+	body: Type.Optional(Type.Object({
+		payload: Type.Optional(Type.Any())
+	})),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			webhookId: Type.String(),
+			deliveryId: Type.String(),
+			status: Type.String()
+		})
+	])
+}
+export type CSPWebhookTestValidation = {
+	params: Static<typeof CSPWebhookTestRVS.params>
+	body: Static<typeof CSPWebhookTestRVS.body>
+	response: Static<typeof CSPWebhookTestRVS.response>
+}
+
+// ─── CSP Webhook Dispatcher RVS (internal service-to-service) ────────────────
+
+const DispatchInternalHeadersSchema = Type.Object({
+	'de-auth-token': Type.String({ description: 'Internal service auth token' }),
+	'de-auth-device': Type.String(),
+	'de-auth-service': Type.String()
+})
+
+export const CSPWebhookDispatchRVS = {
+	headers: DispatchInternalHeadersSchema,
+	body: Type.Object({
+		event: WebhookEventTypeSchema,
+		provider: LSPServiceContextSchema,
+		data: Type.Any({ description: 'Event payload — shape varies by event type' }),
+		timestamp: Type.Number({ description: 'Event timestamp (Unix ms)' }),
+		idempotencyKey: Type.Optional(Type.String({ description: 'Prevents duplicate dispatch' }))
+	}),
+	response: Type.Intersect([
+		APIResponseBaseSchema,
+		APIResponseDataSchemaFactory({
+			dispatched: Type.Number({ description: 'Number of webhooks notified' }),
+			failed: Type.Number(),
+			deliveryIds: Type.Array(Type.String())
+		})
+	])
+}
+export type CSPWebhookDispatchValidation = {
+	body: Static<typeof CSPWebhookDispatchRVS.body>
+	response: Static<typeof CSPWebhookDispatchRVS.response>
+}

package/src/de.profile.ts

@@ -0,0 +1,123 @@
+import { Type, Static } from '@sinclair/typebox'
+import {
+	APIErrorSchema,
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory,
+	FetchByQueryRequestSchema
+} from './api'
+import { ActionRecordSchema, DateTimeRangeSchema, DateTimeZoneSchema } from './time'
+import { AddressSchema, ContactsSchema } from './geo'
+import { ContextSchema } from './context'
+
+export const DProfileTypeSchema = Type.Union([
+  Type.Literal('CUSTOMER'),
+  Type.Literal('STORE'),
+  Type.Literal('EXT_WAREHOUSE')
+])
+
+export const DProfilePreferencesSchema = Type.Object({
+  preferredTimeWindow: Type.Optional(DateTimeRangeSchema),
+  instructions: Type.Optional(Type.String({ maxLength: 500 })),
+  accessCodes: Type.Optional(Type.String({ maxLength: 200 })),
+  requiresSignature: Type.Optional(Type.Boolean()),
+  leaveAtDoor: Type.Optional(Type.Boolean()),
+  notifications: Type.Optional(Type.Object({
+    sms: Type.Boolean(),
+    email: Type.Boolean(),
+    push: Type.Boolean()
+  }))
+})
+
+export const DProfileSchema = Type.Object({
+  id: Type.String(),
+  context: ContextSchema,
+  type: DProfileTypeSchema,
+  reference: Type.String({ description: 'External reference scoped to context' }),
+  label: Type.String({ minLength: 1, maxLength: 200, description: 'Display name (e.g., "Home", "Warehouse A")' }),
+  address: AddressSchema,
+  contact: Type.Optional(ContactsSchema),
+  preferences: Type.Optional(DProfilePreferencesSchema),
+  created: ActionRecordSchema
+})
+
+export const DProfileReferenceSchema = Type.Object({
+  id: Type.Optional(Type.String()),
+  reference: Type.Optional(Type.String()),
+  type: DProfileTypeSchema
+})
+
+export const CreateDProfileSchema = Type.Object({
+  reference: Type.String({ minLength: 1, maxLength: 100 }),
+  type: DProfileTypeSchema,
+  label: Type.String({ minLength: 1, maxLength: 200 }),
+  address: AddressSchema,
+  contact: Type.Optional(ContactsSchema),
+  preferences: Type.Optional(DProfilePreferencesSchema)
+})
+
+export type DProfileType        = Static<typeof DProfileTypeSchema>
+export type DProfilePreferences = Static<typeof DProfilePreferencesSchema>
+export type DProfile            = Static<typeof DProfileSchema>
+export type DProfileReference   = Static<typeof DProfileReferenceSchema>
+export type CreateDProfile      = Static<typeof CreateDProfileSchema>
+
+// ─── Request Validation Schemas ───────────────────────────────────────────────
+
+export const DProfileCreateRVS = {
+	headers:  APIHeadersSchema,
+	body:     CreateDProfileSchema,
+	response: {
+		201:   APIResponseDataSchemaFactory({ profileId: Type.String(), reference: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const DProfileFetchRVS = {
+	headers:     APIHeadersSchema,
+	querystring: Type.Composite([
+		FetchByQueryRequestSchema,
+		Type.Object({
+			type:      Type.Optional(Type.String()),
+			reference: Type.Optional(Type.String())
+		})
+	]),
+	response: {
+		200:   APIResponseDataSchemaFactory({ profiles: Type.Array(DProfileSchema), total: Type.Number(), page: Type.Number(), limit: Type.Number() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const DProfileRetrieveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ profile: DProfileSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const DProfileUpdateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     Type.Partial(Type.Omit(DProfileSchema, ['id', 'context', 'created'])),
+	response: {
+		200:   APIResponseDataSchemaFactory({ profile: DProfileSchema }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export const DProfileRemoveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: {
+		200:   APIResponseDataSchemaFactory({ profileId: Type.String() }),
+		'4XX': APIErrorSchema
+	}
+}
+
+export type DProfileCreateValidation   = { body: Static<typeof DProfileCreateRVS.body>, response: Static<(typeof DProfileCreateRVS.response)[201]> }
+export type DProfileFetchValidation    = { querystring: Static<typeof DProfileFetchRVS.querystring>, response: Static<(typeof DProfileFetchRVS.response)[200]> }
+export type DProfileRetrieveValidation = { params: Static<typeof DProfileRetrieveRVS.params>, response: Static<(typeof DProfileRetrieveRVS.response)[200]> }
+export type DProfileUpdateValidation   = { params: Static<typeof DProfileUpdateRVS.params>, body: Static<typeof DProfileUpdateRVS.body>, response: Static<(typeof DProfileUpdateRVS.response)[200]> }
+export type DProfileRemoveValidation   = { params: Static<typeof DProfileRemoveRVS.params>, response: Static<(typeof DProfileRemoveRVS.response)[200]> }

package/src/dev/developer.ts

@@ -0,0 +1,90 @@
+import { Type, Static } from '@sinclair/typebox'
+import {
+	APIErrorSchema,
+	APIHeadersSchema,
+	APIResponseBaseSchema,
+	APIResponseDataSchemaFactory
+} from '../api'
+import { ContextSchema } from '../context'
+import { ActionRecordSchema } from '../time'
+import { ContactsSchema, AddressSchema } from '../geo'
+
+// Developer Status Schema
+export const DeveloperStatusSchema = Type.Union([
+  Type.Literal('ACTIVE'),
+  Type.Literal('INACTIVE'),
+  Type.Literal('SUSPENDED')
+])
+
+export const DeveloperRoleSchema = Type.Union([
+  Type.Literal('MAINTAINER'),
+  Type.Literal('DEVELOPER'),
+  Type.Literal('TESTER')
+])
+
+// Developer Schema
+export const DeveloperSchema = Type.Object({
+  id: Type.String(),
+  context: ContextSchema,
+  bio: Type.Optional(Type.String({ maxLength: 500 })),
+  contacts: ContactsSchema,
+  address: Type.Optional(AddressSchema),
+  role: DeveloperRoleSchema,
+  // permissions: Type.Array(PermissionSchema), // Uncomment when Permission type is available
+  status: DeveloperStatusSchema,
+  added: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+})
+export const DeveloperUpdateSchema = Type.Partial( Type.Omit( DeveloperSchema, ['id', 'context', 'role', 'added', 'updated']) )
+
+// Generate TypeScript types from schemas
+export type DeveloperStatus = Static<typeof DeveloperStatusSchema>
+export type Developer       = Static<typeof DeveloperSchema>
+export type DeveloperUpdate = Static<typeof DeveloperUpdateSchema>
+
+// ─── Request Validation Schemas ───────────────────────────────────────────────
+
+export const DEVDeveloperRetrieveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseDataSchemaFactory({ developer: DeveloperSchema })
+}
+
+export const DEVDeveloperFetchRVS = {
+	headers:  APIHeadersSchema,
+	response: APIResponseDataSchemaFactory({ developers: Type.Array(DeveloperSchema) })
+}
+
+export const DEVDeveloperUpdateRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	body:     DeveloperUpdateSchema,
+	response: APIResponseDataSchemaFactory({ developer: DeveloperSchema })
+}
+
+export const DEVDeveloperRemoveRVS = {
+	headers:  APIHeadersSchema,
+	params:   Type.Object({ id: Type.String() }),
+	response: APIResponseBaseSchema
+}
+
+export type DEVDeveloperRetrieveValidation = {
+	headers:  Static<typeof DEVDeveloperRetrieveRVS.headers>,
+	params:   Static<typeof DEVDeveloperRetrieveRVS.params>,
+	response: Static<typeof DEVDeveloperRetrieveRVS.response>
+}
+export type DEVDeveloperFetchValidation = {
+	headers:  Static<typeof DEVDeveloperFetchRVS.headers>,
+	response: Static<typeof DEVDeveloperFetchRVS.response>
+}
+export type DEVDeveloperUpdateValidation = {
+	headers:  Static<typeof DEVDeveloperUpdateRVS.headers>,
+	params:   Static<typeof DEVDeveloperUpdateRVS.params>,
+	body:     Static<typeof DEVDeveloperUpdateRVS.body>,
+	response: Static<typeof DEVDeveloperUpdateRVS.response>
+}
+export type DEVDeveloperRemoveValidation = {
+	headers:  Static<typeof DEVDeveloperRemoveRVS.headers>,
+	params:   Static<typeof DEVDeveloperRemoveRVS.params>,
+	response: Static<typeof DEVDeveloperRemoveRVS.response>
+}

package/src/dev/index.ts

@@ -0,0 +1,81 @@
+import { Type, Static } from '@sinclair/typebox'
+import {
+  SPProfileSchema,
+  SPProfileUpdateSchema
+} from '../context'
+
+export const DEVTypeSchema = Type.Union([
+  Type.Literal('CONSULTANCY'),
+  Type.Literal('ENTERPRISE'),
+  Type.Literal('FREELANCE')
+])
+
+export const DEVOperatorRoleSchema = Type.Union([
+  Type.Literal('ADMIN'),
+  Type.Literal('READONLY'),
+  Type.Literal('MANAGER'),
+  Type.Literal('SUPERVISOR'),
+  Type.Literal('AUDITOR')
+])
+
+// LSP Schema
+export const DEVSchema = Type.Composite([
+  SPProfileSchema,
+  Type.Object({
+    type: DEVTypeSchema
+  })
+])
+export const DEVUpdateSchema = Type.Composite([
+  SPProfileUpdateSchema,
+  Type.Object({
+    type: Type.Optional(DEVTypeSchema)
+  })
+])
+
+// Service Provider Schema
+export const DEVServiceContextSchema = Type.Object({
+  providerType: DEVTypeSchema,
+  type: Type.Union([
+    // ...CarrierTypeSchema.anyOf,
+    // ...HubTypeSchema.anyOf,
+    // ...WarehouseTypeSchema.anyOf,
+    // ...TerminalTypeSchema.anyOf
+  ]),
+  id: Type.String(),
+  description: Type.Optional(Type.String({ minLength: 10, maxLength: 250 }))
+})
+
+// Generate TypeScript type from schema
+export type DEV = Static<typeof DEVSchema>
+export type DEVType = Static<typeof DEVTypeSchema>
+export type DEVUpdate = Static<typeof DEVUpdateSchema>
+export type DEVServiceContext = Static<typeof DEVServiceContextSchema>
+export type DEVOperatorRole = Static<typeof DEVOperatorRoleSchema>
+
+// Additional utility schemas for DEV management
+export const DEVQuerySchema = Type.Object({
+  name: Type.Optional(Type.String()),
+  companyId: Type.Optional(Type.String()),
+  hasWebsite: Type.Optional(Type.Boolean()),
+  hasContacts: Type.Optional(Type.Boolean()),
+  createdAfter: Type.Optional(Type.Number({ description: 'Timestamp' })),
+  createdBefore: Type.Optional(Type.Number({ description: 'Timestamp' })),
+  limit: Type.Optional(Type.Number({ minimum: 1, maximum: 100 })),
+  offset: Type.Optional(Type.Number({ minimum: 0 }))
+})
+
+export const DEVStatsSchema = Type.Object({
+  total: Type.Number({ minimum: 0 }),
+  withWebsite: Type.Number({ minimum: 0 }),
+  withContacts: Type.Number({ minimum: 0 }),
+  withCompany: Type.Number({ minimum: 0 }),
+  byCountry: Type.Optional(Type.Record(Type.String(), Type.Number({ minimum: 0 }))),
+  recentlyAdded: Type.Number({ minimum: 0, description: 'Added in last 30 days' }),
+  lastActivity: Type.Optional(Type.Number({ description: 'Last update timestamp' }))
+})
+
+export type DEVQuery = Static<typeof DEVQuerySchema>
+export type DEVStats = Static<typeof DEVStatsSchema>
+
+// Developer domain (entity schemas + request validation)
+export * from './developer'