@de./types 1.0.0

package/src/iotsp/topic.ts

@@ -0,0 +1,191 @@
+import { Type, Static } from '@sinclair/typebox'
+import { ActionRecordSchema } from '../time'
+import { ContextSchema } from '../context'
+import { APIResponseBaseSchema, APIResponseDataSchemaFactory, FetchByQueryRequestSchema } from '../api'
+import { ConnectorSchema } from '../workspace/connector'
+
+// Topic Schema
+export const IoTTopicSchema = Type.Object({
+  reference: Type.String({ 
+    minLength: 1,
+    maxLength: 100,
+    description: 'Topic reference identifier'
+  }),
+  context: ContextSchema,
+  path: Type.String({
+    minLength: 1,
+    description: 'MQTT topic path'
+  }),
+  qos: Type.Number({ 
+    minimum: 0, 
+    maximum: 2,
+    description: 'MQTT Quality of Service level (0, 1, or 2)'
+  }),
+  ack: Type.Optional(Type.Boolean()),
+  description: Type.String({ maxLength: 500 }),
+  connectors: Type.Array(Type.String(), {
+    description: 'List of connector IDs'
+  }),
+  tags: Type.Optional(Type.Array(Type.String())),
+  tested: Type.Boolean(),
+  enabled: Type.Boolean(),
+  registered: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+}, { additionalProperties: false })
+
+const OMIT_FIELD = [
+  'reference',
+  'context',
+  'connectors',
+  'ack',
+  'enabled',
+  'tested',
+  'registered',
+  'updated'
+]
+export const IoTTopicAddSchema = Type.Omit(IoTTopicSchema, OMIT_FIELD)
+export const IoTTopicUpdateSchema = Type.Partial(IoTTopicAddSchema)
+
+// Generate TypeScript types from schemas
+export type IoTTopic = Static<typeof IoTTopicSchema>
+export type IoTTopicAdd = Static<typeof IoTTopicAddSchema>
+export type IoTTopicUpdate = Static<typeof IoTTopicUpdateSchema>
+
+
+// ============================================================================
+// REQUEST VALIDATION SCHEMAS
+// ============================================================================
+// The sufix `RVS` stands for `Request Validation Schema` to keep it short
+
+export const IoTTopicRegisterRVS = {
+  body: IoTTopicAddSchema,
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      reference: Type.String()
+    })
+  ])
+}
+export type IoTTopicRegisterValidation = {
+  body: Static<typeof IoTTopicRegisterRVS.body>
+  response: Static<typeof IoTTopicRegisterRVS.response>
+}
+
+export const IoTTopicUpdateRVS = {
+  params: Type.Object({ reference: Type.String() }),
+  body: IoTTopicUpdateSchema,
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      topic: IoTTopicSchema
+    })
+  ])
+}
+export type IoTTopicUpdateValidation = {
+  params: Static<typeof IoTTopicUpdateRVS.params>
+  body: Static<typeof IoTTopicUpdateRVS.body>
+  response: Static<typeof IoTTopicUpdateRVS.response>
+}
+
+export const IoTTopicRetrieveRVS = {
+  params: Type.Object({ reference: Type.String() }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      topic: IoTTopicSchema
+    })
+  ])
+}
+export type IoTTopicRetrieveValidation = {
+  params: Static<typeof IoTTopicRetrieveRVS.params>
+  response: Static<typeof IoTTopicRetrieveRVS.response>
+}
+
+export const IoTTopicStatusRVS = {
+  params: Type.Object({
+    reference: Type.String(),
+    status: Type.String()
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      topic: IoTTopicSchema
+    })
+  ])
+}
+export type IoTTopicStatusValidation = {
+  params: Static<typeof IoTTopicStatusRVS.params>
+  response: Static<typeof IoTTopicStatusRVS.response>
+}
+
+export const IoTTopicListRVS = {
+  querystring: FetchByQueryRequestSchema,
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      topics: Type.Array(IoTTopicSchema)
+    })
+  ])
+}
+export type IoTTopicListValidation = {
+  querystring: Static<typeof IoTTopicListRVS.querystring>
+  response: Static<typeof IoTTopicListRVS.response>
+}
+
+export const IoTTopicFindRVS = {
+  querystring: Type.Intersect([
+    FetchByQueryRequestSchema,
+    Type.Object({
+      query: Type.String()
+    })
+  ]),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      topics: Type.Array(IoTTopicSchema)
+    })
+  ])
+}
+export type IoTTopicFindValidation = {
+  querystring: Static<typeof IoTTopicFindRVS.querystring>
+  response: Static<typeof IoTTopicFindRVS.response>
+}
+
+export const IoTTopicUnregisterRVS = {
+  params: Type.Object({ reference: Type.String() }),
+  response: APIResponseBaseSchema
+}
+export type IoTTopicUnregisterValidation = {
+  params: Static<typeof IoTTopicUnregisterRVS.params>
+  response: Static<typeof IoTTopicUnregisterRVS.response>
+}
+
+export const IoTTopicConnectorsRVS = {
+  params: Type.Object({ reference: Type.String() }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      connectors: Type.Array(ConnectorSchema)
+    })
+  ])
+}
+export type IoTTopicConnectorsValidation = {
+  params: Static<typeof IoTTopicConnectorsRVS.params>
+  response: Static<typeof IoTTopicConnectorsRVS.response>
+}
+
+export const IoTTopicXssignConnectorRVS = {
+  params: Type.Object({ reference: Type.String() }),
+  body: Type.Object({ cid: Type.String() }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      topic: IoTTopicSchema
+    })
+  ])
+}
+export type IoTTopicXssignConnectorValidation = {
+  params: Static<typeof IoTTopicXssignConnectorRVS.params>
+  body: Static<typeof IoTTopicXssignConnectorRVS.body>
+  response: Static<typeof IoTTopicXssignConnectorRVS.response>
+}

