vapi_client/apis/
knowledge_base_api.rs

1/*
2 * Vapi API
3 *
4 * API for building voice assistants
5 *
6 * The version of the OpenAPI document: 1.0
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use std::sync::Arc;
12
13use async_trait::async_trait;
14use reqwest;
15use serde::{de::Error as _, Deserialize, Serialize};
16
17use super::{configuration, Error};
18use crate::{
19    apis::{ContentType, ResponseContent},
20    models,
21};
22
23#[async_trait]
24pub trait KnowledgeBaseApi: Send + Sync {
25    /// POST /knowledge-base
26    async fn knowledge_base_controller_create<'knowledge_base_controller_create_request>(
27        &self,
28        knowledge_base_controller_create_request: models::KnowledgeBaseControllerCreateRequest,
29    ) -> Result<
30        models::KnowledgeBaseControllerFindAll200ResponseInner,
31        Error<KnowledgeBaseControllerCreateError>,
32    >;
33
34    /// GET /knowledge-base
35    async fn knowledge_base_controller_find_all<
36        'limit,
37        'created_at_gt,
38        'created_at_lt,
39        'created_at_ge,
40        'created_at_le,
41        'updated_at_gt,
42        'updated_at_lt,
43        'updated_at_ge,
44        'updated_at_le,
45    >(
46        &self,
47        limit: Option<f64>,
48        created_at_gt: Option<String>,
49        created_at_lt: Option<String>,
50        created_at_ge: Option<String>,
51        created_at_le: Option<String>,
52        updated_at_gt: Option<String>,
53        updated_at_lt: Option<String>,
54        updated_at_ge: Option<String>,
55        updated_at_le: Option<String>,
56    ) -> Result<
57        Vec<models::KnowledgeBaseControllerFindAll200ResponseInner>,
58        Error<KnowledgeBaseControllerFindAllError>,
59    >;
60
61    /// GET /knowledge-base/{id}
62    async fn knowledge_base_controller_find_one<'id>(
63        &self,
64        id: &'id str,
65    ) -> Result<
66        models::KnowledgeBaseControllerFindAll200ResponseInner,
67        Error<KnowledgeBaseControllerFindOneError>,
68    >;
69
70    /// DELETE /knowledge-base/{id}
71    async fn knowledge_base_controller_remove<'id>(
72        &self,
73        id: &'id str,
74    ) -> Result<
75        models::KnowledgeBaseControllerFindAll200ResponseInner,
76        Error<KnowledgeBaseControllerRemoveError>,
77    >;
78
79    /// PATCH /knowledge-base/{id}
80    async fn knowledge_base_controller_update<'id, 'knowledge_base_controller_update_request>(
81        &self,
82        id: &'id str,
83        knowledge_base_controller_update_request: models::KnowledgeBaseControllerUpdateRequest,
84    ) -> Result<
85        models::KnowledgeBaseControllerFindAll200ResponseInner,
86        Error<KnowledgeBaseControllerUpdateError>,
87    >;
88}
89
90pub struct KnowledgeBaseApiClient {
91    configuration: Arc<configuration::Configuration>,
92}
93
94impl KnowledgeBaseApiClient {
95    pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
96        Self { configuration }
97    }
98}
99
100#[async_trait]
101impl KnowledgeBaseApi for KnowledgeBaseApiClient {
102    async fn knowledge_base_controller_create<'knowledge_base_controller_create_request>(
103        &self,
104        knowledge_base_controller_create_request: models::KnowledgeBaseControllerCreateRequest,
105    ) -> Result<
106        models::KnowledgeBaseControllerFindAll200ResponseInner,
107        Error<KnowledgeBaseControllerCreateError>,
108    > {
109        let local_var_configuration = &self.configuration;
110
111        let local_var_client = &local_var_configuration.client;
112
113        let local_var_uri_str = format!("{}/knowledge-base", local_var_configuration.base_path);
114        let mut local_var_req_builder =
115            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
116
117        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
118            local_var_req_builder = local_var_req_builder
119                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
120        }
121        if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
122            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
123        };
124        local_var_req_builder =
125            local_var_req_builder.json(&knowledge_base_controller_create_request);
126
127        let local_var_req = local_var_req_builder.build()?;
128        let local_var_resp = local_var_client.execute(local_var_req).await?;
129
130        let local_var_status = local_var_resp.status();
131        let local_var_content_type = local_var_resp
132            .headers()
133            .get("content-type")
134            .and_then(|v| v.to_str().ok())
135            .unwrap_or("application/octet-stream");
136        let local_var_content_type = super::ContentType::from(local_var_content_type);
137        let local_var_content = local_var_resp.text().await?;
138
139        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
140            match local_var_content_type {
141                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
142                ContentType::Text => {
143                    return Err(Error::from(serde_json::Error::custom(
144                        "Received `text/plain` content type response that cannot be converted to \
145                         `models::KnowledgeBaseControllerFindAll200ResponseInner`",
146                    )))
147                }
148                ContentType::Unsupported(local_var_unknown_type) => {
149                    return Err(Error::from(serde_json::Error::custom(format!(
150                        "Received `{local_var_unknown_type}` content type response that cannot be \
151                         converted to `models::KnowledgeBaseControllerFindAll200ResponseInner`"
152                    ))))
153                }
154            }
155        } else {
156            let local_var_entity: Option<KnowledgeBaseControllerCreateError> =
157                serde_json::from_str(&local_var_content).ok();
158            let local_var_error = ResponseContent {
159                status: local_var_status,
160                content: local_var_content,
161                entity: local_var_entity,
162            };
163            Err(Error::ResponseError(local_var_error))
164        }
165    }
166
167    async fn knowledge_base_controller_find_all<
168        'limit,
169        'created_at_gt,
170        'created_at_lt,
171        'created_at_ge,
172        'created_at_le,
173        'updated_at_gt,
174        'updated_at_lt,
175        'updated_at_ge,
176        'updated_at_le,
177    >(
178        &self,
179        limit: Option<f64>,
180        created_at_gt: Option<String>,
181        created_at_lt: Option<String>,
182        created_at_ge: Option<String>,
183        created_at_le: Option<String>,
184        updated_at_gt: Option<String>,
185        updated_at_lt: Option<String>,
186        updated_at_ge: Option<String>,
187        updated_at_le: Option<String>,
188    ) -> Result<
189        Vec<models::KnowledgeBaseControllerFindAll200ResponseInner>,
190        Error<KnowledgeBaseControllerFindAllError>,
191    > {
192        let local_var_configuration = &self.configuration;
193
194        let local_var_client = &local_var_configuration.client;
195
196        let local_var_uri_str = format!("{}/knowledge-base", local_var_configuration.base_path);
197        let mut local_var_req_builder =
198            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
199
200        if let Some(ref local_var_str) = limit {
201            local_var_req_builder =
202                local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
203        }
204        if let Some(ref local_var_str) = created_at_gt {
205            local_var_req_builder =
206                local_var_req_builder.query(&[("createdAtGt", &local_var_str.to_string())]);
207        }
208        if let Some(ref local_var_str) = created_at_lt {
209            local_var_req_builder =
210                local_var_req_builder.query(&[("createdAtLt", &local_var_str.to_string())]);
211        }
212        if let Some(ref local_var_str) = created_at_ge {
213            local_var_req_builder =
214                local_var_req_builder.query(&[("createdAtGe", &local_var_str.to_string())]);
215        }
216        if let Some(ref local_var_str) = created_at_le {
217            local_var_req_builder =
218                local_var_req_builder.query(&[("createdAtLe", &local_var_str.to_string())]);
219        }
220        if let Some(ref local_var_str) = updated_at_gt {
221            local_var_req_builder =
222                local_var_req_builder.query(&[("updatedAtGt", &local_var_str.to_string())]);
223        }
224        if let Some(ref local_var_str) = updated_at_lt {
225            local_var_req_builder =
226                local_var_req_builder.query(&[("updatedAtLt", &local_var_str.to_string())]);
227        }
228        if let Some(ref local_var_str) = updated_at_ge {
229            local_var_req_builder =
230                local_var_req_builder.query(&[("updatedAtGe", &local_var_str.to_string())]);
231        }
232        if let Some(ref local_var_str) = updated_at_le {
233            local_var_req_builder =
234                local_var_req_builder.query(&[("updatedAtLe", &local_var_str.to_string())]);
235        }
236        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
237            local_var_req_builder = local_var_req_builder
238                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
239        }
240        if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
241            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
242        };
243
244        let local_var_req = local_var_req_builder.build()?;
245        let local_var_resp = local_var_client.execute(local_var_req).await?;
246
247        let local_var_status = local_var_resp.status();
248        let local_var_content_type = local_var_resp
249            .headers()
250            .get("content-type")
251            .and_then(|v| v.to_str().ok())
252            .unwrap_or("application/octet-stream");
253        let local_var_content_type = super::ContentType::from(local_var_content_type);
254        let local_var_content = local_var_resp.text().await?;
255
256        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
257            match local_var_content_type {
258                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
259                ContentType::Text => {
260                    return Err(Error::from(serde_json::Error::custom(
261                        "Received `text/plain` content type response that cannot be converted to \
262                         `Vec&lt;models::KnowledgeBaseControllerFindAll200ResponseInner&gt;`",
263                    )))
264                }
265                ContentType::Unsupported(local_var_unknown_type) => {
266                    return Err(Error::from(serde_json::Error::custom(format!(
267                        "Received `{local_var_unknown_type}` content type response that cannot be \
268                         converted to \
269                         `Vec&lt;models::KnowledgeBaseControllerFindAll200ResponseInner&gt;`"
270                    ))))
271                }
272            }
273        } else {
274            let local_var_entity: Option<KnowledgeBaseControllerFindAllError> =
275                serde_json::from_str(&local_var_content).ok();
276            let local_var_error = ResponseContent {
277                status: local_var_status,
278                content: local_var_content,
279                entity: local_var_entity,
280            };
281            Err(Error::ResponseError(local_var_error))
282        }
283    }
284
285    async fn knowledge_base_controller_find_one<'id>(
286        &self,
287        id: &'id str,
288    ) -> Result<
289        models::KnowledgeBaseControllerFindAll200ResponseInner,
290        Error<KnowledgeBaseControllerFindOneError>,
291    > {
292        let local_var_configuration = &self.configuration;
293
294        let local_var_client = &local_var_configuration.client;
295
296        let local_var_uri_str = format!(
297            "{}/knowledge-base/{id}",
298            local_var_configuration.base_path,
299            id = crate::apis::urlencode(id)
300        );
301        let mut local_var_req_builder =
302            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
303
304        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
305            local_var_req_builder = local_var_req_builder
306                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
307        }
308        if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
309            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
310        };
311
312        let local_var_req = local_var_req_builder.build()?;
313        let local_var_resp = local_var_client.execute(local_var_req).await?;
314
315        let local_var_status = local_var_resp.status();
316        let local_var_content_type = local_var_resp
317            .headers()
318            .get("content-type")
319            .and_then(|v| v.to_str().ok())
320            .unwrap_or("application/octet-stream");
321        let local_var_content_type = super::ContentType::from(local_var_content_type);
322        let local_var_content = local_var_resp.text().await?;
323
324        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
325            match local_var_content_type {
326                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
327                ContentType::Text => {
328                    return Err(Error::from(serde_json::Error::custom(
329                        "Received `text/plain` content type response that cannot be converted to \
330                         `models::KnowledgeBaseControllerFindAll200ResponseInner`",
331                    )))
332                }
333                ContentType::Unsupported(local_var_unknown_type) => {
334                    return Err(Error::from(serde_json::Error::custom(format!(
335                        "Received `{local_var_unknown_type}` content type response that cannot be \
336                         converted to `models::KnowledgeBaseControllerFindAll200ResponseInner`"
337                    ))))
338                }
339            }
340        } else {
341            let local_var_entity: Option<KnowledgeBaseControllerFindOneError> =
342                serde_json::from_str(&local_var_content).ok();
343            let local_var_error = ResponseContent {
344                status: local_var_status,
345                content: local_var_content,
346                entity: local_var_entity,
347            };
348            Err(Error::ResponseError(local_var_error))
349        }
350    }
351
352    async fn knowledge_base_controller_remove<'id>(
353        &self,
354        id: &'id str,
355    ) -> Result<
356        models::KnowledgeBaseControllerFindAll200ResponseInner,
357        Error<KnowledgeBaseControllerRemoveError>,
358    > {
359        let local_var_configuration = &self.configuration;
360
361        let local_var_client = &local_var_configuration.client;
362
363        let local_var_uri_str = format!(
364            "{}/knowledge-base/{id}",
365            local_var_configuration.base_path,
366            id = crate::apis::urlencode(id)
367        );
368        let mut local_var_req_builder =
369            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
370
371        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
372            local_var_req_builder = local_var_req_builder
373                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
374        }
375        if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
376            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
377        };
378
379        let local_var_req = local_var_req_builder.build()?;
380        let local_var_resp = local_var_client.execute(local_var_req).await?;
381
382        let local_var_status = local_var_resp.status();
383        let local_var_content_type = local_var_resp
384            .headers()
385            .get("content-type")
386            .and_then(|v| v.to_str().ok())
387            .unwrap_or("application/octet-stream");
388        let local_var_content_type = super::ContentType::from(local_var_content_type);
389        let local_var_content = local_var_resp.text().await?;
390
391        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
392            match local_var_content_type {
393                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
394                ContentType::Text => {
395                    return Err(Error::from(serde_json::Error::custom(
396                        "Received `text/plain` content type response that cannot be converted to \
397                         `models::KnowledgeBaseControllerFindAll200ResponseInner`",
398                    )))
399                }
400                ContentType::Unsupported(local_var_unknown_type) => {
401                    return Err(Error::from(serde_json::Error::custom(format!(
402                        "Received `{local_var_unknown_type}` content type response that cannot be \
403                         converted to `models::KnowledgeBaseControllerFindAll200ResponseInner`"
404                    ))))
405                }
406            }
407        } else {
408            let local_var_entity: Option<KnowledgeBaseControllerRemoveError> =
409                serde_json::from_str(&local_var_content).ok();
410            let local_var_error = ResponseContent {
411                status: local_var_status,
412                content: local_var_content,
413                entity: local_var_entity,
414            };
415            Err(Error::ResponseError(local_var_error))
416        }
417    }
418
419    async fn knowledge_base_controller_update<'id, 'knowledge_base_controller_update_request>(
420        &self,
421        id: &'id str,
422        knowledge_base_controller_update_request: models::KnowledgeBaseControllerUpdateRequest,
423    ) -> Result<
424        models::KnowledgeBaseControllerFindAll200ResponseInner,
425        Error<KnowledgeBaseControllerUpdateError>,
426    > {
427        let local_var_configuration = &self.configuration;
428
429        let local_var_client = &local_var_configuration.client;
430
431        let local_var_uri_str = format!(
432            "{}/knowledge-base/{id}",
433            local_var_configuration.base_path,
434            id = crate::apis::urlencode(id)
435        );
436        let mut local_var_req_builder =
437            local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
438
439        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
440            local_var_req_builder = local_var_req_builder
441                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
442        }
443        if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
444            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
445        };
446        local_var_req_builder =
447            local_var_req_builder.json(&knowledge_base_controller_update_request);
448
449        let local_var_req = local_var_req_builder.build()?;
450        let local_var_resp = local_var_client.execute(local_var_req).await?;
451
452        let local_var_status = local_var_resp.status();
453        let local_var_content_type = local_var_resp
454            .headers()
455            .get("content-type")
456            .and_then(|v| v.to_str().ok())
457            .unwrap_or("application/octet-stream");
458        let local_var_content_type = super::ContentType::from(local_var_content_type);
459        let local_var_content = local_var_resp.text().await?;
460
461        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
462            match local_var_content_type {
463                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
464                ContentType::Text => {
465                    return Err(Error::from(serde_json::Error::custom(
466                        "Received `text/plain` content type response that cannot be converted to \
467                         `models::KnowledgeBaseControllerFindAll200ResponseInner`",
468                    )))
469                }
470                ContentType::Unsupported(local_var_unknown_type) => {
471                    return Err(Error::from(serde_json::Error::custom(format!(
472                        "Received `{local_var_unknown_type}` content type response that cannot be \
473                         converted to `models::KnowledgeBaseControllerFindAll200ResponseInner`"
474                    ))))
475                }
476            }
477        } else {
478            let local_var_entity: Option<KnowledgeBaseControllerUpdateError> =
479                serde_json::from_str(&local_var_content).ok();
480            let local_var_error = ResponseContent {
481                status: local_var_status,
482                content: local_var_content,
483                entity: local_var_entity,
484            };
485            Err(Error::ResponseError(local_var_error))
486        }
487    }
488}
489
490/// struct for typed errors of method [`knowledge_base_controller_create`]
491#[derive(Debug, Clone, Serialize, Deserialize)]
492#[serde(untagged)]
493pub enum KnowledgeBaseControllerCreateError {
494    UnknownValue(serde_json::Value),
495}
496
497/// struct for typed errors of method [`knowledge_base_controller_find_all`]
498#[derive(Debug, Clone, Serialize, Deserialize)]
499#[serde(untagged)]
500pub enum KnowledgeBaseControllerFindAllError {
501    UnknownValue(serde_json::Value),
502}
503
504/// struct for typed errors of method [`knowledge_base_controller_find_one`]
505#[derive(Debug, Clone, Serialize, Deserialize)]
506#[serde(untagged)]
507pub enum KnowledgeBaseControllerFindOneError {
508    UnknownValue(serde_json::Value),
509}
510
511/// struct for typed errors of method [`knowledge_base_controller_remove`]
512#[derive(Debug, Clone, Serialize, Deserialize)]
513#[serde(untagged)]
514pub enum KnowledgeBaseControllerRemoveError {
515    UnknownValue(serde_json::Value),
516}
517
518/// struct for typed errors of method [`knowledge_base_controller_update`]
519#[derive(Debug, Clone, Serialize, Deserialize)]
520#[serde(untagged)]
521pub enum KnowledgeBaseControllerUpdateError {
522    UnknownValue(serde_json::Value),
523}
vapi_client/apis/knowledge_base_api.rs

vapi_client/apis/
knowledge_base_api.rs
