az-device-contract-codegen 2026.5.18

Generate deterministic Modbus C, Markdown, and Tokio client artifacts from typed device contract definitions.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use std::path::PathBuf;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TransportKind {
    Rtu,
    Tcp,
}

impl TransportKind {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Rtu => "RTU",
            Self::Tcp => "TCP",
        }
    }

    pub fn file_segment(&self) -> &'static str {
        match self {
            Self::Rtu => "rtu",
            Self::Tcp => "tcp",
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ApiKind {
    StaticRead,
    RuntimeRead,
    Write,
}

impl ApiKind {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::StaticRead => "STATIC_READ",
            Self::RuntimeRead => "RUNTIME_READ",
            Self::Write => "WRITE",
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ValueType {
    Boolean,
    Int,
    String,
    Bytes,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ReadReturnKind {
    Dto,
    Boolean,
    Int,
    String,
    Bytes,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RegisterArea {
    Coil,
    DiscreteInput,
    HoldingRegister,
    InputRegister,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ContractTypedItem {
    pub name: String,
    pub summary: Option<String>,
    pub value_type: ValueType,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ContractMethod {
    pub summary: Option<String>,
    pub method_name: String,
    pub read_return_kind: Option<ReadReturnKind>,
    pub read_return_type_name: Option<String>,
    pub read_area: Option<RegisterArea>,
    pub write_area: Option<RegisterArea>,
    pub read_fields: Vec<ContractTypedItem>,
    pub parameters: Vec<ContractTypedItem>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ContractService {
    pub api_kind: ApiKind,
    pub interface_name: String,
    pub interface_summary: Option<String>,
    pub methods: Vec<ContractMethod>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ContractRenderRequest {
    pub transports: Vec<TransportKind>,
    pub services: Vec<ContractService>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ArtifactGroup {
    CServiceContract,
    CTransportContract,
    MarkdownProtocol,
    RustTokioModbus,
}

impl ArtifactGroup {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::CServiceContract => "C_SERVICE_CONTRACT",
            Self::CTransportContract => "C_TRANSPORT_CONTRACT",
            Self::MarkdownProtocol => "MARKDOWN_PROTOCOL",
            Self::RustTokioModbus => "RUST_TOKIO_MODBUS",
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GeneratedArtifact {
    pub relative_path: PathBuf,
    pub package_name: Option<String>,
    pub file_name: String,
    pub extension_name: String,
    pub content: String,
    pub artifact_group: ArtifactGroup,
    pub transport: TransportKind,
    pub service_interface_name: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ServiceSummary {
    pub api_kind: String,
    pub interface_package: String,
    pub interface_simple_name: String,
    pub summary: String,
    pub operation_count: i64,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GeneratedBundle {
    pub summary: String,
    pub artifacts: Vec<GeneratedArtifact>,
    pub services: Vec<ServiceSummary>,
}