package/src/lsp/carrier/analytics.ts

@@ -0,0 +1,393 @@
+import { Type, Static } from '@sinclair/typebox'
+import { DurationSchema } from '../../time'
+import { MoneySchema, DistanceSchema, ServiceLevelSchema, WeightSchema, PerTimeSchema } from '../../measure'
+import { EntityStatusSchema } from '../../entity'
+import { CarrierCapacitySchema } from './capacities'
+import { CoverageTransitModeSchema } from '../coverage'
+import { CarrierCapabilitySchema } from './capabilities'
+import { CarrierTypeSchema } from '.'
+
+// Route and network analysis
+export const CarrierRouteAnalysisSchema = Type.Object({
+  routeOptimization: Type.Object({
+    currentRoutes: Type.Array(Type.Object({
+      routeId: Type.String(),
+      origin: Type.String(),
+      destination: Type.String(),
+      stops: Type.Number({ minimum: 0 }),
+      distance: DistanceSchema,
+      duration: DurationSchema,
+      capacity: WeightSchema,
+      utilization: Type.Number({ minimum: 0, maximum: 100 }),
+      efficiency: Type.Number({ minimum: 0, maximum: 100 }),
+      cost: MoneySchema,
+      frequency: PerTimeSchema
+    })),
+    
+    optimizationOpportunities: Type.Array(Type.Object({
+      routeId: Type.String(),
+      optimizationType: Type.Union([
+        Type.Literal('DISTANCE_OPTIMIZATION'),
+        Type.Literal('TIME_OPTIMIZATION'),
+        Type.Literal('COST_OPTIMIZATION'),
+        Type.Literal('CAPACITY_OPTIMIZATION'),
+        Type.Literal('STOP_CONSOLIDATION'),
+        Type.Literal('BACKHAUL_OPTIMIZATION'),
+        Type.Literal('CROSS_DOCK_OPTIMIZATION')
+      ]),
+      currentMetric: Type.Number(),
+      optimizedMetric: Type.Number(),
+      improvement: Type.Number({ description: 'percentage' }),
+      implementationCost: MoneySchema,
+      savingsPerMonth: MoneySchema,
+      paybackPeriod: DurationSchema
+    })),
+    
+    networkEfficiency: Type.Object({
+      totalDistance: DistanceSchema,
+      emptyMiles: DistanceSchema,
+      loadedMiles: DistanceSchema,
+      emptyMileRatio: Type.Number({ minimum: 0, maximum: 100 }),
+      networkDensity: Type.Number({ minimum: 0 }),
+      routeOverlap: Type.Number({ minimum: 0, maximum: 100 }),
+      hubConnectivity: Type.Number({ minimum: 0, maximum: 100 })
+    })
+  }),
+  
+  demandPatterns: Type.Object({
+    historicalDemand: Type.Array(Type.Object({
+      period: Type.String(),
+      volume: Type.Number({ minimum: 0 }),
+      revenue: MoneySchema,
+      serviceArea: Type.String(),
+      seasonalFactor: Type.Number({ minimum: 0 }),
+      growthRate: Type.Number({ description: 'percentage' })
+    })),
+    
+    forecastedDemand: Type.Array(Type.Object({
+      period: Type.String(),
+      forecastedVolume: Type.Number({ minimum: 0 }),
+      forecastedRevenue: MoneySchema,
+      confidenceLevel: Type.Number({ minimum: 0, maximum: 100 }),
+      serviceArea: Type.String(),
+      assumptions: Type.Array(Type.String())
+    })),
+    
+    seasonalTrends: Type.Array(Type.Object({
+      season: Type.String(),
+      volumeMultiplier: Type.Number({ minimum: 0 }),
+      priceMultiplier: Type.Number({ minimum: 0 }),
+      durationWeeks: Type.Number({ minimum: 0 }),
+      resourceRequirements: Type.String(),
+      specialConsiderations: Type.Array(Type.String())
+    })),
+    
+    marketSegments: Type.Array(Type.Object({
+      segment: Type.String(),
+      volume: Type.Number({ minimum: 0 }),
+      revenue: MoneySchema,
+      profitability: Type.Number({ minimum: 0, maximum: 100 }),
+      growth: Type.Number({ description: 'percentage' }),
+      competitiveness: Type.Number({ minimum: 0, maximum: 100 })
+    }))
+  })
+})
+
+// Fleet and resource optimization analysis
+export const CarrierFleetAnalysisSchema = Type.Object({
+  fleetOptimization: Type.Object({
+    fleetComposition: Type.Array(Type.Object({
+      vehicleType: Type.String(),
+      currentCount: Type.Number({ minimum: 0 }),
+      optimalCount: Type.Number({ minimum: 0 }),
+      utilization: Type.Number({ minimum: 0, maximum: 100 }),
+      efficiency: Type.Number({ minimum: 0, maximum: 100 }),
+      cost: MoneySchema,
+      recommendation: Type.String()
+    })),
+    
+    rightsizing: Type.Object({
+      oversizedAssets: Type.Number({ minimum: 0 }),
+      undersizedAssets: Type.Number({ minimum: 0 }),
+      rightSizedAssets: Type.Number({ minimum: 0 }),
+      optimizationPotential: Type.Number({ minimum: 0, maximum: 100 }),
+      costSavings: MoneySchema,
+      efficiencyGain: Type.Number({ minimum: 0, maximum: 100 })
+    }),
+    
+    replacementSchedule: Type.Array(Type.Object({
+      vehicleId: Type.String(),
+      vehicleType: Type.String(),
+      currentAge: Type.Number({ minimum: 0 }),
+      recommendedReplacementDate: Type.Number(),
+      replacementCost: MoneySchema,
+      expectedSavings: MoneySchema,
+      downtime: DurationSchema
+    })),
+    
+    acquisitionPlan: Type.Array(Type.Object({
+      vehicleType: Type.String(),
+      quantity: Type.Number({ minimum: 0 }),
+      acquisitionMethod: Type.Union([
+        Type.Literal('PURCHASE'),
+        Type.Literal('LEASE'),
+        Type.Literal('RENT'),
+        Type.Literal('CONTRACT')
+      ]),
+      cost: MoneySchema,
+      timeline: DurationSchema,
+      businessCase: Type.String()
+    }))
+  }),
+  
+  maintenanceOptimization: Type.Object({
+    maintenanceCosts: MoneySchema,
+    downtimeHours: Type.Number({ minimum: 0 }),
+    preventiveRatio: Type.Number({ minimum: 0, maximum: 100 }),
+    reactiveRatio: Type.Number({ minimum: 0, maximum: 100 }),
+    
+    optimizationOpportunities: Type.Array(Type.Object({
+      opportunity: Type.String(),
+      description: Type.String(),
+      potentialSavings: MoneySchema,
+      implementationCost: MoneySchema,
+      downtimeReduction: Type.Number({ minimum: 0 }),
+      reliabilityImprovement: Type.Number({ minimum: 0, maximum: 100 })
+    })),
+    
+    predictiveMaintenance: Type.Object({
+      available: Type.Boolean(),
+      penetration: Type.Number({ minimum: 0, maximum: 100 }),
+      accuracy: Type.Number({ minimum: 0, maximum: 100 }),
+      costSavings: MoneySchema,
+      downtimeReduction: Type.Number({ minimum: 0, maximum: 100 })
+    })
+  }),
+  
+  driverOptimization: Type.Object({
+    driverUtilization: Type.Number({ minimum: 0, maximum: 100 }),
+    overtimeRatio: Type.Number({ minimum: 0, maximum: 100 }),
+    turnoverRate: Type.Number({ minimum: 0, maximum: 100 }),
+    trainingCosts: MoneySchema,
+    recruitmentCosts: MoneySchema,
+    
+    optimizationAreas: Type.Array(Type.Object({
+      area: Type.String(),
+      currentPerformance: Type.Number(),
+      targetPerformance: Type.Number(),
+      improvement: Type.Number({ description: 'percentage' }),
+      actions: Type.Array(Type.String()),
+      investment: MoneySchema,
+      timeline: DurationSchema
+    })),
+    
+    safetyProgram: Type.Object({
+      accidentRate: Type.Number({ minimum: 0 }),
+      safetyScore: Type.Number({ minimum: 0, maximum: 100 }),
+      trainingEffectiveness: Type.Number({ minimum: 0, maximum: 100 }),
+      complianceLevel: Type.Number({ minimum: 0, maximum: 100 }),
+      insuranceImpact: MoneySchema
+    })
+  })
+})
+
+// Market and competitive analysis
+export const CarrierMarketAnalysisSchema = Type.Object({
+  marketPosition: Type.Object({
+    marketShare: Type.Number({ minimum: 0, maximum: 100, description: 'percentage' }),
+    rankingInMarket: Type.Number({ minimum: 1 }),
+    competitiveAdvantages: Type.Array(Type.String()),
+    competitiveDisadvantages: Type.Array(Type.String()),
+    differentiators: Type.Array(Type.String()),
+    
+    swotAnalysis: Type.Object({
+      strengths: Type.Array(Type.String()),
+      weaknesses: Type.Array(Type.String()),
+      opportunities: Type.Array(Type.String()),
+      threats: Type.Array(Type.String())
+    })
+  }),
+  
+  competitorAnalysis: Type.Array(Type.Object({
+    competitorName: Type.String(),
+    marketShare: Type.Number({ minimum: 0, maximum: 100 }),
+    serviceOfferings: Type.Array(Type.String()),
+    pricing: Type.Object({
+      competitive: Type.Boolean(),
+      pricePoint: Type.Union([
+        Type.Literal('PREMIUM'),
+        Type.Literal('MARKET'),
+        Type.Literal('DISCOUNT')
+      ]),
+      valueProposition: Type.String()
+    }),
+    strengths: Type.Array(Type.String()),
+    weaknesses: Type.Array(Type.String()),
+    threatLevel: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH'),
+      Type.Literal('CRITICAL')
+    ])
+  })),
+  
+  marketTrends: Type.Array(Type.Object({
+    trend: Type.String(),
+    impact: Type.Union([
+      Type.Literal('POSITIVE'),
+      Type.Literal('NEGATIVE'),
+      Type.Literal('NEUTRAL')
+    ]),
+    timeframe: Type.Union([
+      Type.Literal('SHORT_TERM'),
+      Type.Literal('MEDIUM_TERM'),
+      Type.Literal('LONG_TERM')
+    ]),
+    probability: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH')
+    ]),
+    strategicResponse: Type.String(),
+    investmentRequired: Type.Optional(MoneySchema)
+  })),
+  
+  customerAnalysis: Type.Object({
+    customerSegments: Type.Array(Type.Object({
+      segment: Type.String(),
+      size: Type.Number({ minimum: 0 }),
+      revenue: MoneySchema,
+      profitability: Type.Number({ minimum: 0, maximum: 100 }),
+      retention: Type.Number({ minimum: 0, maximum: 100 }),
+      satisfaction: Type.Number({ minimum: 0, maximum: 100 }),
+      growthPotential: Type.Union([
+        Type.Literal('LOW'),
+        Type.Literal('MEDIUM'),
+        Type.Literal('HIGH')
+      ])
+    })),
+    
+    customerNeeds: Type.Array(Type.Object({
+      need: Type.String(),
+      importance: Type.Union([
+        Type.Literal('LOW'),
+        Type.Literal('MEDIUM'),
+        Type.Literal('HIGH'),
+        Type.Literal('CRITICAL')
+      ]),
+      currentSatisfaction: Type.Number({ minimum: 0, maximum: 100 }),
+      gapAnalysis: Type.String(),
+      improvementOpportunity: Type.String()
+    }))
+  })
+})
+
+// Strategic recommendations
+export const CarrierStrategicRecommendationsSchema = Type.Array(Type.Object({
+  recommendationId: Type.String(),
+  category: Type.Union([
+    Type.Literal('OPERATIONAL_EXCELLENCE'),
+    Type.Literal('SERVICE_ENHANCEMENT'),
+    Type.Literal('TECHNOLOGY_INVESTMENT'),
+    Type.Literal('FLEET_OPTIMIZATION'),
+    Type.Literal('NETWORK_EXPANSION'),
+    Type.Literal('MARKET_DEVELOPMENT'),
+    Type.Literal('COST_REDUCTION'),
+    Type.Literal('REVENUE_GROWTH'),
+    Type.Literal('COMPETITIVE_POSITIONING'),
+    Type.Literal('SUSTAINABILITY'),
+    Type.Literal('RISK_MANAGEMENT')
+  ]),
+  priority: Type.Union([
+    Type.Literal('LOW'),
+    Type.Literal('MEDIUM'),
+    Type.Literal('HIGH'),
+    Type.Literal('CRITICAL')
+  ]),
+  title: Type.String(),
+  description: Type.String(),
+  businessCase: Type.String(),
+  expectedBenefits: Type.Array(Type.String()),
+  
+  implementation: Type.Object({
+    timeline: DurationSchema,
+    phases: Type.Array(Type.Object({
+      phase: Type.String(),
+      duration: DurationSchema,
+      activities: Type.Array(Type.String()),
+      deliverables: Type.Array(Type.String()),
+      resources: Type.Array(Type.String())
+    })),
+    totalCost: MoneySchema,
+    resourceRequirements: Type.Object({
+      budget: MoneySchema,
+      personnel: Type.Number({ minimum: 0 }),
+      equipment: Type.Array(Type.String()),
+      technology: Type.Array(Type.String()),
+      facilities: Type.Array(Type.String())
+    })
+  }),
+  
+  expectedOutcomes: Type.Object({
+    quantifiableBenefits: Type.Record(Type.String(), Type.Union([
+      Type.Number(),
+      MoneySchema,
+      Type.String()
+    ])),
+    qualitativeBenefits: Type.Array(Type.String()),
+    roi: Type.Number({ description: 'percentage' }),
+    paybackPeriod: DurationSchema,
+    riskLevel: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH')
+    ])
+  }),
+  
+  dependencies: Type.Array(Type.String()),
+  risks: Type.Array(Type.Object({
+    risk: Type.String(),
+    probability: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH')
+    ]),
+    impact: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH')
+    ]),
+    mitigation: Type.String()
+  })),
+  
+  successMetrics: Type.Array(Type.Object({
+    metric: Type.String(),
+    baseline: Type.Number(),
+    target: Type.Number(),
+    timeline: DurationSchema,
+    measurementMethod: Type.String()
+  }))
+}))
+
+// Combined carrier analytics
+export const CarrierAnalyticsSchema = Type.Object({
+  carrierId: Type.String(),
+  analysisDate: Type.Number(),
+  analysisPeriod: Type.Object({
+    start: Type.Number(),
+    end: Type.Number()
+  }),
+  
+  routeAnalysis: CarrierRouteAnalysisSchema,
+  fleetAnalysis: CarrierFleetAnalysisSchema,
+  marketAnalysis: CarrierMarketAnalysisSchema,
+  recommendations: CarrierStrategicRecommendationsSchema
+})
+
+
+// Carrier Analytics Types
+export type CarrierRouteAnalysis = Static<typeof CarrierRouteAnalysisSchema>
+export type CarrierFleetAnalysis = Static<typeof CarrierFleetAnalysisSchema>
+export type CarrierMarketAnalysis = Static<typeof CarrierMarketAnalysisSchema>
+export type CarrierStrategicRecommendations = Static<typeof CarrierStrategicRecommendationsSchema>
+export type CarrierAnalytics = Static<typeof CarrierAnalyticsSchema>