rusty_falcon/apis/
container_packages_api.rs

1/*
2 * CrowdStrike API Specification
3 *
4 * Use this API specification as a reference for the API endpoints you can use to interact with your Falcon environment. These endpoints support authentication via OAuth2 and interact with detections and network containment. For detailed usage guides and examples, see our [documentation inside the Falcon console](https://falcon.crowdstrike.com/support/documentation).     To use the APIs described below, combine the base URL with the path shown for each API endpoint. For commercial cloud customers, your base URL is `https://api.crowdstrike.com`.    Each API endpoint requires authorization via an OAuth2 token. Your first API request should retrieve an OAuth2 token using the `oauth2/token` endpoint, such as `https://api.crowdstrike.com/oauth2/token`. For subsequent requests, include the OAuth2 token in an HTTP authorization header. Tokens expire after 30 minutes, after which you should make a new token request to continue making API requests.
5 *
6 * The version of the OpenAPI document: rolling
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 _;
15
16/// struct for typed errors of method [`read_packages_by_fixable_vuln_count`]
17#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum ReadPackagesByFixableVulnCountError {
20    Status403(models::MsaReplyMetaOnly),
21    Status429(models::MsaReplyMetaOnly),
22    Status500(models::CoreEntitiesResponse),
23    UnknownValue(serde_json::Value),
24}
25
26/// struct for typed errors of method [`read_packages_by_image_count`]
27#[derive(Debug, Clone, Serialize, Deserialize)]
28#[serde(untagged)]
29pub enum ReadPackagesByImageCountError {
30    Status403(models::MsaReplyMetaOnly),
31    Status429(models::MsaReplyMetaOnly),
32    Status500(models::CoreEntitiesResponse),
33    UnknownValue(serde_json::Value),
34}
35
36/// struct for typed errors of method [`read_packages_by_vuln_count`]
37#[derive(Debug, Clone, Serialize, Deserialize)]
38#[serde(untagged)]
39pub enum ReadPackagesByVulnCountError {
40    Status403(models::MsaReplyMetaOnly),
41    Status429(models::MsaReplyMetaOnly),
42    Status500(models::CoreEntitiesResponse),
43    UnknownValue(serde_json::Value),
44}
45
46/// struct for typed errors of method [`read_packages_combined`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum ReadPackagesCombinedError {
50    Status403(models::MsaReplyMetaOnly),
51    Status429(models::MsaReplyMetaOnly),
52    Status500(models::CoreEntitiesResponse),
53    UnknownValue(serde_json::Value),
54}
55
56/// struct for typed errors of method [`read_packages_combined_export`]
57#[derive(Debug, Clone, Serialize, Deserialize)]
58#[serde(untagged)]
59pub enum ReadPackagesCombinedExportError {
60    Status403(models::MsaReplyMetaOnly),
61    Status429(models::MsaReplyMetaOnly),
62    Status500(models::CoreEntitiesResponse),
63    UnknownValue(serde_json::Value),
64}
65
66/// struct for typed errors of method [`read_packages_combined_v2`]
67#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(untagged)]
69pub enum ReadPackagesCombinedV2Error {
70    Status403(models::MsaReplyMetaOnly),
71    Status429(models::MsaReplyMetaOnly),
72    Status500(models::CoreEntitiesResponse),
73    UnknownValue(serde_json::Value),
74}
75
76/// struct for typed errors of method [`read_packages_count_by_zero_day`]
77#[derive(Debug, Clone, Serialize, Deserialize)]
78#[serde(untagged)]
79pub enum ReadPackagesCountByZeroDayError {
80    Status403(models::MsaReplyMetaOnly),
81    Status429(models::MsaReplyMetaOnly),
82    Status500(models::CoreEntitiesResponse),
83    UnknownValue(serde_json::Value),
84}
85
86pub async fn read_packages_by_fixable_vuln_count(
87    configuration: &configuration::Configuration,
88    filter: Option<&str>,
89    limit: Option<i32>,
90    offset: Option<i32>,
91) -> Result<models::PackagesApiPackagesByVulnCount, Error<ReadPackagesByFixableVulnCountError>> {
92    // add a prefix to parameters to efficiently prevent name collisions
93    let p_query_filter = filter;
94    let p_query_limit = limit;
95    let p_query_offset = offset;
96
97    let uri_str = format!(
98        "{}/container-security/combined/packages/app-by-fixable-vulnerability-count/v1",
99        configuration.base_path
100    );
101    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
102
103    if let Some(ref param_value) = p_query_filter {
104        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
105    }
106    if let Some(ref param_value) = p_query_limit {
107        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
108    }
109    if let Some(ref param_value) = p_query_offset {
110        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
111    }
112    if let Some(ref user_agent) = configuration.user_agent {
113        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
114    }
115    if let Some(ref token) = configuration.oauth_access_token {
116        req_builder = req_builder.bearer_auth(token.to_owned());
117    };
118
119    let req = req_builder.build()?;
120    let resp = configuration.client.execute(req).await?;
121
122    let status = resp.status();
123    let content_type = resp
124        .headers()
125        .get("content-type")
126        .and_then(|v| v.to_str().ok())
127        .unwrap_or("application/octet-stream");
128    let content_type = super::ContentType::from(content_type);
129
130    if !status.is_client_error() && !status.is_server_error() {
131        let content = resp.text().await?;
132        match content_type {
133            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
134            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::PackagesApiPackagesByVulnCount`"))),
135            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::PackagesApiPackagesByVulnCount`")))),
136        }
137    } else {
138        let content = resp.text().await?;
139        let entity: Option<ReadPackagesByFixableVulnCountError> =
140            serde_json::from_str(&content).ok();
141        Err(Error::ResponseError(ResponseContent {
142            status,
143            content,
144            entity,
145        }))
146    }
147}
148
149pub async fn read_packages_by_image_count(
150    configuration: &configuration::Configuration,
151    filter: Option<&str>,
152    limit: Option<i32>,
153) -> Result<models::PackagesApiPackagesByImageCount, Error<ReadPackagesByImageCountError>> {
154    // add a prefix to parameters to efficiently prevent name collisions
155    let p_query_filter = filter;
156    let p_query_limit = limit;
157
158    let uri_str = format!(
159        "{}/container-security/aggregates/packages/by-image-count/v1",
160        configuration.base_path
161    );
162    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
163
164    if let Some(ref param_value) = p_query_filter {
165        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
166    }
167    if let Some(ref param_value) = p_query_limit {
168        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
169    }
170    if let Some(ref user_agent) = configuration.user_agent {
171        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
172    }
173    if let Some(ref token) = configuration.oauth_access_token {
174        req_builder = req_builder.bearer_auth(token.to_owned());
175    };
176
177    let req = req_builder.build()?;
178    let resp = configuration.client.execute(req).await?;
179
180    let status = resp.status();
181    let content_type = resp
182        .headers()
183        .get("content-type")
184        .and_then(|v| v.to_str().ok())
185        .unwrap_or("application/octet-stream");
186    let content_type = super::ContentType::from(content_type);
187
188    if !status.is_client_error() && !status.is_server_error() {
189        let content = resp.text().await?;
190        match content_type {
191            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
192            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::PackagesApiPackagesByImageCount`"))),
193            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::PackagesApiPackagesByImageCount`")))),
194        }
195    } else {
196        let content = resp.text().await?;
197        let entity: Option<ReadPackagesByImageCountError> = serde_json::from_str(&content).ok();
198        Err(Error::ResponseError(ResponseContent {
199            status,
200            content,
201            entity,
202        }))
203    }
204}
205
206pub async fn read_packages_by_vuln_count(
207    configuration: &configuration::Configuration,
208    filter: Option<&str>,
209    limit: Option<i32>,
210    offset: Option<i32>,
211) -> Result<models::PackagesApiPackagesByVulnCount, Error<ReadPackagesByVulnCountError>> {
212    // add a prefix to parameters to efficiently prevent name collisions
213    let p_query_filter = filter;
214    let p_query_limit = limit;
215    let p_query_offset = offset;
216
217    let uri_str = format!(
218        "{}/container-security/combined/packages/by-vulnerability-count/v1",
219        configuration.base_path
220    );
221    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
222
223    if let Some(ref param_value) = p_query_filter {
224        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
225    }
226    if let Some(ref param_value) = p_query_limit {
227        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
228    }
229    if let Some(ref param_value) = p_query_offset {
230        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
231    }
232    if let Some(ref user_agent) = configuration.user_agent {
233        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
234    }
235    if let Some(ref token) = configuration.oauth_access_token {
236        req_builder = req_builder.bearer_auth(token.to_owned());
237    };
238
239    let req = req_builder.build()?;
240    let resp = configuration.client.execute(req).await?;
241
242    let status = resp.status();
243    let content_type = resp
244        .headers()
245        .get("content-type")
246        .and_then(|v| v.to_str().ok())
247        .unwrap_or("application/octet-stream");
248    let content_type = super::ContentType::from(content_type);
249
250    if !status.is_client_error() && !status.is_server_error() {
251        let content = resp.text().await?;
252        match content_type {
253            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
254            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::PackagesApiPackagesByVulnCount`"))),
255            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::PackagesApiPackagesByVulnCount`")))),
256        }
257    } else {
258        let content = resp.text().await?;
259        let entity: Option<ReadPackagesByVulnCountError> = serde_json::from_str(&content).ok();
260        Err(Error::ResponseError(ResponseContent {
261            status,
262            content,
263            entity,
264        }))
265    }
266}
267
268pub async fn read_packages_combined(
269    configuration: &configuration::Configuration,
270    filter: Option<&str>,
271    only_zero_day_affected: Option<bool>,
272    sort: Option<&str>,
273    limit: Option<i32>,
274    offset: Option<i32>,
275) -> Result<models::PackagesApiCombinedPackage, Error<ReadPackagesCombinedError>> {
276    // add a prefix to parameters to efficiently prevent name collisions
277    let p_query_filter = filter;
278    let p_query_only_zero_day_affected = only_zero_day_affected;
279    let p_query_sort = sort;
280    let p_query_limit = limit;
281    let p_query_offset = offset;
282
283    let uri_str = format!(
284        "{}/container-security/combined/packages/v1",
285        configuration.base_path
286    );
287    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
288
289    if let Some(ref param_value) = p_query_filter {
290        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
291    }
292    if let Some(ref param_value) = p_query_only_zero_day_affected {
293        req_builder = req_builder.query(&[("only_zero_day_affected", &param_value.to_string())]);
294    }
295    if let Some(ref param_value) = p_query_sort {
296        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
297    }
298    if let Some(ref param_value) = p_query_limit {
299        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
300    }
301    if let Some(ref param_value) = p_query_offset {
302        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
303    }
304    if let Some(ref user_agent) = configuration.user_agent {
305        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
306    }
307    if let Some(ref token) = configuration.oauth_access_token {
308        req_builder = req_builder.bearer_auth(token.to_owned());
309    };
310
311    let req = req_builder.build()?;
312    let resp = configuration.client.execute(req).await?;
313
314    let status = resp.status();
315    let content_type = resp
316        .headers()
317        .get("content-type")
318        .and_then(|v| v.to_str().ok())
319        .unwrap_or("application/octet-stream");
320    let content_type = super::ContentType::from(content_type);
321
322    if !status.is_client_error() && !status.is_server_error() {
323        let content = resp.text().await?;
324        match content_type {
325            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
326            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::PackagesApiCombinedPackage`"))),
327            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::PackagesApiCombinedPackage`")))),
328        }
329    } else {
330        let content = resp.text().await?;
331        let entity: Option<ReadPackagesCombinedError> = serde_json::from_str(&content).ok();
332        Err(Error::ResponseError(ResponseContent {
333            status,
334            content,
335            entity,
336        }))
337    }
338}
339
340pub async fn read_packages_combined_export(
341    configuration: &configuration::Configuration,
342    filter: Option<&str>,
343    only_zero_day_affected: Option<bool>,
344    sort: Option<&str>,
345    limit: Option<i32>,
346    offset: Option<i32>,
347) -> Result<models::PackagesApiCombinedPackageExport, Error<ReadPackagesCombinedExportError>> {
348    // add a prefix to parameters to efficiently prevent name collisions
349    let p_query_filter = filter;
350    let p_query_only_zero_day_affected = only_zero_day_affected;
351    let p_query_sort = sort;
352    let p_query_limit = limit;
353    let p_query_offset = offset;
354
355    let uri_str = format!(
356        "{}/container-security/combined/packages/export/v1",
357        configuration.base_path
358    );
359    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
360
361    if let Some(ref param_value) = p_query_filter {
362        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
363    }
364    if let Some(ref param_value) = p_query_only_zero_day_affected {
365        req_builder = req_builder.query(&[("only_zero_day_affected", &param_value.to_string())]);
366    }
367    if let Some(ref param_value) = p_query_sort {
368        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
369    }
370    if let Some(ref param_value) = p_query_limit {
371        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
372    }
373    if let Some(ref param_value) = p_query_offset {
374        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
375    }
376    if let Some(ref user_agent) = configuration.user_agent {
377        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
378    }
379    if let Some(ref token) = configuration.oauth_access_token {
380        req_builder = req_builder.bearer_auth(token.to_owned());
381    };
382
383    let req = req_builder.build()?;
384    let resp = configuration.client.execute(req).await?;
385
386    let status = resp.status();
387    let content_type = resp
388        .headers()
389        .get("content-type")
390        .and_then(|v| v.to_str().ok())
391        .unwrap_or("application/octet-stream");
392    let content_type = super::ContentType::from(content_type);
393
394    if !status.is_client_error() && !status.is_server_error() {
395        let content = resp.text().await?;
396        match content_type {
397            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
398            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::PackagesApiCombinedPackageExport`"))),
399            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::PackagesApiCombinedPackageExport`")))),
400        }
401    } else {
402        let content = resp.text().await?;
403        let entity: Option<ReadPackagesCombinedExportError> = serde_json::from_str(&content).ok();
404        Err(Error::ResponseError(ResponseContent {
405            status,
406            content,
407            entity,
408        }))
409    }
410}
411
412pub async fn read_packages_combined_v2(
413    configuration: &configuration::Configuration,
414    filter: Option<&str>,
415    only_zero_day_affected: Option<bool>,
416    sort: Option<&str>,
417    limit: Option<i32>,
418    offset: Option<i32>,
419) -> Result<models::PackagesApiCombinedPackageV2, Error<ReadPackagesCombinedV2Error>> {
420    // add a prefix to parameters to efficiently prevent name collisions
421    let p_query_filter = filter;
422    let p_query_only_zero_day_affected = only_zero_day_affected;
423    let p_query_sort = sort;
424    let p_query_limit = limit;
425    let p_query_offset = offset;
426
427    let uri_str = format!(
428        "{}/container-security/combined/packages/v2",
429        configuration.base_path
430    );
431    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
432
433    if let Some(ref param_value) = p_query_filter {
434        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
435    }
436    if let Some(ref param_value) = p_query_only_zero_day_affected {
437        req_builder = req_builder.query(&[("only_zero_day_affected", &param_value.to_string())]);
438    }
439    if let Some(ref param_value) = p_query_sort {
440        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
441    }
442    if let Some(ref param_value) = p_query_limit {
443        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
444    }
445    if let Some(ref param_value) = p_query_offset {
446        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
447    }
448    if let Some(ref user_agent) = configuration.user_agent {
449        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
450    }
451    if let Some(ref token) = configuration.oauth_access_token {
452        req_builder = req_builder.bearer_auth(token.to_owned());
453    };
454
455    let req = req_builder.build()?;
456    let resp = configuration.client.execute(req).await?;
457
458    let status = resp.status();
459    let content_type = resp
460        .headers()
461        .get("content-type")
462        .and_then(|v| v.to_str().ok())
463        .unwrap_or("application/octet-stream");
464    let content_type = super::ContentType::from(content_type);
465
466    if !status.is_client_error() && !status.is_server_error() {
467        let content = resp.text().await?;
468        match content_type {
469            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
470            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::PackagesApiCombinedPackageV2`"))),
471            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::PackagesApiCombinedPackageV2`")))),
472        }
473    } else {
474        let content = resp.text().await?;
475        let entity: Option<ReadPackagesCombinedV2Error> = serde_json::from_str(&content).ok();
476        Err(Error::ResponseError(ResponseContent {
477            status,
478            content,
479            entity,
480        }))
481    }
482}
483
484pub async fn read_packages_count_by_zero_day(
485    configuration: &configuration::Configuration,
486    filter: Option<&str>,
487) -> Result<models::CommonCountResponse, Error<ReadPackagesCountByZeroDayError>> {
488    // add a prefix to parameters to efficiently prevent name collisions
489    let p_query_filter = filter;
490
491    let uri_str = format!(
492        "{}/container-security/aggregates/packages/count-by-zero-day/v1",
493        configuration.base_path
494    );
495    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
496
497    if let Some(ref param_value) = p_query_filter {
498        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
499    }
500    if let Some(ref user_agent) = configuration.user_agent {
501        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
502    }
503    if let Some(ref token) = configuration.oauth_access_token {
504        req_builder = req_builder.bearer_auth(token.to_owned());
505    };
506
507    let req = req_builder.build()?;
508    let resp = configuration.client.execute(req).await?;
509
510    let status = resp.status();
511    let content_type = resp
512        .headers()
513        .get("content-type")
514        .and_then(|v| v.to_str().ok())
515        .unwrap_or("application/octet-stream");
516    let content_type = super::ContentType::from(content_type);
517
518    if !status.is_client_error() && !status.is_server_error() {
519        let content = resp.text().await?;
520        match content_type {
521            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
522            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CommonCountResponse`"))),
523            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::CommonCountResponse`")))),
524        }
525    } else {
526        let content = resp.text().await?;
527        let entity: Option<ReadPackagesCountByZeroDayError> = serde_json::from_str(&content).ok();
528        Err(Error::ResponseError(ResponseContent {
529            status,
530            content,
531            entity,
532        }))
533    }
534}
rusty_falcon/apis/container_packages_api.rs

rusty_falcon/apis/
container_packages_api.rs
