@de./types 1.0.0

package/src/iotsp/device.ts

@@ -0,0 +1,334 @@
+import { Type, Static } from '@sinclair/typebox'
+import { ActionRecordSchema } from '../time'
+import { ContextSchema } from '../context'
+import { APIResponseBaseSchema, APIResponseDataSchemaFactory, FetchByQueryRequestSchema } from '../api'
+
+// Device Specs Schema (expandable structure)
+export const IoTDeviceSpecsSchema = Type.Object({
+  manufacturer: Type.Optional(Type.String({ maxLength: 100 })),
+  model: Type.Optional(Type.String({ maxLength: 100 })),
+  firmwareVersion: Type.Optional(Type.String({ maxLength: 50 })),
+  hardwareVersion: Type.Optional(Type.String({ maxLength: 50 })),
+  serialNumber: Type.Optional(Type.String({ maxLength: 100 })),
+  capabilities: Type.Optional(Type.Array(Type.String())),
+  sensors: Type.Optional(Type.Array(Type.Object({
+    type: Type.String(),
+    model: Type.Optional(Type.String()),
+    accuracy: Type.Optional(Type.String()),
+    range: Type.Optional(Type.String())
+  }))),
+  connectivity: Type.Optional(Type.Object({
+    protocols: Type.Optional(Type.Array(Type.String())),
+    networkTypes: Type.Optional(Type.Array(Type.String())),
+    maxConnections: Type.Optional(Type.Number({ minimum: 1 }))
+  })),
+  power: Type.Optional(Type.Object({
+    type: Type.Optional(Type.Union([
+      Type.Literal('BATTERY'),
+      Type.Literal('WIRED'),
+      Type.Literal('SOLAR'),
+      Type.Literal('HYBRID')
+    ])),
+    voltage: Type.Optional(Type.Number({ minimum: 0 })),
+    capacity: Type.Optional(Type.Number({ minimum: 0, description: 'mAh for batteries' }))
+  })),
+  physical: Type.Optional(Type.Object({
+    weight: Type.Optional(Type.Number({ minimum: 0, description: 'grams' })),
+    dimensions: Type.Optional(Type.Object({
+      length: Type.Number({ minimum: 0 }),
+      width: Type.Number({ minimum: 0 }),
+      height: Type.Number({ minimum: 0 }),
+      unit: Type.Union([Type.Literal('mm'), Type.Literal('cm')])
+    })),
+    operatingTemperature: Type.Optional(Type.Object({
+      min: Type.Number(),
+      max: Type.Number(),
+      unit: Type.Union([Type.Literal('C'), Type.Literal('F')])
+    })),
+    ipRating: Type.Optional(Type.String({ description: 'IP protection rating (e.g., IP67)' }))
+  }))
+}, { 
+  additionalProperties: true,
+  description: 'Device specifications - extensible structure'
+})
+
+// Device State Schema (expandable structure)
+export const IoTDeviceStateSchema = Type.Object({
+  online: Type.Optional(Type.Boolean()),
+  lastSeen: Type.Optional(Type.Number({ description: 'Last communication timestamp' })),
+  batteryLevel: Type.Optional(Type.Number({ 
+    minimum: 0, 
+    maximum: 100,
+    description: 'Battery percentage'
+  })),
+  signalStrength: Type.Optional(Type.Number({ 
+    minimum: -150, 
+    maximum: 0,
+    description: 'Signal strength in dBm'
+  })),
+  location: Type.Optional(Type.Object({
+    latitude: Type.Number(),
+    longitude: Type.Number(),
+    altitude: Type.Optional(Type.Number()),
+    accuracy: Type.Optional(Type.Number()),
+    timestamp: Type.Optional(Type.Number())
+  })),
+  temperature: Type.Optional(Type.Number()),
+  errors: Type.Optional(Type.Array(Type.Object({
+    code: Type.String(),
+    message: Type.String(),
+    timestamp: Type.Number(),
+    severity: Type.Union([
+      Type.Literal('LOW'),
+      Type.Literal('MEDIUM'),
+      Type.Literal('HIGH'),
+      Type.Literal('CRITICAL')
+    ])
+  }))),
+  diagnostics: Type.Optional(Type.Object({
+    uptime: Type.Optional(Type.Number({ description: 'Device uptime in seconds' })),
+    memoryUsage: Type.Optional(Type.Number({ minimum: 0, maximum: 100 })),
+    cpuUsage: Type.Optional(Type.Number({ minimum: 0, maximum: 100 })),
+    networkLatency: Type.Optional(Type.Number({ minimum: 0, description: 'ms' }))
+  })),
+  customState: Type.Optional(Type.Record(Type.String(), Type.Any()))
+}, { 
+  additionalProperties: true,
+  description: 'Device state - extensible structure'
+})
+
+// Device Schema
+export const IoTDeviceSchema = Type.Object({
+  id: Type.String(),
+  context: ContextSchema,
+  commands: Type.Record(Type.String(), Type.String(), {
+    description: 'Assigned commands rule id mapping'
+  }),
+  specs: IoTDeviceSpecsSchema,
+  state: IoTDeviceStateSchema,
+  tags: Type.Optional(Type.Array(Type.String())),
+  tested: Type.Boolean(),
+  enabled: Type.Boolean(),
+  added: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+}, { additionalProperties: false })
+
+export const IoTDeviceAddSchema = Type.Omit( IoTDeviceSchema, [
+  'context',
+  'commands', 'state',
+  'tested', 'enabled',
+  'added', 'updated'
+])
+export const IoTDeviceUpdateSchema = Type.Partial(IoTDeviceAddSchema)
+
+
+// Generate TypeScript types from schemas
+export type IoTDeviceSpecs = Static<typeof IoTDeviceSpecsSchema>
+export type IoTDeviceState = Static<typeof IoTDeviceStateSchema>
+export type IoTDevice = Static<typeof IoTDeviceSchema>
+export type IoTDeviceAdd = Static<typeof IoTDeviceAddSchema>
+export type IoTDeviceUpdate = Static<typeof IoTDeviceUpdateSchema>
+
+
+// Additional utility schemas for IoT management
+export const IoTDeviceCommandStatusSchema = Type.Union([
+  Type.Literal('PENDING'),
+  Type.Literal('SENT'),
+  Type.Literal('ACKNOWLEDGED'),
+  Type.Literal('EXECUTED'),
+  Type.Literal('FAILED'),
+  Type.Literal('TIMEOUT'),
+  Type.Literal('CANCELLED')
+])
+export const IoTDeviceCommandSchema = Type.Object({
+  deviceId: Type.String(),
+  ruleReference: Type.String({ description: 'Rule reference like device.unlock' }),
+  parameters: Type.Optional(Type.Record(Type.String(), Type.Any())),
+  priority: Type.Union([
+    Type.Literal('LOW'),
+    Type.Literal('NORMAL'),
+    Type.Literal('HIGH'),
+    Type.Literal('URGENT')
+  ]),
+  timeout: Type.Optional(Type.Number({ 
+    minimum: 1000,
+    maximum: 300000,
+    description: 'Command timeout in milliseconds'
+  })),
+  retryCount: Type.Optional(Type.Number({ minimum: 0, maximum: 5 })),
+  scheduledAt: Type.Optional(Type.Number({ description: 'Scheduled execution timestamp' })),
+  executedAt: Type.Optional(Type.Number({ description: 'Actual execution timestamp' })),
+  status: IoTDeviceCommandStatusSchema,
+  response: Type.Optional(Type.Any()),
+  error: Type.Optional(Type.String()),
+  initiatedBy: Type.String(),
+  created: ActionRecordSchema
+})
+
+export const IoTDeviceReportSchema = Type.Object({
+  deviceId: Type.String(),
+  ruleReference: Type.String({ description: 'Rule reference like position.report' }),
+  payload: Type.Record(Type.String(), Type.Any()),
+  receivedAt: Type.Number({ description: 'Server receipt timestamp' }),
+  deviceTimestamp: Type.Optional(Type.Number({ description: 'Device generation timestamp' })),
+  topicPath: Type.String(),
+  qos: Type.Number({ minimum: 0, maximum: 2 }),
+  processed: Type.Boolean(),
+  processedAt: Type.Optional(Type.Number()),
+  processingErrors: Type.Optional(Type.Array(Type.String()))
+})
+
+export const IoTDeviceQuerySchema = Type.Object({
+  online: Type.Optional(Type.Boolean()),
+  enabled: Type.Optional(Type.Boolean()),
+  tested: Type.Optional(Type.Boolean()),
+  tags: Type.Optional(Type.Array(Type.String())),
+  manufacturer: Type.Optional(Type.String()),
+  model: Type.Optional(Type.String()),
+  batteryLevel: Type.Optional(Type.Object({
+    min: Type.Number({ minimum: 0, maximum: 100 }),
+    max: Type.Number({ minimum: 0, maximum: 100 })
+  })),
+  lastSeenAfter: Type.Optional(Type.Number({ description: 'Timestamp' })),
+  lastSeenBefore: Type.Optional(Type.Number({ description: 'Timestamp' })),
+  location: Type.Optional(Type.Object({
+    center: Type.Object({
+      latitude: Type.Number(),
+      longitude: Type.Number()
+    }),
+    radius: Type.Number({ minimum: 0.1, description: 'Radius in kilometers' })
+  })),
+  limit: Type.Optional(Type.Number({ minimum: 1, maximum: 1000 })),
+  offset: Type.Optional(Type.Number({ minimum: 0 }))
+})
+
+export const IoTDeviceStatsSchema = Type.Object({
+  total: Type.Number({ minimum: 0 }),
+  online: Type.Number({ minimum: 0 }),
+  offline: Type.Number({ minimum: 0 }),
+  enabled: Type.Number({ minimum: 0 }),
+  disabled: Type.Number({ minimum: 0 }),
+  tested: Type.Number({ minimum: 0 }),
+  untested: Type.Number({ minimum: 0 }),
+  byManufacturer: Type.Optional(Type.Record(Type.String(), Type.Number({ minimum: 0 }))),
+  byModel: Type.Optional(Type.Record(Type.String(), Type.Number({ minimum: 0 }))),
+  averageBatteryLevel: Type.Optional(Type.Number({ minimum: 0, maximum: 100 })),
+  averageSignalStrength: Type.Optional(Type.Number()),
+  recentlyAdded: Type.Number({ minimum: 0, description: 'Added in last 24 hours' }),
+  lastActivity: Type.Optional(Type.Number({ description: 'Last device activity timestamp' }))
+})
+
+export type IoTDeviceCommandStatus = Static<typeof IoTDeviceCommandStatusSchema>
+export type IoTDeviceCommand = Static<typeof IoTDeviceCommandSchema>
+export type IoTDeviceReport = Static<typeof IoTDeviceReportSchema>
+export type IoTDeviceQuery = Static<typeof IoTDeviceQuerySchema>
+export type IoTDeviceStats = Static<typeof IoTDeviceStatsSchema>
+
+
+// ============================================================================
+// REQUEST VALIDATION SCHEMAS
+// ============================================================================
+// The sufix `RVS` stands for `Request Validation Schema` to keep it short
+
+export const IoTDeviceAddRVS = {
+  body: IoTDeviceAddSchema,
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      id: Type.String()
+    })
+  ])
+}
+export type IoTDeviceAddValidation = {
+  body: Static<typeof IoTDeviceAddRVS.body>
+  response: Static<typeof IoTDeviceAddRVS.response>
+}
+
+export const IoTDeviceUpdateRVS = {
+  params: Type.Object({ id: Type.String() }),
+  body: IoTDeviceUpdateSchema,
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      device: IoTDeviceSchema
+    })
+  ])
+}
+export type IoTDeviceUpdateValidation = {
+  params: Static<typeof IoTDeviceUpdateRVS.params>
+  body: Static<typeof IoTDeviceUpdateRVS.body>
+  response: Static<typeof IoTDeviceUpdateRVS.response>
+}
+
+export const IoTDeviceRetrieveRVS = {
+  params: Type.Object({ id: Type.String() }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      device: IoTDeviceSchema
+    })
+  ])
+}
+export type IoTDeviceRetrieveValidation = {
+  params: Static<typeof IoTDeviceRetrieveRVS.params>
+  response: Static<typeof IoTDeviceRetrieveRVS.response>
+}
+
+export const IoTDeviceStatusRVS = {
+  params: Type.Object({
+    id: Type.String(),
+    status: Type.String()
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      device: IoTDeviceSchema
+    })
+  ])
+}
+export type IoTDeviceStatusValidation = {
+  params: Static<typeof IoTDeviceStatusRVS.params>
+  response: Static<typeof IoTDeviceStatusRVS.response>
+}
+
+export const IoTDeviceListRVS = {
+  querystring: FetchByQueryRequestSchema,
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      devices: Type.Array(IoTDeviceSchema)
+    })
+  ])
+}
+export type IoTDeviceListValidation = {
+  querystring: Static<typeof IoTDeviceListRVS.querystring>
+  response: Static<typeof IoTDeviceListRVS.response>
+}
+
+export const IoTDeviceFindRVS = {
+  querystring: Type.Intersect([
+    FetchByQueryRequestSchema,
+    Type.Object({
+      query: Type.String()
+    })
+  ]),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      devices: Type.Array(IoTDeviceSchema)
+    })
+  ])
+}
+export type IoTDeviceFindValidation = {
+  querystring: Static<typeof IoTDeviceFindRVS.querystring>
+  response: Static<typeof IoTDeviceFindRVS.response>
+}
+
+export const IoTDeviceRemoveRVS = {
+  params: Type.Object({ id: Type.String() }),
+  response: APIResponseBaseSchema
+}
+export type IoTDeviceRemoveValidation = {
+  params: Static<typeof IoTDeviceRemoveRVS.params>
+  response: Static<typeof IoTDeviceRemoveRVS.response>
+}

