langfuse_rs/apis/
models_api.rs1use super::{configuration, Error};
12use crate::{apis::ResponseContent, models};
13use reqwest;
14use serde::{Deserialize, Serialize};
15
16#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum ModelsCreateError {
20 Status400(serde_json::Value),
21 Status401(serde_json::Value),
22 Status403(serde_json::Value),
23 Status404(serde_json::Value),
24 Status405(serde_json::Value),
25 UnknownValue(serde_json::Value),
26}
27
28#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(untagged)]
31pub enum ModelsDeleteError {
32 Status400(serde_json::Value),
33 Status401(serde_json::Value),
34 Status403(serde_json::Value),
35 Status404(serde_json::Value),
36 Status405(serde_json::Value),
37 UnknownValue(serde_json::Value),
38}
39
40#[derive(Debug, Clone, Serialize, Deserialize)]
42#[serde(untagged)]
43pub enum ModelsGetError {
44 Status400(serde_json::Value),
45 Status401(serde_json::Value),
46 Status403(serde_json::Value),
47 Status404(serde_json::Value),
48 Status405(serde_json::Value),
49 UnknownValue(serde_json::Value),
50}
51
52#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(untagged)]
55pub enum ModelsListError {
56 Status400(serde_json::Value),
57 Status401(serde_json::Value),
58 Status403(serde_json::Value),
59 Status404(serde_json::Value),
60 Status405(serde_json::Value),
61 UnknownValue(serde_json::Value),
62}
63
64pub async fn models_create(
66 configuration: &configuration::Configuration,
67 create_model_request: models::CreateModelRequest,
68) -> Result<models::Model, Error<ModelsCreateError>> {
69 let p_create_model_request = create_model_request;
71
72 let uri_str = format!("{}/api/public/models", configuration.base_path);
73 let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
74
75 if let Some(ref user_agent) = configuration.user_agent {
76 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
77 }
78 if let Some(ref auth_conf) = configuration.basic_auth {
79 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
80 };
81 req_builder = req_builder.json(&p_create_model_request);
82
83 let req = req_builder.build()?;
84 let resp = configuration.client.execute(req).await?;
85
86 let status = resp.status();
87
88 if !status.is_client_error() && !status.is_server_error() {
89 let content = resp.text().await?;
90 serde_json::from_str(&content).map_err(Error::from)
91 } else {
92 let content = resp.text().await?;
93 let entity: Option<ModelsCreateError> = serde_json::from_str(&content).ok();
94 Err(Error::ResponseError(ResponseContent { status, content, entity }))
95 }
96}
97
98pub async fn models_delete(configuration: &configuration::Configuration, id: &str) -> Result<(), Error<ModelsDeleteError>> {
100 let p_id = id;
102
103 let uri_str = format!("{}/api/public/models/{id}", configuration.base_path, id = crate::apis::urlencode(p_id));
104 let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
105
106 if let Some(ref user_agent) = configuration.user_agent {
107 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
108 }
109 if let Some(ref auth_conf) = configuration.basic_auth {
110 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
111 };
112
113 let req = req_builder.build()?;
114 let resp = configuration.client.execute(req).await?;
115
116 let status = resp.status();
117
118 if !status.is_client_error() && !status.is_server_error() {
119 Ok(())
120 } else {
121 let content = resp.text().await?;
122 let entity: Option<ModelsDeleteError> = serde_json::from_str(&content).ok();
123 Err(Error::ResponseError(ResponseContent { status, content, entity }))
124 }
125}
126
127pub async fn models_get(configuration: &configuration::Configuration, id: &str) -> Result<models::Model, Error<ModelsGetError>> {
129 let p_id = id;
131
132 let uri_str = format!("{}/api/public/models/{id}", configuration.base_path, id = crate::apis::urlencode(p_id));
133 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
134
135 if let Some(ref user_agent) = configuration.user_agent {
136 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
137 }
138 if let Some(ref auth_conf) = configuration.basic_auth {
139 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
140 };
141
142 let req = req_builder.build()?;
143 let resp = configuration.client.execute(req).await?;
144
145 let status = resp.status();
146
147 if !status.is_client_error() && !status.is_server_error() {
148 let content = resp.text().await?;
149 serde_json::from_str(&content).map_err(Error::from)
150 } else {
151 let content = resp.text().await?;
152 let entity: Option<ModelsGetError> = serde_json::from_str(&content).ok();
153 Err(Error::ResponseError(ResponseContent { status, content, entity }))
154 }
155}
156
157pub async fn models_list(
159 configuration: &configuration::Configuration,
160 page: Option<i32>,
161 limit: Option<i32>,
162) -> Result<models::PaginatedModels, Error<ModelsListError>> {
163 let p_page = page;
165 let p_limit = limit;
166
167 let uri_str = format!("{}/api/public/models", configuration.base_path);
168 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
169
170 if let Some(ref param_value) = p_page {
171 req_builder = req_builder.query(&[("page", ¶m_value.to_string())]);
172 }
173 if let Some(ref param_value) = p_limit {
174 req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]);
175 }
176 if let Some(ref user_agent) = configuration.user_agent {
177 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
178 }
179 if let Some(ref auth_conf) = configuration.basic_auth {
180 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
181 };
182
183 let req = req_builder.build()?;
184 let resp = configuration.client.execute(req).await?;
185
186 let status = resp.status();
187
188 if !status.is_client_error() && !status.is_server_error() {
189 let content = resp.text().await?;
190 serde_json::from_str(&content).map_err(Error::from)
191 } else {
192 let content = resp.text().await?;
193 let entity: Option<ModelsListError> = serde_json::from_str(&content).ok();
194 Err(Error::ResponseError(ResponseContent { status, content, entity }))
195 }
196}