OMGeeky/google-apis-rs
1
0
Fork 0
mirror of https://github.com/OMGeeky/google-apis-rs.git synced 2026-02-23 15:49:49 +01:00
Code Issues Packages Projects Releases Wiki Activity

remove generated libs

Browse Source
This commit is contained in:
OMGeeky
2024-05-12 22:15:06 +02:00
parent 85133fa452 55222f3d00
commit 988ebe882e
4862 changed files with 0 additions and 6416267 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2579
gen/clouderrorreporting1_beta1/src/api/call_builders.rs
View File

File diff suppressed because it is too large Load Diff

112
gen/clouderrorreporting1_beta1/src/api/hub.rs
View File

@@ -1,112 +0,0 @@
use super::*;
/// Central instance to access all Clouderrorreporting related resource activities
///
/// # Examples
///
/// Instantiate a new hub
///
/// ```test_harness,no_run
/// extern crate hyper;
/// extern crate hyper_rustls;
/// extern crate google_clouderrorreporting1_beta1 as clouderrorreporting1_beta1;
/// use clouderrorreporting1_beta1::api::ErrorGroup;
/// use clouderrorreporting1_beta1::{Result, Error};
/// # async fn dox() {
/// use std::default::Default;
/// use clouderrorreporting1_beta1::{Clouderrorreporting, oauth2, hyper, hyper_rustls, chrono, FieldMask};
///
/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and
/// // `client_secret`, among other things.
/// let secret: oauth2::ApplicationSecret = Default::default();
/// // Instantiate the authenticator. It will choose a suitable authentication flow for you,
/// // unless you replace `None` with the desired Flow.
/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about
/// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and
/// // retrieve them from storage.
/// let auth = oauth2::InstalledFlowAuthenticator::builder(
/// secret,
/// oauth2::InstalledFlowReturnMethod::HTTPRedirect,
/// ).build().await.unwrap();
/// let mut hub = Clouderrorreporting::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
/// // As the method needs a request, you would usually fill it with the desired information
/// // into the respective structure. Some of the parts shown here might not be applicable !
/// // Values shown here are possibly random and not representative !
/// let mut req = ErrorGroup::default();
///
/// // You can configure optional parameters by calling the respective setters at will, and
/// // execute the final call using `doit()`.
/// // Values shown here are possibly random and not representative !
/// let result = hub.projects().groups_update(req, "name")
/// .doit().await;
///
/// match result {
/// Err(e) => match e {
/// // The Error enum provides details about what exactly happened.
/// // You can also just use its `Debug`, `Display` or `Error` traits
/// Error::HttpError(_)
/// |Error::Io(_)
/// |Error::MissingAPIKey
/// |Error::MissingToken(_)
/// |Error::Cancelled
/// |Error::UploadSizeLimitExceeded(_, _)
/// |Error::Failure(_)
/// |Error::BadRequest(_)
/// |Error::FieldClash(_)
/// |Error::JsonDecodeError(_, _) => println!("{}", e),
/// },
/// Ok(res) => println!("Success: {:?}", res),
/// }
/// # }
/// ```
#[derive(Clone)]
pub struct Clouderrorreporting<S> {
pub client: hyper::Client<S, hyper::body::Body>,
pub auth: Box<dyn client::GetToken>,
pub(super) _user_agent: String,
pub(super) _base_url: String,
pub(super) _root_url: String,
}
impl<'a, S> client::Hub for Clouderrorreporting<S> {}
impl<'a, S> Clouderrorreporting<S> {
pub fn new<A: 'static + client::GetToken>(client: hyper::Client<S, hyper::body::Body>, auth: A) -> Clouderrorreporting<S> {
Clouderrorreporting {
client,
auth: Box::new(auth),
_user_agent: "google-api-rust-client/5.0.3".to_string(),
_base_url: "https://clouderrorreporting.googleapis.com/".to_string(),
_root_url: "https://clouderrorreporting.googleapis.com/".to_string(),
}
}
pub fn projects(&'a self) -> ProjectMethods<'a, S> {
ProjectMethods { hub: &self }
}
/// Set the user-agent header field to use in all requests to the server.
/// It defaults to `google-api-rust-client/5.0.3`.
///
/// Returns the previously set user-agent.
pub fn user_agent(&mut self, agent_name: String) -> String {
mem::replace(&mut self._user_agent, agent_name)
}
/// Set the base url to use in all requests to the server.
/// It defaults to `https://clouderrorreporting.googleapis.com/`.
///
/// Returns the previously set base url.
pub fn base_url(&mut self, new_base_url: String) -> String {
mem::replace(&mut self._base_url, new_base_url)
}
/// Set the root url to use in all requests to the server.
/// It defaults to `https://clouderrorreporting.googleapis.com/`.
///
/// Returns the previously set root url.
pub fn root_url(&mut self, new_root_url: String) -> String {
mem::replace(&mut self._root_url, new_root_url)
}
}

