vapi_client/apis/
knowledge_base_api.rs

1/*
2 * Vapi API
3 *
4 * Voice AI for developers.
5 *
6 * The version of the OpenAPI document: 1.0
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use super::{configuration, ContentType, Error};
12use crate::{apis::ResponseContent, models};
13use reqwest;
14use serde::{de::Error as _, Deserialize, Serialize};
15
16/// struct for typed errors of method [`knowledge_base_controller_create`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum KnowledgeBaseControllerCreateError {
20    UnknownValue(serde_json::Value),
21}
22
23/// struct for typed errors of method [`knowledge_base_controller_find_all`]
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum KnowledgeBaseControllerFindAllError {
27    UnknownValue(serde_json::Value),
28}
29
30/// struct for typed errors of method [`knowledge_base_controller_find_one`]
31#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum KnowledgeBaseControllerFindOneError {
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`knowledge_base_controller_remove`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum KnowledgeBaseControllerRemoveError {
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`knowledge_base_controller_update`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum KnowledgeBaseControllerUpdateError {
48    UnknownValue(serde_json::Value),
49}
50
51pub async fn knowledge_base_controller_create(
52    configuration: &configuration::Configuration,
53    knowledge_base_controller_create_request: models::KnowledgeBaseControllerCreateRequest,
54) -> Result<
55    models::KnowledgeBaseControllerFindAll200ResponseInner,
56    Error<KnowledgeBaseControllerCreateError>,
57> {
58    // add a prefix to parameters to efficiently prevent name collisions
59    let p_knowledge_base_controller_create_request = knowledge_base_controller_create_request;
60
61    let uri_str = format!("{}/knowledge-base", configuration.base_path);
62    let mut req_builder = configuration
63        .client
64        .request(reqwest::Method::POST, &uri_str);
65
66    if let Some(ref user_agent) = configuration.user_agent {
67        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
68    }
69    if let Some(ref token) = configuration.bearer_access_token {
70        req_builder = req_builder.bearer_auth(token.to_owned());
71    };
72    req_builder = req_builder.json(&p_knowledge_base_controller_create_request);
73
74    let req = req_builder.build()?;
75    let resp = configuration.client.execute(req).await?;
76
77    let status = resp.status();
78    let content_type = resp
79        .headers()
80        .get("content-type")
81        .and_then(|v| v.to_str().ok())
82        .unwrap_or("application/octet-stream");
83    let content_type = super::ContentType::from(content_type);
84
85    if !status.is_client_error() && !status.is_server_error() {
86        let content = resp.text().await?;
87        match content_type {
88            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
89            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KnowledgeBaseControllerFindAll200ResponseInner`"))),
90            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KnowledgeBaseControllerFindAll200ResponseInner`")))),
91        }
92    } else {
93        let content = resp.text().await?;
94        let entity: Option<KnowledgeBaseControllerCreateError> =
95            serde_json::from_str(&content).ok();
96        Err(Error::ResponseError(ResponseContent {
97            status,
98            content,
99            entity,
100        }))
101    }
102}
103
104pub async fn knowledge_base_controller_find_all(
105    configuration: &configuration::Configuration,
106    limit: Option<f64>,
107    created_at_gt: Option<String>,
108    created_at_lt: Option<String>,
109    created_at_ge: Option<String>,
110    created_at_le: Option<String>,
111    updated_at_gt: Option<String>,
112    updated_at_lt: Option<String>,
113    updated_at_ge: Option<String>,
114    updated_at_le: Option<String>,
115) -> Result<
116    Vec<models::KnowledgeBaseControllerFindAll200ResponseInner>,
117    Error<KnowledgeBaseControllerFindAllError>,
118> {
119    // add a prefix to parameters to efficiently prevent name collisions
120    let p_limit = limit;
121    let p_created_at_gt = created_at_gt;
122    let p_created_at_lt = created_at_lt;
123    let p_created_at_ge = created_at_ge;
124    let p_created_at_le = created_at_le;
125    let p_updated_at_gt = updated_at_gt;
126    let p_updated_at_lt = updated_at_lt;
127    let p_updated_at_ge = updated_at_ge;
128    let p_updated_at_le = updated_at_le;
129
130    let uri_str = format!("{}/knowledge-base", configuration.base_path);
131    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
132
133    if let Some(ref param_value) = p_limit {
134        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
135    }
136    if let Some(ref param_value) = p_created_at_gt {
137        req_builder = req_builder.query(&[("createdAtGt", &param_value.to_string())]);
138    }
139    if let Some(ref param_value) = p_created_at_lt {
140        req_builder = req_builder.query(&[("createdAtLt", &param_value.to_string())]);
141    }
142    if let Some(ref param_value) = p_created_at_ge {
143        req_builder = req_builder.query(&[("createdAtGe", &param_value.to_string())]);
144    }
145    if let Some(ref param_value) = p_created_at_le {
146        req_builder = req_builder.query(&[("createdAtLe", &param_value.to_string())]);
147    }
148    if let Some(ref param_value) = p_updated_at_gt {
149        req_builder = req_builder.query(&[("updatedAtGt", &param_value.to_string())]);
150    }
151    if let Some(ref param_value) = p_updated_at_lt {
152        req_builder = req_builder.query(&[("updatedAtLt", &param_value.to_string())]);
153    }
154    if let Some(ref param_value) = p_updated_at_ge {
155        req_builder = req_builder.query(&[("updatedAtGe", &param_value.to_string())]);
156    }
157    if let Some(ref param_value) = p_updated_at_le {
158        req_builder = req_builder.query(&[("updatedAtLe", &param_value.to_string())]);
159    }
160    if let Some(ref user_agent) = configuration.user_agent {
161        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
162    }
163    if let Some(ref token) = configuration.bearer_access_token {
164        req_builder = req_builder.bearer_auth(token.to_owned());
165    };
166
167    let req = req_builder.build()?;
168    let resp = configuration.client.execute(req).await?;
169
170    let status = resp.status();
171    let content_type = resp
172        .headers()
173        .get("content-type")
174        .and_then(|v| v.to_str().ok())
175        .unwrap_or("application/octet-stream");
176    let content_type = super::ContentType::from(content_type);
177
178    if !status.is_client_error() && !status.is_server_error() {
179        let content = resp.text().await?;
180        match content_type {
181            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
182            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::KnowledgeBaseControllerFindAll200ResponseInner&gt;`"))),
183            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::KnowledgeBaseControllerFindAll200ResponseInner&gt;`")))),
184        }
185    } else {
186        let content = resp.text().await?;
187        let entity: Option<KnowledgeBaseControllerFindAllError> =
188            serde_json::from_str(&content).ok();
189        Err(Error::ResponseError(ResponseContent {
190            status,
191            content,
192            entity,
193        }))
194    }
195}
196
197pub async fn knowledge_base_controller_find_one(
198    configuration: &configuration::Configuration,
199    id: &str,
200) -> Result<
201    models::KnowledgeBaseControllerFindAll200ResponseInner,
202    Error<KnowledgeBaseControllerFindOneError>,
203> {
204    // add a prefix to parameters to efficiently prevent name collisions
205    let p_id = id;
206
207    let uri_str = format!(
208        "{}/knowledge-base/{id}",
209        configuration.base_path,
210        id = crate::apis::urlencode(p_id)
211    );
212    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
213
214    if let Some(ref user_agent) = configuration.user_agent {
215        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
216    }
217    if let Some(ref token) = configuration.bearer_access_token {
218        req_builder = req_builder.bearer_auth(token.to_owned());
219    };
220
221    let req = req_builder.build()?;
222    let resp = configuration.client.execute(req).await?;
223
224    let status = resp.status();
225    let content_type = resp
226        .headers()
227        .get("content-type")
228        .and_then(|v| v.to_str().ok())
229        .unwrap_or("application/octet-stream");
230    let content_type = super::ContentType::from(content_type);
231
232    if !status.is_client_error() && !status.is_server_error() {
233        let content = resp.text().await?;
234        match content_type {
235            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
236            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KnowledgeBaseControllerFindAll200ResponseInner`"))),
237            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KnowledgeBaseControllerFindAll200ResponseInner`")))),
238        }
239    } else {
240        let content = resp.text().await?;
241        let entity: Option<KnowledgeBaseControllerFindOneError> =
242            serde_json::from_str(&content).ok();
243        Err(Error::ResponseError(ResponseContent {
244            status,
245            content,
246            entity,
247        }))
248    }
249}
250
251pub async fn knowledge_base_controller_remove(
252    configuration: &configuration::Configuration,
253    id: &str,
254) -> Result<
255    models::KnowledgeBaseControllerFindAll200ResponseInner,
256    Error<KnowledgeBaseControllerRemoveError>,
257> {
258    // add a prefix to parameters to efficiently prevent name collisions
259    let p_id = id;
260
261    let uri_str = format!(
262        "{}/knowledge-base/{id}",
263        configuration.base_path,
264        id = crate::apis::urlencode(p_id)
265    );
266    let mut req_builder = configuration
267        .client
268        .request(reqwest::Method::DELETE, &uri_str);
269
270    if let Some(ref user_agent) = configuration.user_agent {
271        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
272    }
273    if let Some(ref token) = configuration.bearer_access_token {
274        req_builder = req_builder.bearer_auth(token.to_owned());
275    };
276
277    let req = req_builder.build()?;
278    let resp = configuration.client.execute(req).await?;
279
280    let status = resp.status();
281    let content_type = resp
282        .headers()
283        .get("content-type")
284        .and_then(|v| v.to_str().ok())
285        .unwrap_or("application/octet-stream");
286    let content_type = super::ContentType::from(content_type);
287
288    if !status.is_client_error() && !status.is_server_error() {
289        let content = resp.text().await?;
290        match content_type {
291            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
292            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KnowledgeBaseControllerFindAll200ResponseInner`"))),
293            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KnowledgeBaseControllerFindAll200ResponseInner`")))),
294        }
295    } else {
296        let content = resp.text().await?;
297        let entity: Option<KnowledgeBaseControllerRemoveError> =
298            serde_json::from_str(&content).ok();
299        Err(Error::ResponseError(ResponseContent {
300            status,
301            content,
302            entity,
303        }))
304    }
305}
306
307pub async fn knowledge_base_controller_update(
308    configuration: &configuration::Configuration,
309    id: &str,
310    knowledge_base_controller_update_request: models::KnowledgeBaseControllerUpdateRequest,
311) -> Result<
312    models::KnowledgeBaseControllerFindAll200ResponseInner,
313    Error<KnowledgeBaseControllerUpdateError>,
314> {
315    // add a prefix to parameters to efficiently prevent name collisions
316    let p_id = id;
317    let p_knowledge_base_controller_update_request = knowledge_base_controller_update_request;
318
319    let uri_str = format!(
320        "{}/knowledge-base/{id}",
321        configuration.base_path,
322        id = crate::apis::urlencode(p_id)
323    );
324    let mut req_builder = configuration
325        .client
326        .request(reqwest::Method::PATCH, &uri_str);
327
328    if let Some(ref user_agent) = configuration.user_agent {
329        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
330    }
331    if let Some(ref token) = configuration.bearer_access_token {
332        req_builder = req_builder.bearer_auth(token.to_owned());
333    };
334    req_builder = req_builder.json(&p_knowledge_base_controller_update_request);
335
336    let req = req_builder.build()?;
337    let resp = configuration.client.execute(req).await?;
338
339    let status = resp.status();
340    let content_type = resp
341        .headers()
342        .get("content-type")
343        .and_then(|v| v.to_str().ok())
344        .unwrap_or("application/octet-stream");
345    let content_type = super::ContentType::from(content_type);
346
347    if !status.is_client_error() && !status.is_server_error() {
348        let content = resp.text().await?;
349        match content_type {
350            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
351            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KnowledgeBaseControllerFindAll200ResponseInner`"))),
352            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KnowledgeBaseControllerFindAll200ResponseInner`")))),
353        }
354    } else {
355        let content = resp.text().await?;
356        let entity: Option<KnowledgeBaseControllerUpdateError> =
357            serde_json::from_str(&content).ok();
358        Err(Error::ResponseError(ResponseContent {
359            status,
360            content,
361            entity,
362        }))
363    }
364}
vapi_client/apis/knowledge_base_api.rs

vapi_client/apis/
knowledge_base_api.rs