package/src/iotsp/index.ts

@@ -0,0 +1,91 @@
+import { Type, Static } from '@sinclair/typebox'
+import {
+  SPProfileSchema,
+  SPProfileUpdateSchema
+} from '../context'
+
+export const IoTSPTypeSchema = Type.Union([
+  // TRACKING & MONITORING
+  Type.Literal('ASSET_TRACKING'),         // GPS tracking devices/platforms
+  Type.Literal('FLEET_TRACKING'),         // Vehicle/fleet monitoring
+  Type.Literal('CARGO_MONITORING'),       // Shipment condition monitoring
+  Type.Literal('COLD_CHAIN'),             // Temperature/humidity monitoring
+  Type.Literal('LOCATION_SERVICES'),      // Real-time location tracking
+  
+  // TELEMATICS
+  Type.Literal('TELEMATICS'),             // Vehicle telematics systems
+  Type.Literal('DRIVER_BEHAVIOR'),        // Driver monitoring/scoring
+  Type.Literal('VEHICLE_DIAGNOSTICS'),    // Engine/vehicle health monitoring
+  Type.Literal('FUEL_MONITORING'),        // Fuel consumption tracking
+  
+  // SENSORS & CONDITIONS
+  Type.Literal('ENVIRONMENTAL_SENSORS'),  // Temperature, humidity, pressure
+  Type.Literal('SECURITY_SENSORS'),       // Door, motion, tampering detection
+  Type.Literal('SHOCK_VIBRATION'),        // Impact/handling monitoring
+  Type.Literal('LIGHT_EXPOSURE'),         // Light/UV monitoring
+  
+  // CONNECTIVITY
+  Type.Literal('CONNECTIVITY_PROVIDER'),  // IoT network connectivity (cellular, LoRaWAN, etc.)
+  Type.Literal('SATELLITE_IOT'),          // Satellite-based IoT
+  Type.Literal('EDGE_COMPUTING'),         // Edge processing devices
+  
+  // PLATFORMS & SOFTWARE
+  Type.Literal('IOT_PLATFORM'),           // IoT data platform/dashboard
+  Type.Literal('ANALYTICS'),              // IoT data analytics
+  Type.Literal('INTEGRATION'),            // IoT system integration
+  
+  // SPECIALIZED
+  Type.Literal('WAREHOUSE_IOT'),          // Warehouse automation sensors
+  Type.Literal('YARD_MANAGEMENT'),        // Yard/dock IoT systems
+  Type.Literal('SMART_LOCKS'),            // Electronic locks/seals
+  Type.Literal('RFID'),                   // RFID tracking systems
+  Type.Literal('BARCODE_SCANNING'),       // Barcode/QR scanning systems
+  
+  // GENERAL
+  Type.Literal('HARDWARE_PROVIDER'),      // IoT hardware manufacturer
+  Type.Literal('SOFTWARE_PROVIDER'),      // IoT software/SaaS
+  Type.Literal('FULL_SOLUTION'),          // End-to-end IoT solution
+  Type.Literal('OTHER')
+])
+
+// LSP Schema
+export const IoTSPSchema = Type.Composite([
+  SPProfileSchema,
+  Type.Object({
+    type: IoTSPTypeSchema
+  })
+])
+export const IoTSPUpdateSchema = Type.Composite([
+  SPProfileUpdateSchema,
+  Type.Object({
+    type: Type.Optional(IoTSPTypeSchema)
+  })
+])
+
+// Service Provider Schema
+export const IoTSPServiceContextSchema = Type.Object({
+  providerType: IoTSPTypeSchema,
+  type: Type.Union([
+    // ...CarrierTypeSchema.anyOf,
+    // ...HubTypeSchema.anyOf,
+    // ...WarehouseTypeSchema.anyOf,
+    // ...TerminalTypeSchema.anyOf
+  ]),
+  id: Type.String(),
+  description: Type.Optional(Type.String({ minLength: 10, maxLength: 250 }))
+})
+
+export const IoTSPOperatorRoleSchema = Type.Union([
+  Type.Literal('ADMIN'),
+  Type.Literal('READONLY'),
+  Type.Literal('MANAGER'),
+  Type.Literal('SUPERVISOR'),
+  Type.Literal('TECHNICIAN'),
+  Type.Literal('DEVELOPER')
+])
+
+export type IoTSP = Static<typeof IoTSPSchema>
+export type IoTSPType = Static<typeof IoTSPTypeSchema>
+export type IoTSPUpdate = Static<typeof IoTSPUpdateSchema>
+export type IoTSPServiceContext = Static<typeof IoTSPServiceContextSchema>
+export type IoTSPOperatorRole = Static<typeof IoTSPOperatorRoleSchema>

