aqara 0.1.1

Aqara SDK for Rust.
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198

//! Push subscription related request types.

/// A resource subscription entry.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ResourceSubscription {
    /// Subject id.
    pub subject_id: String,
    /// Resource id list.
    pub resource_ids: Vec<String>,
    /// Optional attach string echoed in push payload.
    pub attach: Option<String>,
}

impl ResourceSubscription {
    /// Create params with required fields.
    pub fn new(subject_id: impl Into<String>, resource_ids: impl Into<Vec<String>>) -> Self {
        Self {
            subject_id: subject_id.into(),
            resource_ids: resource_ids.into(),
            attach: None,
        }
    }

    /// Set attach string echoed in push payload.
    pub fn with_attach(mut self, attach: impl Into<String>) -> Self {
        self.attach = Some(attach.into());
        self
    }
}

/// Parameters for `config.resource.subscribe`.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct SubscribeResourceParams {
    /// Resource subscriptions.
    pub resources: Vec<ResourceSubscription>,
}

impl SubscribeResourceParams {
    /// Create params.
    pub fn new(resources: impl Into<Vec<ResourceSubscription>>) -> Self {
        Self {
            resources: resources.into(),
        }
    }
}

/// Parameters for `config.resource.unsubscribe`.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct UnsubscribeResourceParams {
    /// Resource subscriptions to remove.
    pub resources: Vec<ResourceSubscription>,
}

impl UnsubscribeResourceParams {
    /// Create params.
    pub fn new(resources: impl Into<Vec<ResourceSubscription>>) -> Self {
        Self {
            resources: resources.into(),
        }
    }
}

/// Parameters for `query.push.errorMsg`.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct QueryPushErrorMsgParams {
    /// App id.
    pub app_id: String,
    /// Optional user open id.
    pub open_id: Option<String>,
    /// Optional message type.
    pub msg_type: Option<String>,
    /// Optional start timestamp millis.
    pub start_time: Option<i64>,
    /// Optional end timestamp millis.
    pub end_time: Option<i64>,
    /// Optional size.
    pub size: Option<u32>,
    /// Optional scan id.
    pub scan_id: Option<String>,
}

impl QueryPushErrorMsgParams {
    /// Create params with required fields.
    pub fn new(app_id: impl Into<String>) -> Self {
        Self {
            app_id: app_id.into(),
            open_id: None,
            msg_type: None,
            start_time: None,
            end_time: None,
            size: None,
            scan_id: None,
        }
    }

    /// Set open id.
    pub fn with_open_id(mut self, open_id: impl Into<String>) -> Self {
        self.open_id = Some(open_id.into());
        self
    }

    /// Set message type.
    pub fn with_msg_type(mut self, msg_type: impl Into<String>) -> Self {
        self.msg_type = Some(msg_type.into());
        self
    }

    /// Set start timestamp millis.
    pub fn with_start_time(mut self, start_time: i64) -> Self {
        self.start_time = Some(start_time);
        self
    }

    /// Set end timestamp millis.
    pub fn with_end_time(mut self, end_time: i64) -> Self {
        self.end_time = Some(end_time);
        self
    }

    /// Set size.
    pub fn with_size(mut self, size: u32) -> Self {
        self.size = Some(size);
        self
    }

    /// Set scan id.
    pub fn with_scan_id(mut self, scan_id: impl Into<String>) -> Self {
        self.scan_id = Some(scan_id.into());
        self
    }
}

/// A trait subscription entry.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct TraitSubscription {
    /// Target device id.
    pub subject_id: String,
    /// Code paths (`endpointId.functionCode.traitCode`).
    pub code_paths: Vec<String>,
    /// Optional attach string echoed in push payload.
    pub attach: Option<String>,
}

impl TraitSubscription {
    /// Create params.
    pub fn new(subject_id: impl Into<String>, code_paths: impl Into<Vec<String>>) -> Self {
        Self {
            subject_id: subject_id.into(),
            code_paths: code_paths.into(),
            attach: None,
        }
    }

    /// Set attach string echoed in push payload.
    pub fn with_attach(mut self, attach: impl Into<String>) -> Self {
        self.attach = Some(attach.into());
        self
    }
}

/// Parameters for `spec.config.trait.subscribe`.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct TraitSubscribeParams {
    /// Trait subscriptions.
    pub traits: Vec<TraitSubscription>,
}

impl TraitSubscribeParams {
    /// Create params.
    pub fn new(traits: impl Into<Vec<TraitSubscription>>) -> Self {
        Self {
            traits: traits.into(),
        }
    }
}

/// Parameters for `spec.config.trait.unsubscribe`.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct TraitUnsubscribeParams {
    /// Trait subscriptions to remove.
    pub traits: Vec<TraitSubscription>,
}

impl TraitUnsubscribeParams {
    /// Create params.
    pub fn new(traits: impl Into<Vec<TraitSubscription>>) -> Self {
        Self {
            traits: traits.into(),
        }
    }
}