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

//! Query

use crate::models::ast::Package;
use crate::models::ast::dialect::Annotations;
use crate::models::File;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Query influx using the Flux language
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Query {
    /// Query Script
    #[serde(rename = "extern", skip_serializing_if = "Option::is_none")]
    pub r#extern: Option<File>,
    /// Query script to execute.
    pub query: String,
    /// The type of query. Must be \"flux\".
    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
    pub r#type: Option<Type>,
    /// Dialect
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialect: Option<crate::models::ast::Dialect>,
    /// Specifies the time that should be reported as "now" in the query.
    /// Default is the server's now time.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub now: Option<String>,
}

impl Query {
    /// Query influx using the Flux language
    pub fn new(query: String) -> Self {
        Self {
            query,
            ..Default::default()
        }
    }
}
    
impl Default for Query {
    fn default() -> Self {
        Self {
            r#extern: None,
            query: String::from(""),
            r#type: None,
            dialect: Some(crate::models::ast::Dialect {
                annotations: vec![Annotations::Datatype, Annotations::Group, Annotations::Default],
                ..Default::default()
            }),
            now: None,
        }
    }
}

/// The type of query. Must be \"flux\".
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Type {
    /// Query Type
    Flux,
}

#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
/// Flux Query Suggestion
pub struct FluxSuggestion {
    /// Suggestion Name
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Suggestion Params
    #[serde(skip_serializing_if = "Option::is_none")]
    pub params: Option<HashMap<String, String>>,
}

impl FluxSuggestion {
    /// Returns an instance FluxSuggestion
    pub fn new() -> Self {
        Self::default()
    }
}

/// FluxSuggestions
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct FluxSuggestions {
    /// List of Flux Suggestions
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub funcs: Vec<crate::models::FluxSuggestion>,
}

impl FluxSuggestions {
    /// Return an instance of FluxSuggestions
    pub fn new() -> Self {
        Self::default()
    }
}

/// AnalyzeQueryResponse
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct AnalyzeQueryResponse {
    /// List of QueryResponseErrors
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub errors: Vec<AnalyzeQueryResponseErrors>,
}

impl AnalyzeQueryResponse {
    /// Return an instance of AnanlyzeQueryResponse
    pub fn new() -> Self {
        Self::default()
    }
}

/// AnalyzeQueryResponseErrors
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct AnalyzeQueryResponseErrors {
    /// Error line
    #[serde(skip_serializing_if = "Option::is_none")]
    pub line: Option<i32>,
    /// Error column
    #[serde(skip_serializing_if = "Option::is_none")]
    pub column: Option<i32>,
    /// Error char
    #[serde(skip_serializing_if = "Option::is_none")]
    pub character: Option<i32>,
    /// Error message
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

impl AnalyzeQueryResponseErrors {
    /// Return an instance of AnalyzeQueryResponseErrors
    pub fn new() -> Self {
        Self::default()
    }
}

/// AstResponse : Contains the AST for the supplied Flux query
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct AstResponse {
    /// AST of Flux query
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ast: Option<Package>,
}

impl AstResponse {
    /// Contains the AST for the supplied Flux query
    pub fn new() -> Self {
        Self::default()
    }
}

/// LanguageRequest : Flux query to be analyzed.
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct LanguageRequest {
    /// Flux query script to be analyzed
    pub query: String,
}

impl LanguageRequest {
    /// Flux query to be analyzed.
    pub fn new(query: String) -> Self {
        Self { query }
    }
}