package/src/iotsp/rule.ts

@@ -0,0 +1,227 @@
+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'
+
+// Param Schema
+export const IoTParamSchema = Type.Object({
+  type: Type.Union([
+    Type.Literal('boolean'),
+    Type.Literal('string'),
+    Type.Literal('number')
+  ]),
+  unit: Type.String({ maxLength: 20 }),
+  description: Type.Optional(Type.String({ maxLength: 200 })),
+  sources: Type.Optional(Type.Array(Type.String()))
+})
+export const IoTRuleTypeSchema = Type.Union([
+  Type.Literal('REPORT'),
+  Type.Literal('COMMAND')
+])
+
+// Rule Schema
+export const IoTRuleSchema = Type.Object({
+  context: ContextSchema,
+  type: IoTRuleTypeSchema,
+  /**
+   * Specific `reference` of the rule that can be use
+   * to identify a given report from devices or to initiate
+   * a single or composed command(s) to a device.
+   * 
+   * For a payload: 
+   *  - `position.report` to receive device's position report
+   *  - `network.report` to receive device's network status info
+   * 
+   * For a command:
+   *  - `network.config`
+   *  - `device.unlock` to initiate a composed command to unlock *helmet*, *ecu*, enable *wireless charge*, ...
+   * 
+   * NOTE:
+   * The validation only match strings like:
+   * 
+   * ✅ realtime-operation.report
+   * ✅ device.unlock
+   * ✅ position_tracking-v2.beta
+   * ✅ ABC123
+   * 
+   * And reject strings with other characters:
+   * 
+   * ❌ real time (space)
+   * ❌ report@v1 (@ symbol)
+   * ❌ tracking/route (/ symbol)
+   */
+  reference: Type.String({ 
+    minLength: 1,
+    maxLength: 100,
+    pattern: '^[a-zA-Z0-9._-]+$',
+    description: 'Rule reference for identification (e.g., position.report, device.unlock)'
+  }),
+  description: Type.String({ maxLength: 1000 }),
+  connectors: Type.Array(Type.String(), {
+    description: 'List of connector IDs'
+  }),
+  tags: Type.Optional(Type.Array(Type.String())),
+  struct: Type.String(),
+  schema: Type.Record(Type.String(), IoTParamSchema, {
+    description: 'Parameter schema definition'
+  }),
+  tested: Type.Boolean(),
+  enabled: Type.Boolean(),
+  added: ActionRecordSchema,
+  updated: Type.Optional(ActionRecordSchema)
+}, { additionalProperties: false })
+
+export const IoTRuleAddSchema = Type.Omit( IoTRuleSchema, ['context', 'connectors', 'tested', 'enabled', 'added', 'updated'])
+export const IoTRuleUpdateSchema = Type.Partial( IoTRuleAddSchema )
+
+// Generate TypeScript types from schemas
+export type IoTParam = Static<typeof IoTParamSchema>
+export type IoTRule = Static<typeof IoTRuleSchema>
+export type IoTRuleType = Static<typeof IoTRuleTypeSchema>
+export type IoTRuleAdd = Static<typeof IoTRuleAddSchema>
+export type IoTRuleUpdate = Static<typeof IoTRuleUpdateSchema>
+
+
+// ============================================================================
+// REQUEST VALIDATION SCHEMAS
+// ============================================================================
+// The sufix `RVS` stands for `Request Validation Schema` to keep it short
+
+export const IoTRuleAddRVS = {
+  body: IoTRuleAddSchema,
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      reference: Type.String()
+    })
+  ])
+}
+export type IoTRuleAddValidation = {
+  body: Static<typeof IoTRuleAddRVS.body>
+  response: Static<typeof IoTRuleAddRVS.response>
+}
+
+export const IoTRuleUpdateRVS = {
+  params: Type.Object({ reference: Type.String() }),
+  body: IoTRuleUpdateSchema,
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      rule: IoTRuleSchema
+    })
+  ])
+}
+export type IoTRuleUpdateValidation = {
+  params: Static<typeof IoTRuleUpdateRVS.params>
+  body: Static<typeof IoTRuleUpdateRVS.body>
+  response: Static<typeof IoTRuleUpdateRVS.response>
+}
+
+export const IoTRuleRetrieveRVS = {
+  params: Type.Object({ reference: Type.String() }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      rule: IoTRuleSchema
+    })
+  ])
+}
+export type IoTRuleRetrieveValidation = {
+  params: Static<typeof IoTRuleRetrieveRVS.params>
+  response: Static<typeof IoTRuleRetrieveRVS.response>
+}
+
+export const IoTRuleStatusRVS = {
+  params: Type.Object({
+    reference: Type.String(),
+    status: Type.String()
+  }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      rule: IoTRuleSchema
+    })
+  ])
+}
+export type IoTRuleStatusValidation = {
+  params: Static<typeof IoTRuleStatusRVS.params>
+  response: Static<typeof IoTRuleStatusRVS.response>
+}
+
+export const IoTRuleListRVS = {
+  querystring: Type.Intersect([
+    FetchByQueryRequestSchema,
+    Type.Object({
+      type: IoTRuleTypeSchema
+    })
+  ]),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      rules: Type.Array(IoTRuleSchema)
+    })
+  ])
+}
+export type IoTRuleListValidation = {
+  querystring: Static<typeof IoTRuleListRVS.querystring>
+  response: Static<typeof IoTRuleListRVS.response>
+}
+
+export const IoTRuleFindRVS = {
+  querystring: Type.Intersect([
+    FetchByQueryRequestSchema,
+    Type.Object({
+      query: Type.String()
+    })
+  ]),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      rules: Type.Array(IoTRuleSchema)
+    })
+  ])
+}
+export type IoTRuleFindValidation = {
+  querystring: Static<typeof IoTRuleFindRVS.querystring>
+  response: Static<typeof IoTRuleFindRVS.response>
+}
+
+export const IoTRuleRemoveRVS = {
+  params: Type.Object({ reference: Type.String() }),
+  response: APIResponseBaseSchema
+}
+export type IoTRuleRemoveValidation = {
+  params: Static<typeof IoTRuleRemoveRVS.params>
+  response: Static<typeof IoTRuleRemoveRVS.response>
+}
+
+export const IoTRuleConnectorsRVS = {
+  params: Type.Object({ reference: Type.String() }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      connectors: Type.Array(ConnectorSchema)
+    })
+  ])
+}
+export type IoTRuleConnectorsValidation = {
+  params: Static<typeof IoTRuleConnectorsRVS.params>
+  response: Static<typeof IoTRuleConnectorsRVS.response>
+}
+
+export const IoTRuleXssignConnectorRVS = {
+  params: Type.Object({ reference: Type.String() }),
+  body: Type.Object({ cid: Type.String() }),
+  response: Type.Intersect([
+    APIResponseBaseSchema,
+    APIResponseDataSchemaFactory({
+      rule: IoTRuleSchema
+    })
+  ])
+}
+export type IoTRuleXssignConnectorValidation = {
+  params: Static<typeof IoTRuleXssignConnectorRVS.params>
+  body: Static<typeof IoTRuleXssignConnectorRVS.body>
+  response: Static<typeof IoTRuleXssignConnectorRVS.response>
+}