1use serde::{Deserialize, Serialize};
2use serde_json::Value;
3
4use crate::{
5 AuthRequest, AuthenticatedSession, ServiceCoreEffect, ServiceCoreInput, ServiceCoreOutput,
6};
7use std::collections::HashMap;
8
9pub const EXTERNAL_CORE_PROTOCOL_VERSION: u32 = 6;
10
11#[derive(Debug, Clone, Serialize, Deserialize)]
12pub struct ExternalCoreRequest {
13 pub id: String,
14 pub method: ExternalCoreMethod,
15 pub payload: Value,
16}
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
19pub struct ExternalCoreResponse {
20 pub id: String,
21 pub ok: bool,
22 #[serde(skip_serializing_if = "Option::is_none")]
23 pub result: Option<Value>,
24 #[serde(skip_serializing_if = "Option::is_none")]
25 pub error: Option<ExternalCoreError>,
26}
27
28#[derive(Debug, Clone, Serialize, Deserialize)]
29pub struct ExternalCoreError {
30 pub code: String,
31 pub message: String,
32}
33
34#[derive(Debug, Clone, Serialize, Deserialize)]
35pub enum ExternalCoreMethod {
36 HandleCoreInput,
37 RegisterLocalAppClient,
38 RegisterNodeConnection,
39 CleanupWsState,
40 UpdateCallbackBase,
41 DeviceIdentity,
42 CommissionFingerprint,
43 CommissionPublicKeyBase64,
44 ListMdnsRecords,
45 PollEvents,
46 CompleteEvents,
47 CommissionChallengePayload,
48 PairingStartPayload,
49 SetupStartPayload,
50 GeneralWebhookPayload,
51 PlaygroundWebhookPayload,
52 InvokeWasmPayload,
53 Health,
54}
55
56#[derive(Debug, Clone, Serialize, Deserialize)]
57pub struct HandleCoreInputRequest {
58 pub input: ServiceCoreInput,
59}
60
61#[derive(Debug, Clone, Serialize, Deserialize)]
62pub struct HandleCoreInputResponse {
63 pub output: ServiceCoreOutput,
64}
65
66#[derive(Debug, Clone, Serialize, Deserialize)]
67pub struct RegisterLocalAppClientRequest {
68 pub ws_id: String,
69 pub auth_request: AuthRequest,
70 pub session: AuthenticatedSession,
71}
72
73#[derive(Debug, Clone, Serialize, Deserialize)]
74pub struct RegisterNodeConnectionRequest {
75 pub ws_id: String,
76 pub session_id: String,
77 pub node_type: String,
78 pub instance_id: String,
79 #[serde(default, skip_serializing_if = "Option::is_none")]
80 pub host_name: Option<String>,
81 pub tenant_id: String,
82 pub scope_id: String,
83}
84
85#[derive(Debug, Clone, Serialize, Deserialize)]
86pub struct CleanupWsStateRequest {
87 pub ws_id: String,
88}
89
90#[derive(Debug, Clone, Serialize, Deserialize)]
91pub struct UpdateCallbackBaseRequest {
92 pub callback_base: String,
93 pub host: String,
94 pub port: u16,
95}
96
97#[derive(Debug, Clone, Serialize, Deserialize)]
98#[serde(rename_all = "camelCase")]
99pub struct ExternalCoreDeviceIdentity {
100 pub device_id: String,
101 pub device_name: String,
102}
103
104#[derive(Debug, Clone, Serialize, Deserialize)]
105#[serde(rename_all = "camelCase")]
106pub struct ListMdnsRecordsRequest {
107 pub port: u16,
108 pub addresses: Vec<String>,
109 pub host_type: String,
110}
111
112#[derive(Debug, Clone, Serialize, Deserialize)]
113#[serde(rename_all = "camelCase")]
114pub struct ExternalCoreMdnsRecord {
115 pub service_type: String,
116 pub instance_name: String,
117 pub port: u16,
118 pub properties: HashMap<String, String>,
119}
120
121#[derive(Debug, Clone, Serialize, Deserialize)]
122#[serde(rename_all = "camelCase")]
123pub struct PollExternalCoreEventsRequest {
124 pub consumer_id: String,
125 pub max_events: u16,
126 pub timeout_ms: u64,
127}
128
129#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(rename_all = "camelCase")]
131pub struct PollExternalCoreEventsResponse {
132 pub events: Vec<ExternalCoreEvent>,
133 pub timed_out: bool,
134}
135
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(rename_all = "camelCase")]
138pub struct CompleteExternalCoreEventsRequest {
139 pub consumer_id: String,
140 pub completions: Vec<ExternalCoreEventCompletion>,
141}
142
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(rename_all = "camelCase")]
145pub struct CompleteExternalCoreEventsResponse {
146 pub completed_event_ids: Vec<String>,
147 pub missing_event_ids: Vec<String>,
148}
149
150#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(rename_all = "camelCase")]
152pub struct ExternalCoreEvent {
153 pub event_id: String,
154 pub kind: ExternalCoreEventKind,
155 pub payload: Value,
156 pub expects_response: bool,
157}
158
159#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
160#[serde(rename_all = "camelCase")]
161pub enum ExternalCoreEventKind {
162 MdnsRecordsChanged,
163 ServiceEffects,
164}
165
166#[derive(Debug, Clone, Serialize, Deserialize)]
167#[serde(rename_all = "camelCase")]
168pub struct ExternalCoreServiceEffects {
169 pub effects: Vec<ServiceCoreEffect>,
170}
171
172#[derive(Debug, Clone, Serialize, Deserialize)]
173#[serde(rename_all = "camelCase")]
174pub struct ExternalCoreEventCompletion {
175 pub event_id: String,
176 pub ok: bool,
177 #[serde(default, skip_serializing_if = "Option::is_none")]
178 pub response: Option<Value>,
179 #[serde(default, skip_serializing_if = "Option::is_none")]
180 pub error: Option<ExternalCoreError>,
181}
182
183#[derive(Debug, Clone, Serialize, Deserialize)]
184pub struct HttpPayloadRequest {
185 pub payload: Value,
186}
187
188#[derive(Debug, Clone, Serialize, Deserialize)]
189pub struct EndpointPayloadRequest {
190 pub endpoint_id: String,
191 pub payload: Value,
192}
193
194#[derive(Debug, Clone, Serialize, Deserialize)]
195pub struct PlaygroundPayloadRequest {
196 pub tenant_id: String,
197 pub scope_id: String,
198 pub device_id: String,
199 pub capability_id: String,
200 pub payload: Value,
201}
202
203#[derive(Debug, Clone, Serialize, Deserialize)]
204#[serde(rename_all = "camelCase")]
205pub struct ExternalCoreRuntimeMetadata {
206 pub backend: String,
207 pub instance_id: String,
208 pub pid: u32,
209 pub state: String,
210 pub started_at: String,
211 pub protocol_version: u32,
212 pub binary_version: String,
213 pub socket_path: String,
214}
215
216#[derive(Debug, Clone, Serialize, Deserialize)]
217#[serde(rename_all = "camelCase")]
218pub struct ExternalCoreHealth {
219 pub ok: bool,
220 pub ready: bool,
221 pub backend: String,
222 pub binary_version: String,
223 pub agent_version: String,
224 pub protocol_version: u32,
225 #[serde(skip_serializing_if = "Option::is_none")]
226 pub instance_id: Option<String>,
227 #[serde(skip_serializing_if = "Option::is_none")]
228 pub pid: Option<u32>,
229 #[serde(skip_serializing_if = "Option::is_none")]
230 pub state: Option<String>,
231 #[serde(skip_serializing_if = "Option::is_none")]
232 pub started_at: Option<String>,
233 #[serde(default)]
234 pub capabilities: Vec<String>,
235}