166
gen/clouderrorreporting1_beta1/src/api/method_builders.rs
View File

@@ -1,166 +0,0 @@
use super::*;
/// A builder providing access to all methods supported on *project* resources.
/// It is not used directly, but through the [`Clouderrorreporting`] hub.
///
/// # Example
///
/// Instantiate a resource builder
///
/// ```test_harness,no_run
/// extern crate hyper;
/// extern crate hyper_rustls;
/// extern crate google_clouderrorreporting1_beta1 as clouderrorreporting1_beta1;
///
/// # async fn dox() {
/// use std::default::Default;
/// use clouderrorreporting1_beta1::{Clouderrorreporting, oauth2, hyper, hyper_rustls, chrono, FieldMask};
///
/// let secret: oauth2::ApplicationSecret = Default::default();
/// let auth = oauth2::InstalledFlowAuthenticator::builder(
/// secret,
/// oauth2::InstalledFlowReturnMethod::HTTPRedirect,
/// ).build().await.unwrap();
/// let mut hub = Clouderrorreporting::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
/// // Usually you wouldn't bind this to a variable, but keep calling *CallBuilders*
/// // like `delete_events(...)`, `events_list(...)`, `events_report(...)`, `group_stats_list(...)`, `groups_get(...)` and `groups_update(...)`
/// // to build up your call.
/// let rb = hub.projects();
/// # }
/// ```
pub struct ProjectMethods<'a, S>
where S: 'a {
pub(super) hub: &'a Clouderrorreporting<S>,
}
impl<'a, S> client::MethodsBuilder for ProjectMethods<'a, S> {}
impl<'a, S> ProjectMethods<'a, S> {
/// Create a builder to help you perform the following task:
///
/// Lists the specified events.
///
/// # Arguments
///
/// * `projectName` - Required. The resource name of the Google Cloud Platform project. Written as `projects/{projectID}`, where `{projectID}` is the [Google Cloud Platform project ID](https://support.google.com/cloud/answer/6158840). Example: `projects/my-project-123`.
pub fn events_list(&self, project_name: &str) -> ProjectEventListCall<'a, S> {
ProjectEventListCall {
hub: self.hub,
_project_name: project_name.to_string(),
_time_range_period: Default::default(),
_service_filter_version: Default::default(),
_service_filter_service: Default::default(),
_service_filter_resource_type: Default::default(),
_page_token: Default::default(),
_page_size: Default::default(),
_group_id: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Report an individual error event and record the event to a log. This endpoint accepts **either** an OAuth token, **or** an [API key](https://support.google.com/cloud/answer/6158862) for authentication. To use an API key, append it to the URL as the value of a `key` parameter. For example: `POST https://clouderrorreporting.googleapis.com/v1beta1/{projectName}/events:report?key=123ABC456` **Note:** [Error Reporting] (https://cloud.google.com/error-reporting) is a global service built on Cloud Logging and doesn't analyze logs stored in regional log buckets or logs routed to other Google Cloud projects. For more information, see [Using Error Reporting with regionalized logs] (https://cloud.google.com/error-reporting/docs/regionalization).
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `projectName` - Required. The resource name of the Google Cloud Platform project. Written as `projects/{projectId}`, where `{projectId}` is the [Google Cloud Platform project ID](https://support.google.com/cloud/answer/6158840). Example: // `projects/my-project-123`.
pub fn events_report(&self, request: ReportedErrorEvent, project_name: &str) -> ProjectEventReportCall<'a, S> {
ProjectEventReportCall {
hub: self.hub,
_request: request,
_project_name: project_name.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Lists the specified groups.
///
/// # Arguments
///
/// * `projectName` - Required. The resource name of the Google Cloud Platform project. Written as `projects/{projectID}` or `projects/{projectNumber}`, where `{projectID}` and `{projectNumber}` can be found in the [Google Cloud console](https://support.google.com/cloud/answer/6158840). Examples: `projects/my-project-123`, `projects/5551234`.
pub fn group_stats_list(&self, project_name: &str) -> ProjectGroupStatListCall<'a, S> {
ProjectGroupStatListCall {
hub: self.hub,
_project_name: project_name.to_string(),
_timed_count_duration: Default::default(),
_time_range_period: Default::default(),
_service_filter_version: Default::default(),
_service_filter_service: Default::default(),
_service_filter_resource_type: Default::default(),
_page_token: Default::default(),
_page_size: Default::default(),
_order: Default::default(),
_group_id: Default::default(),
_alignment_time: Default::default(),
_alignment: Default::default(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Get the specified group.
///
/// # Arguments
///
/// * `groupName` - Required. The group resource name. Written as `projects/{projectID}/groups/{group_name}`. Call groupStats.list to return a list of groups belonging to this project. Example: `projects/my-project-123/groups/my-group`
pub fn groups_get(&self, group_name: &str) -> ProjectGroupGetCall<'a, S> {
ProjectGroupGetCall {
hub: self.hub,
_group_name: group_name.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Replace the data for the specified group. Fails if the group does not exist.
///
/// # Arguments
///
/// * `request` - No description provided.
/// * `name` - The group resource name. Example: projects/my-project-123/groups/CNSgkpnppqKCUw
pub fn groups_update(&self, request: ErrorGroup, name: &str) -> ProjectGroupUpdateCall<'a, S> {
ProjectGroupUpdateCall {
hub: self.hub,
_request: request,
_name: name.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
/// Create a builder to help you perform the following task:
///
/// Deletes all error events of a given project.
///
/// # Arguments
///
/// * `projectName` - Required. The resource name of the Google Cloud Platform project. Written as `projects/{projectID}`, where `{projectID}` is the [Google Cloud Platform project ID](https://support.google.com/cloud/answer/6158840). Example: `projects/my-project-123`.
pub fn delete_events(&self, project_name: &str) -> ProjectDeleteEventCall<'a, S> {
ProjectDeleteEventCall {
hub: self.hub,
_project_name: project_name.to_string(),
_delegate: Default::default(),
_additional_params: Default::default(),
_scopes: Default::default(),
}
}
}

35
gen/clouderrorreporting1_beta1/src/api/mod.rs
View File

@@ -1,35 +0,0 @@
use std::collections::HashMap;
use std::cell::RefCell;
use std::default::Default;
use std::collections::BTreeSet;
use std::error::Error as StdError;
use serde_json as json;
use std::io;
use std::fs;
use std::mem;
use hyper::client::connect;
use tokio::io::{AsyncRead, AsyncWrite};
use tokio::time::sleep;
use tower_service;
use serde::{Serialize, Deserialize};
use crate::{client, client::GetToken, client::serde_with};
mod utilities;
pub use utilities::*;
mod hub;
pub use hub::*;
mod schemas;
pub use schemas::*;
mod method_builders;
pub use method_builders::*;
mod call_builders;
pub use call_builders::*;
mod enums;
pub use enums::*;

387
gen/clouderrorreporting1_beta1/src/api/schemas.rs
View File

@@ -1,387 +0,0 @@
use super::*;
/// Response message for deleting error events.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [delete events projects](ProjectDeleteEventCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct DeleteEventsResponse { _never_set: Option<bool> }
impl client::ResponseResult for DeleteEventsResponse {}
/// A description of the context in which an error occurred. This data should be provided by the application when reporting an error, unless the error report has been generated automatically from Google App Engine logs.
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ErrorContext {
/// The HTTP request which was processed when the error was triggered.
#[serde(rename="httpRequest")]
pub http_request: Option<HttpRequestContext>,
/// The location in the source code where the decision was made to report the error, usually the place where it was logged. For a logged exception this would be the source line where the exception is logged, usually close to the place where it was caught.
#[serde(rename="reportLocation")]
pub report_location: Option<SourceLocation>,
/// Source code that was used to build the executable which has caused the given error message.
#[serde(rename="sourceReferences")]
pub source_references: Option<Vec<SourceReference>>,
/// The user who caused or was affected by the crash. This can be a user ID, an email address, or an arbitrary token that uniquely identifies the user. When sending an error report, leave this field empty if the user was not logged in. In this case the Error Reporting system will use other data, such as remote IP address, to distinguish affected users. See `affected_users_count` in `ErrorGroupStats`.
pub user: Option<String>,
}
impl client::Part for ErrorContext {}
/// An error event which is returned by the Error Reporting system.
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ErrorEvent {
/// Data about the context in which the error occurred.
pub context: Option<ErrorContext>,
/// Time when the event occurred as provided in the error report. If the report did not contain a timestamp, the time the error was received by the Error Reporting system is used.
#[serde(rename="eventTime")]
pub event_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
/// The stack trace that was reported or logged by the service.
pub message: Option<String>,
/// The `ServiceContext` for which this error was reported.
#[serde(rename="serviceContext")]
pub service_context: Option<ServiceContext>,
}
impl client::Part for ErrorEvent {}
/// Description of a group of similar error events.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [groups get projects](ProjectGroupGetCall) (response)
/// * [groups update projects](ProjectGroupUpdateCall) (request|response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ErrorGroup {
/// Group IDs are unique for a given project. If the same kind of error occurs in different service contexts, it will receive the same group ID.
#[serde(rename="groupId")]
pub group_id: Option<String>,
/// The group resource name. Example: projects/my-project-123/groups/CNSgkpnppqKCUw
pub name: Option<String>,
/// Error group's resolution status. An unspecified resolution status will be interpreted as OPEN
#[serde(rename="resolutionStatus")]
pub resolution_status: Option<ErrorGroupResolutionStatusEnum>,
/// Associated tracking issues.
#[serde(rename="trackingIssues")]
pub tracking_issues: Option<Vec<TrackingIssue>>,
}
impl client::RequestValue for ErrorGroup {}
impl client::ResponseResult for ErrorGroup {}
/// Data extracted for a specific group based on certain filter criteria, such as a given time period and/or service filter.
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ErrorGroupStats {
/// Service contexts with a non-zero error count for the given filter criteria. This list can be truncated if multiple services are affected. Refer to `num_affected_services` for the total count.
#[serde(rename="affectedServices")]
pub affected_services: Option<Vec<ServiceContext>>,
/// Approximate number of affected users in the given group that match the filter criteria. Users are distinguished by data in the ErrorContext of the individual error events, such as their login name or their remote IP address in case of HTTP requests. The number of affected users can be zero even if the number of errors is non-zero if no data was provided from which the affected user could be deduced. Users are counted based on data in the request context that was provided in the error report. If more users are implicitly affected, such as due to a crash of the whole service, this is not reflected here.
#[serde(rename="affectedUsersCount")]
#[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
pub affected_users_count: Option<i64>,
/// Approximate total number of events in the given group that match the filter criteria.
#[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
pub count: Option<i64>,
/// Approximate first occurrence that was ever seen for this group and which matches the given filter criteria, ignoring the time_range that was specified in the request.
#[serde(rename="firstSeenTime")]
pub first_seen_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
/// Group data that is independent of the filter criteria.
pub group: Option<ErrorGroup>,
/// Approximate last occurrence that was ever seen for this group and which matches the given filter criteria, ignoring the time_range that was specified in the request.
#[serde(rename="lastSeenTime")]
pub last_seen_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
/// The total number of services with a non-zero error count for the given filter criteria.
#[serde(rename="numAffectedServices")]
pub num_affected_services: Option<i32>,
/// An arbitrary event that is chosen as representative for the whole group. The representative event is intended to be used as a quick preview for the whole group. Events in the group are usually sufficiently similar to each other such that showing an arbitrary representative provides insight into the characteristics of the group as a whole.
pub representative: Option<ErrorEvent>,
/// Approximate number of occurrences over time. Timed counts returned by ListGroups are guaranteed to be: - Inside the requested time interval - Non-overlapping, and - Ordered by ascending time.
#[serde(rename="timedCounts")]
pub timed_counts: Option<Vec<TimedCount>>,
}
impl client::Part for ErrorGroupStats {}
/// HTTP request data that is related to a reported error. This data should be provided by the application when reporting an error, unless the error report has been generated automatically from Google App Engine logs.
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct HttpRequestContext {
/// The type of HTTP request, such as `GET`, `POST`, etc.
pub method: Option<String>,
/// The referrer information that is provided with the request.
pub referrer: Option<String>,
/// The IP address from which the request originated. This can be IPv4, IPv6, or a token which is derived from the IP address, depending on the data that has been provided in the error report.
#[serde(rename="remoteIp")]
pub remote_ip: Option<String>,
/// The HTTP response status code for the request.
#[serde(rename="responseStatusCode")]
pub response_status_code: Option<i32>,
/// The URL of the request.
pub url: Option<String>,
/// The user agent information that is provided with the request.
#[serde(rename="userAgent")]
pub user_agent: Option<String>,
}
impl client::Part for HttpRequestContext {}
/// Contains a set of requested error events.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [events list projects](ProjectEventListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ListEventsResponse {
/// The error events which match the given request.
#[serde(rename="errorEvents")]
pub error_events: Option<Vec<ErrorEvent>>,
/// If non-empty, more results are available. Pass this token, along with the same query parameters as the first request, to view the next page of results.
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
/// The timestamp specifies the start time to which the request was restricted.
#[serde(rename="timeRangeBegin")]
pub time_range_begin: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
}
impl client::ResponseResult for ListEventsResponse {}
/// Contains a set of requested error group stats.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [group stats list projects](ProjectGroupStatListCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ListGroupStatsResponse {
/// The error group stats which match the given request.
#[serde(rename="errorGroupStats")]
pub error_group_stats: Option<Vec<ErrorGroupStats>>,
/// If non-empty, more results are available. Pass this token, along with the same query parameters as the first request, to view the next page of results.
#[serde(rename="nextPageToken")]
pub next_page_token: Option<String>,
/// The timestamp specifies the start time to which the request was restricted. The start time is set based on the requested time range. It may be adjusted to a later time if a project has exceeded the storage quota and older data has been deleted.
#[serde(rename="timeRangeBegin")]
pub time_range_begin: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
}
impl client::ResponseResult for ListGroupStatsResponse {}
/// Response for reporting an individual error event. Data may be added to this message in the future.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [events report projects](ProjectEventReportCall) (response)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ReportErrorEventResponse { _never_set: Option<bool> }
impl client::ResponseResult for ReportErrorEventResponse {}
/// An error event which is reported to the Error Reporting system.
///
/// # Activities
///
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
///
/// * [events report projects](ProjectEventReportCall) (request)
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ReportedErrorEvent {
/// Optional. A description of the context in which the error occurred.
pub context: Option<ErrorContext>,
/// Optional. Time when the event occurred. If not provided, the time when the event was received by the Error Reporting system is used. If provided, the time must not exceed the [logs retention period](https://cloud.google.com/logging/quotas#logs_retention_periods) in the past, or be more than 24 hours in the future. If an invalid time is provided, then an error is returned.
#[serde(rename="eventTime")]
pub event_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
/// Required. The error message. If no `context.reportLocation` is provided, the message must contain a header (typically consisting of the exception type name and an error message) and an exception stack trace in one of the supported programming languages and formats. Supported languages are Java, Python, JavaScript, Ruby, C#, PHP, and Go. Supported stack trace formats are: * **Java**: Must be the return value of [`Throwable.printStackTrace()`](https://docs.oracle.com/javase/7/docs/api/java/lang/Throwable.html#printStackTrace%28%29). * **Python**: Must be the return value of [`traceback.format_exc()`](https://docs.python.org/2/library/traceback.html#traceback.format_exc). * **JavaScript**: Must be the value of [`error.stack`](https://github.com/v8/v8/wiki/Stack-Trace-API) as returned by V8. * **Ruby**: Must contain frames returned by [`Exception.backtrace`](https://ruby-doc.org/core-2.2.0/Exception.html#method-i-backtrace). * **C#**: Must be the return value of [`Exception.ToString()`](https://msdn.microsoft.com/en-us/library/system.exception.tostring.aspx). * **PHP**: Must be prefixed with `"PHP (Notice|Parse error|Fatal error|Warning): "` and contain the result of [`(string)$exception`](https://php.net/manual/en/exception.tostring.php). * **Go**: Must be the return value of [`runtime.Stack()`](https://golang.org/pkg/runtime/debug/#Stack).
pub message: Option<String>,
/// Required. The service context in which this error has occurred.
#[serde(rename="serviceContext")]
pub service_context: Option<ServiceContext>,
}
impl client::RequestValue for ReportedErrorEvent {}
/// Describes a running service that sends errors. Its version changes over time and multiple versions can run in parallel.
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct ServiceContext {
/// Type of the MonitoredResource. List of possible values: https://cloud.google.com/monitoring/api/resources Value is set automatically for incoming errors and must not be set when reporting errors.
#[serde(rename="resourceType")]
pub resource_type: Option<String>,
/// An identifier of the service, such as the name of the executable, job, or Google App Engine service name. This field is expected to have a low number of values that are relatively stable over time, as opposed to `version`, which can be changed whenever new code is deployed. Contains the service name for error reports extracted from Google App Engine logs or `default` if the App Engine default service is used.
pub service: Option<String>,
/// Represents the source code version that the developer provided, which could represent a version label or a Git SHA-1 hash, for example. For App Engine standard environment, the version is set to the version of the app.
pub version: Option<String>,
}
impl client::Part for ServiceContext {}
/// Indicates a location in the source code of the service for which errors are reported. `functionName` must be provided by the application when reporting an error, unless the error report contains a `message` with a supported exception stack trace. All fields are optional for the later case.
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct SourceLocation {
/// The source code filename, which can include a truncated relative path, or a full path from a production machine.
#[serde(rename="filePath")]
pub file_path: Option<String>,
/// Human-readable name of a function or method. The value can include optional context like the class or package name. For example, `my.package.MyClass.method` in case of Java.
#[serde(rename="functionName")]
pub function_name: Option<String>,
/// 1-based. 0 indicates that the line number is unknown.
#[serde(rename="lineNumber")]
pub line_number: Option<i32>,
}
impl client::Part for SourceLocation {}
/// A reference to a particular snapshot of the source tree used to build and deploy an application.
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct SourceReference {
/// Optional. A URI string identifying the repository. Example: "https://github.com/GoogleCloudPlatform/kubernetes.git"
pub repository: Option<String>,
/// The canonical and persistent identifier of the deployed revision. Example (git): "0035781c50ec7aa23385dc841529ce8a4b70db1b"
#[serde(rename="revisionId")]
pub revision_id: Option<String>,
}
impl client::Part for SourceReference {}
/// The number of errors in a given time period. All numbers are approximate since the error events are sampled before counting them.
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct TimedCount {
/// Approximate number of occurrences in the given time period.
#[serde_as(as = "Option<::client::serde_with::DisplayFromStr>")]
pub count: Option<i64>,
/// End of the time period to which `count` refers (excluded).
#[serde(rename="endTime")]
pub end_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
/// Start of the time period to which `count` refers (included).
#[serde(rename="startTime")]
pub start_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
}
impl client::Part for TimedCount {}
/// Information related to tracking the progress on resolving the error.
///
/// This type is not used in any activity, and only used as *part* of another schema.
///
#[serde_with::serde_as(crate = "::client::serde_with")]
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct TrackingIssue {
/// A URL pointing to a related entry in an issue tracking system. Example: `https://github.com/user/project/issues/4`
pub url: Option<String>,
}
impl client::Part for TrackingIssue {}

24
gen/clouderrorreporting1_beta1/src/api/utilities.rs
View File

@@ -1,24 +0,0 @@
use super::*;
/// Identifies the an OAuth2 authorization scope.
/// A scope is needed when requesting an
/// [authorization token](https://developers.google.com/youtube/v3/guides/authentication).
#[derive(PartialEq, Eq, Hash, Debug, Clone)]
pub enum Scope {
/// See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account.
CloudPlatform,
}
impl AsRef<str> for Scope {
fn as_ref(&self) -> &str {
match *self {
Scope::CloudPlatform => "https://www.googleapis.com/auth/cloud-platform",
}
}
}
impl Default for Scope {
fn default() -> Scope {
Scope::CloudPlatform
}
}

204
gen/clouderrorreporting1_beta1/src/lib.rs
View File

@@ -1,204 +0,0 @@
// DO NOT EDIT !
// This file was generated automatically from 'src/generator/templates/api/lib.rs.mako'
// DO NOT EDIT !
//! This documentation was generated from *Clouderrorreporting* crate version *5.0.4+20240221*, where *20240221* is the exact revision of the *clouderrorreporting:v1beta1* schema built by the [mako](http://www.makotemplates.org/) code generator *v5.0.4*.
//!
//! Everything else about the *Clouderrorreporting* *v1_beta1* API can be found at the
//! [official documentation site](https://cloud.google.com/error-reporting/).
//! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/clouderrorreporting1_beta1).
//! # Features
//!
//! Handle the following *Resources* with ease from the central [hub](Clouderrorreporting) ...
//!
//! * projects
//! * [*delete events*](api::ProjectDeleteEventCall), [*events list*](api::ProjectEventListCall), [*events report*](api::ProjectEventReportCall), [*group stats list*](api::ProjectGroupStatListCall), [*groups get*](api::ProjectGroupGetCall) and [*groups update*](api::ProjectGroupUpdateCall)
//!
//!
//!
//!
//! Not what you are looking for ? Find all other Google APIs in their Rust [documentation index](http://byron.github.io/google-apis-rs).
//!
//! # Structure of this Library
//!
//! The API is structured into the following primary items:
//!
//! * **[Hub](Clouderrorreporting)**
//! * a central object to maintain state and allow accessing all *Activities*
//! * creates [*Method Builders*](client::MethodsBuilder) which in turn
//! allow access to individual [*Call Builders*](client::CallBuilder)
//! * **[Resources](client::Resource)**
//! * primary types that you can apply *Activities* to
//! * a collection of properties and *Parts*
//! * **[Parts](client::Part)**
//! * a collection of properties
//! * never directly used in *Activities*
//! * **[Activities](client::CallBuilder)**
//! * operations to apply to *Resources*
//!
//! All *structures* are marked with applicable traits to further categorize them and ease browsing.
//!
//! Generally speaking, you can invoke *Activities* like this:
//!
//! ```Rust,ignore
//! let r = hub.resource().activity(...).doit().await
//! ```
//!
//! Or specifically ...
//!
//! ```ignore
//! let r = hub.projects().groups_get(...).doit().await
//! let r = hub.projects().groups_update(...).doit().await
//! ```
//!
//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities`
//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be
//! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired.
//! The `doit()` method performs the actual communication with the server and returns the respective result.
//!
//! # Usage
//!
//! ## Setting up your Project
//!
//! To use this library, you would put the following lines into your `Cargo.toml` file:
//!
//! ```toml
//! [dependencies]
//! google-clouderrorreporting1_beta1 = "*"
//! serde = "^1.0"
//! serde_json = "^1.0"
//! ```
//!
//! ## A complete example
//!
//! ```test_harness,no_run
//! extern crate hyper;
//! extern crate hyper_rustls;
//! extern crate google_clouderrorreporting1_beta1 as clouderrorreporting1_beta1;
//! use clouderrorreporting1_beta1::api::ErrorGroup;
//! use clouderrorreporting1_beta1::{Result, Error};
//! # async fn dox() {
//! use std::default::Default;
//! use clouderrorreporting1_beta1::{Clouderrorreporting, oauth2, hyper, hyper_rustls, chrono, FieldMask};
//!
//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and
//! // `client_secret`, among other things.
//! let secret: oauth2::ApplicationSecret = Default::default();
//! // Instantiate the authenticator. It will choose a suitable authentication flow for you,
//! // unless you replace `None` with the desired Flow.
//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about
//! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and
//! // retrieve them from storage.
//! let auth = oauth2::InstalledFlowAuthenticator::builder(
//! secret,
//! oauth2::InstalledFlowReturnMethod::HTTPRedirect,
//! ).build().await.unwrap();
//! let mut hub = Clouderrorreporting::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
//! // As the method needs a request, you would usually fill it with the desired information
//! // into the respective structure. Some of the parts shown here might not be applicable !
//! // Values shown here are possibly random and not representative !
//! let mut req = ErrorGroup::default();
//!
//! // You can configure optional parameters by calling the respective setters at will, and
//! // execute the final call using `doit()`.
//! // Values shown here are possibly random and not representative !
//! let result = hub.projects().groups_update(req, "name")
//! .doit().await;
//!
//! match result {
//! Err(e) => match e {
//! // The Error enum provides details about what exactly happened.
//! // You can also just use its `Debug`, `Display` or `Error` traits
//! Error::HttpError(_)
//! |Error::Io(_)
//! |Error::MissingAPIKey
//! |Error::MissingToken(_)
//! |Error::Cancelled
//! |Error::UploadSizeLimitExceeded(_, _)
//! |Error::Failure(_)
//! |Error::BadRequest(_)
//! |Error::FieldClash(_)
//! |Error::JsonDecodeError(_, _) => println!("{}", e),
//! },
//! Ok(res) => println!("Success: {:?}", res),
//! }
//! # }
//! ```
//! ## Handling Errors
//!
//! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of
//! the doit() methods, or handed as possibly intermediate results to either the
//! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html).
//!
//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This
//! makes the system potentially resilient to all kinds of errors.
//!
//! ## Uploads and Downloads
//! If a method supports downloads, the response body, which is part of the [Result](client::Result), should be
//! read by you to obtain the media.
//! If such a method also supports a [Response Result](client::ResponseResult), it will return that by default.
//! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making
//! this call: `.param("alt", "media")`.
//!
//! Methods supporting uploads can do so using up to 2 different protocols:
//! *simple* and *resumable*. The distinctiveness of each is represented by customized
//! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively.
//!
//! ## Customization and Callbacks
//!
//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the
//! [Method Builder](client::CallBuilder) before making the final `doit()` call.
//! Respective methods will be called to provide progress information, as well as determine whether the system should
//! retry on failure.
//!
//! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort.
//!
//! ## Optional Parts in Server-Requests
//!
//! All structures provided by this library are made to be [encodable](client::RequestValue) and
//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses
//! are valid.
//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to
//! the server to indicate either the set parts of the request or the desired parts in the response.
//!
//! ## Builder Arguments
//!
//! Using [method builders](client::CallBuilder), you are able to prepare an action call by repeatedly calling it's methods.
//! These will always take a single argument, for which the following statements are true.
//!
//! * [PODs][wiki-pod] are handed by copy
//! * strings are passed as `&str`
//! * [request values](client::RequestValue) are moved
//!
//! Arguments will always be copied or cloned into the builder, to make them independent of their original life times.
//!
//! [wiki-pod]: http://en.wikipedia.org/wiki/Plain_old_data_structure
//! [builder-pattern]: http://en.wikipedia.org/wiki/Builder_pattern
//! [google-go-api]: https://github.com/google/google-api-go-client
//!
//!
// Unused attributes happen thanks to defined, but unused structures
// We don't warn about this, as depending on the API, some data structures or facilities are never used.
// Instead of pre-determining this, we just disable the lint. It's manually tuned to not have any
// unused imports in fully featured APIs. Same with unused_mut ... .
#![allow(unused_imports, unused_mut, dead_code)]
// DO NOT EDIT !
// This file was generated automatically from 'src/generator/templates/api/lib.rs.mako'
// DO NOT EDIT !
// Re-export the hyper and hyper_rustls crate, they are required to build the hub
pub use hyper;
pub use hyper_rustls;
pub extern crate google_apis_common as client;
pub use client::chrono;
pub mod api;
// Re-export the hub type and some basic client structs
pub use api::Clouderrorreporting;
pub use client::{Result, Error, Delegate, FieldMask};
// Re-export the yup_oauth2 crate, that is required to call some methods of the hub and the client
#[cfg(feature = "yup-oauth2")]
pub use client::oauth2;