gcp-lite-rs 0.1.1

//! Types for the Cloud Scheduler API (v1).
//!
//! Auto-generated from the GCP Discovery Document.
//! **Do not edit manually** — modify the manifest and re-run codegen.
//!
//! Discovery document: `https://www.googleapis.com/discovery/v1/apis/cloudscheduler/v1/rest`

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Possible values for `cloudscheduler.v1.Job.state`.
///
/// **GCP API**: `cloudscheduler.v1.Job.state`
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum JobState {
    /// Unspecified state.
    StateUnspecified,

    /// The job is executing normally.
    Enabled,

    /// The job is paused by the user. It will not execute. A user can intentionally pause the
    /// job using PauseJobRequest.
    Paused,

    /// The job is disabled by the system due to error. The user cannot directly set a job to be
    /// disabled.
    Disabled,

    /// The job state resulting from a failed CloudScheduler.UpdateJob operation. To recover a
    /// job from this state, retry CloudScheduler.UpdateJob until a successful response is
    /// received.
    UpdateFailed,

    /// Unknown or future value not yet represented.
    #[serde(other)]
    Unknown,
}

/// Possible values for `cloudscheduler.v1.HttpTarget.httpMethod`.
///
/// **GCP API**: `cloudscheduler.v1.HttpTarget.httpMethod`
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum HttpMethod {
    /// HTTP method unspecified. Defaults to POST.
    HttpMethodUnspecified,

    /// HTTP POST
    Post,

    /// HTTP GET
    Get,

    /// HTTP HEAD
    Head,

    /// HTTP PUT
    Put,

    /// HTTP DELETE
    Delete,

    /// HTTP PATCH
    Patch,

    /// HTTP OPTIONS
    Options,

    /// Unknown or future value not yet represented.
    #[serde(other)]
    Unknown,
}

/// Configuration for a job. The maximum allowed size for a job is 1MB.
///
/// **GCP API**: `cloudscheduler.v1.Job`
/// **Reference**: <https://cloud.google.com/scheduler/docs/reference/rest/v1/Job>
///
/// ## Coverage
/// 14 of 15 fields included.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Job {
    /// Optionally caller-specified in CreateJob, after which it becomes output only. The job
    /// name. For example: `projects/PROJECT_ID/locations/LOCATION_ID/jobs/JOB_ID`.
    /// * `PROJECT_ID` can contain letters ([A-Za-z]), numbers ([0-9]), hyphens (-), colons (:),
    ///   or periods (.). For more information, see [Identifying projects](/resource-
    ///   manager/docs/creating-managing-projects#identifying_projects)
    /// * `LOCATION_ID` is the canonical ID for the job's location. The list of available
    ///   locations can be obtained by calling
    ///   [locations.list](/scheduler/docs/reference/rest/v1/projects.locations/list). For more
    ///   information, see [Cloud Scheduler locations](/scheduler/docs/locations).
    /// * `JOB_ID` can contain only letters ([A-Za-z]), numbers ([0-9]), hyphens (-), or
    ///   underscores (_). The maximum length is 500 characters.
    ///
    /// *Output-only field.*
    pub name: String,

    /// Optionally caller-specified in CreateJob or UpdateJob. A human-readable description for
    /// the job. This string must not contain more than 500 characters.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,

    /// Required, except when used with UpdateJob. Describes the schedule on which the job will
    /// be executed. The schedule can be either of the following types:
    /// * [Crontab](https://en.wikipedia.org/wiki/Cron#Overview)
    /// * English-like [schedule](/scheduler/docs/configuring/cron-job-schedules) As a general
    ///   rule, execution `n + 1` of a job will not begin until execution `n` has finished.
    ///   Cloud Scheduler will never allow two simultaneously outstanding executions. For
    ///   example, this implies that if the `n+1`th execution is scheduled to run at 16:00 but
    ///   the `n`th execution takes until 16:15, the `n+1`th execution will not start until
    ///   `16:15`. A scheduled start time will be delayed if the previous execution has not
    ///   ended when its scheduled time occurs. If retry_count > 0 and a job attempt fails, the
    ///   job will be tried a total of retry_count times, with exponential backoff, until the
    ///   next scheduled start time. If retry_count is 0, a job attempt will not be retried if
    ///   it fails. Instead the Cloud Scheduler system will wait for the next scheduled
    ///   execution time. Setting retry_count to 0 does not prevent failed jobs from running
    ///   according to schedule after the failure.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub schedule: Option<String>,

    /// Specifies the time zone to be used in interpreting schedule. The value of this field
    /// must be a time zone name from the [tz
    /// database](http://en.wikipedia.org/wiki/Tz_database). Note that some time zones include a
    /// provision for daylight savings time. The rules for daylight saving time are determined
    /// by the chosen tz. For UTC use the string "utc". If a time zone is not specified, the
    /// default will be in UTC (also known as GMT).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub time_zone: Option<String>,

    /// Output only. State of the job.
    ///
    /// *Output-only field.*
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<JobState>,

    /// HTTP target.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub http_target: Option<HttpTarget>,

    /// Pub/Sub target.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pubsub_target: Option<PubsubTarget>,

    /// App Engine HTTP target.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_engine_http_target: Option<AppEngineHttpTarget>,

    /// Settings that determine the retry behavior.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retry_config: Option<RetryConfig>,

    /// The deadline for job attempts. If the request handler does not respond by this deadline
    /// then the request is cancelled and the attempt is marked as a `DEADLINE_EXCEEDED`
    /// failure. The failed attempt can be viewed in execution logs. Cloud Scheduler will retry
    /// the job according to the RetryConfig. The default and the allowed values depend on the
    /// type of target:
    /// * For HTTP targets, the default is 3 minutes. The deadline must be in the interval [15
    ///   seconds, 30 minutes].
    /// * For App Engine HTTP targets, 0 indicates that the request has the default deadline.
    ///   The default deadline depends on the scaling type of the service: 10 minutes for
    ///   standard apps with automatic scaling, 24 hours for standard apps with manual and basic
    ///   scaling, and 60 minutes for flex apps. If the request deadline is set, it must be in
    ///   the interval [15 seconds, 24 hours 15 seconds].
    /// * For Pub/Sub targets, this field is ignored.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub attempt_deadline: Option<String>,

    /// Output only. The time the last job attempt started.
    ///
    /// *Output-only field.*
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_attempt_time: Option<String>,

    /// Output only. The next time the job is scheduled. Note that this may be a retry of a
    /// previously failed attempt or the next execution time according to the schedule.
    ///
    /// *Output-only field.*
    #[serde(skip_serializing_if = "Option::is_none")]
    pub schedule_time: Option<String>,

    /// Output only. The creation time of the job.
    ///
    /// *Output-only field.*
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_update_time: Option<String>,

    /// Output only. The response from the target for the last attempted execution.
    ///
    /// *Output-only field.*
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<JobStatus>,
}

impl Job {
    #[cfg(any(test, feature = "test-support"))]
    /// Create a fixture instance for testing.
    pub fn fixture() -> Self {
        Self {
            name: "test-job".into(),
            description: Some("test-description".into()),
            schedule: Some("test-schedule".into()),
            time_zone: Some("test-time_zone".into()),
            state: Some(JobState::StateUnspecified),
            http_target: Some(HttpTarget::fixture()),
            pubsub_target: Some(PubsubTarget::fixture()),
            app_engine_http_target: Some(AppEngineHttpTarget::fixture()),
            retry_config: Some(RetryConfig::fixture()),
            attempt_deadline: Some("test-attempt_deadline".into()),
            last_attempt_time: Some("test-last_attempt_time".into()),
            schedule_time: Some("test-schedule_time".into()),
            user_update_time: Some("test-user_update_time".into()),
            status: Some(JobStatus::fixture()),
        }
    }
}

/// Http target. The job will be pushed to the job handler by means of an HTTP request via an
/// http_method such as HTTP POST, HTTP GET, etc. The job is acknowledged by means of an HTTP
/// response code in the range [200 - 299]. A failure to receive a response constitutes a failed
/// execution. For a redirected request, the response returned by the redirected request is
/// considered.
///
/// **GCP API**: `cloudscheduler.v1.HttpTarget`
/// **Reference**: <https://cloud.google.com/scheduler/docs/reference/rest/v1/HttpTarget>
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HttpTarget {
    /// Required. The full URI path that the request will be sent to. This string must begin
    /// with either "http://" or "https://". Some examples of valid values for uri are:
    /// `http://acme.com` and `https://acme.com/sales:8080`. Cloud Scheduler will encode some
    /// characters for safety and compatibility. The maximum allowed URL length is 2083
    /// characters after encoding.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,

    /// Which HTTP method to use for the request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub http_method: Option<HttpMethod>,

    /// HTTP request headers. This map contains the header field names and values. The user can
    /// specify HTTP request headers to send with the job's HTTP request. Repeated headers are
    /// not supported, but a header value can contain commas. The following headers represent a
    /// subset of the headers that accompany the job's HTTP request. Some HTTP request headers
    /// are ignored or replaced. A partial list of headers that are ignored or replaced is
    /// below:
    /// * Host: This will be computed by Cloud Scheduler and derived from uri.
    /// * `Content-Length`: This will be computed by Cloud Scheduler.
    /// * `User-Agent`: This will be set to `"Google-Cloud-Scheduler"`.
    /// * `X-Google-*`: Google internal use only.
    /// * `X-AppEngine-*`: Google internal use only.
    /// * `X-CloudScheduler`: This header will be set to true.
    /// * `X-CloudScheduler-JobName`: This header will contain the job name.
    /// * `X-CloudScheduler-ScheduleTime`: For Cloud Scheduler jobs specified in the unix-cron
    ///   format, this header will contain the job schedule as an offset of UTC parsed according
    ///   to RFC3339. If the job has a body and the following headers are not set by the user,
    ///   Cloud Scheduler sets default values:
    /// * `Content-Type`: This will be set to `"application/octet-stream"`. You can override
    ///   this default by explicitly setting `Content-Type` to a particular media type when
    ///   creating the job. For example, you can set `Content-Type` to `"application/json"`. The
    ///   total size of headers must be less than 80KB.
    #[serde(default)]
    #[serde(skip_serializing_if = "HashMap::is_empty")]
    pub headers: HashMap<String, String>,

    /// HTTP request body. A request body is allowed only if the HTTP method is POST, PUT, or
    /// PATCH. It is an error to set body on a job with an incompatible HttpMethod.
    ///
    /// *Wire format: base64-encoded. Serde handles encoding/decoding automatically.*
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::serde_base64::serialize_base64_opt",
        deserialize_with = "crate::serde_base64::deserialize_base64_opt"
    )]
    pub body: Option<String>,

    /// If specified, an [OAuth token](https://developers.google.com/identity/protocols/OAuth2)
    /// will be generated and attached as an `Authorization` header in the HTTP request. This
    /// type of authorization should generally only be used when calling Google APIs hosted on
    /// *.googleapis.com.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub oauth_token: Option<OAuthToken>,

    /// If specified, an [OIDC](https://developers.google.com/identity/protocols/OpenIDConnect)
    /// token will be generated and attached as an `Authorization` header in the HTTP request.
    /// This type of authorization can be used for many scenarios, including calling Cloud Run,
    /// or endpoints where you intend to validate the token yourself.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub oidc_token: Option<OidcToken>,
}

impl HttpTarget {
    #[cfg(any(test, feature = "test-support"))]
    /// Create a fixture instance for testing.
    pub fn fixture() -> Self {
        Self {
            uri: Some("test-uri".into()),
            http_method: Some(HttpMethod::HttpMethodUnspecified),
            headers: Default::default(),
            body: Some("test-body".into()),
            oauth_token: Some(OAuthToken::fixture()),
            oidc_token: Some(OidcToken::fixture()),
        }
    }
}

/// Contains information needed for generating an [OAuth
/// token](https://developers.google.com/identity/protocols/OAuth2). This type of authorization
/// should generally only be used when calling Google APIs hosted on *.googleapis.com.
///
/// **GCP API**: `cloudscheduler.v1.OAuthToken`
/// **Reference**: <https://cloud.google.com/scheduler/docs/reference/rest/v1/OAuthToken>
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OAuthToken {
    /// [Service account email](https://cloud.google.com/iam/docs/service-accounts) to be used
    /// for generating OAuth token. The service account must be within the same project as the
    /// job. The caller must have iam.serviceAccounts.actAs permission for the service account.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_account_email: Option<String>,

    /// OAuth scope to be used for generating OAuth access token. If not specified,
    /// "https://www.googleapis.com/auth/cloud-platform" will be used.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scope: Option<String>,
}

impl OAuthToken {
    #[cfg(any(test, feature = "test-support"))]
    /// Create a fixture instance for testing.
    pub fn fixture() -> Self {
        Self {
            service_account_email: Some("test-service_account_email".into()),
            scope: Some("test-scope".into()),
        }
    }
}

/// Contains information needed for generating an [OpenID Connect
/// token](https://developers.google.com/identity/protocols/OpenIDConnect). This type of
/// authorization can be used for many scenarios, including calling Cloud Run, or endpoints
/// where you intend to validate the token yourself.
///
/// **GCP API**: `cloudscheduler.v1.OidcToken`
/// **Reference**: <https://cloud.google.com/scheduler/docs/reference/rest/v1/OidcToken>
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OidcToken {
    /// [Service account email](https://cloud.google.com/iam/docs/service-accounts) to be used
    /// for generating OIDC token. The service account must be within the same project as the
    /// job. The caller must have iam.serviceAccounts.actAs permission for the service account.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_account_email: Option<String>,

    /// Audience to be used when generating OIDC token. If not specified, the URI specified in
    /// target will be used.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub audience: Option<String>,
}

impl OidcToken {
    #[cfg(any(test, feature = "test-support"))]
    /// Create a fixture instance for testing.
    pub fn fixture() -> Self {
        Self {
            service_account_email: Some("test-service_account_email".into()),
            audience: Some("test-audience".into()),
        }
    }
}

/// Pub/Sub target. The job will be delivered by publishing a message to the given Pub/Sub
/// topic.
///
/// **GCP API**: `cloudscheduler.v1.PubsubTarget`
/// **Reference**: <https://cloud.google.com/scheduler/docs/reference/rest/v1/PubsubTarget>
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PubsubTarget {
    /// Required. The name of the Cloud Pub/Sub topic to which messages will be published when a
    /// job is delivered. The topic name must be in the same format as required by Pub/Sub's [Pu
    /// blishRequest.name](https://cloud.google.com/pubsub/docs/reference/rpc/google.pubsub.v1#p
    /// ublishrequest), for example `projects/PROJECT_ID/topics/TOPIC_ID`. The topic must be in
    /// the same project as the Cloud Scheduler job.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub topic_name: Option<String>,

    /// The message payload for PubsubMessage. Pubsub message must contain either non-empty
    /// data, or at least one attribute.
    ///
    /// *Wire format: base64-encoded. Serde handles encoding/decoding automatically.*
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::serde_base64::serialize_base64_opt",
        deserialize_with = "crate::serde_base64::deserialize_base64_opt"
    )]
    pub data: Option<String>,

    /// Attributes for PubsubMessage. Pubsub message must contain either non-empty data, or at
    /// least one attribute.
    #[serde(default)]
    #[serde(skip_serializing_if = "HashMap::is_empty")]
    pub attributes: HashMap<String, String>,
}

impl PubsubTarget {
    #[cfg(any(test, feature = "test-support"))]
    /// Create a fixture instance for testing.
    pub fn fixture() -> Self {
        Self {
            topic_name: Some("test-topic_name".into()),
            data: Some("test-data".into()),
            attributes: Default::default(),
        }
    }
}

/// App Engine target. The job will be pushed to a job handler by means of an HTTP request via
/// an http_method such as HTTP POST, HTTP GET, etc. The job is acknowledged by means of an HTTP
/// response code in the range [200 - 299]. Error 503 is considered an App Engine system error
/// instead of an application error. Requests returning error 503 will be retried regardless of
/// retry configuration and not counted against retry counts. Any other response code, or a
/// failure to receive a response before the deadline, constitutes a failed attempt.
///
/// **GCP API**: `cloudscheduler.v1.AppEngineHttpTarget`
/// **Reference**: <https://cloud.google.com/scheduler/docs/reference/rest/v1/AppEngineHttpTarget>
///
/// ## Coverage
/// 4 of 5 fields included.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppEngineHttpTarget {
    /// App Engine Routing setting for the job.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_engine_routing: Option<AppEngineRouting>,

    /// The relative URI. The relative URL must begin with "/" and must be a valid HTTP relative
    /// URL. It can contain a path, query string arguments, and `#` fragments. If the relative
    /// URL is empty, then the root path "/" will be used. No spaces are allowed, and the
    /// maximum length allowed is 2083 characters.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub relative_uri: Option<String>,

    /// HTTP request headers. This map contains the header field names and values. Headers can
    /// be set when the job is created. Cloud Scheduler sets some headers to default values:
    /// * `User-Agent`: By default, this header is `"AppEngine-Google;
    ///   (+http://code.google.com/appengine)"`. This header can be modified, but Cloud
    ///   Scheduler will append `"AppEngine-Google; (+http://code.google.com/appengine)"` to the
    ///   modified `User-Agent`.
    /// * `X-CloudScheduler`: This header will be set to true.
    /// * `X-CloudScheduler-JobName`: This header will contain the job name.
    /// * `X-CloudScheduler-ScheduleTime`: For Cloud Scheduler jobs specified in the unix-cron
    ///   format, this header will contain the job schedule as an offset of UTC parsed according
    ///   to RFC3339. If the job has a body and the following headers are not set by the user,
    ///   Cloud Scheduler sets default values:
    /// * `Content-Type`: This will be set to `"application/octet-stream"`. You can override
    ///   this default by explicitly setting `Content-Type` to a particular media type when
    ///   creating the job. For example, you can set `Content-Type` to `"application/json"`. The
    ///   headers below are output only. They cannot be set or overridden:
    /// * `Content-Length`: This is computed by Cloud Scheduler.
    /// * `X-Google-*`: For Google internal use only.
    /// * `X-AppEngine-*`: For Google internal use only. In addition, some App Engine headers,
    ///   which contain job-specific information, are also be sent to the job handler.
    ///
    /// *Output-only field.*
    #[serde(default)]
    #[serde(skip_serializing_if = "HashMap::is_empty")]
    pub headers: HashMap<String, String>,

    /// Body. HTTP request body. A request body is allowed only if the HTTP method is POST or
    /// PUT. It will result in invalid argument error to set a body on a job with an
    /// incompatible HttpMethod.
    ///
    /// *Wire format: base64-encoded. Serde handles encoding/decoding automatically.*
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::serde_base64::serialize_base64_opt",
        deserialize_with = "crate::serde_base64::deserialize_base64_opt"
    )]
    pub body: Option<String>,
}

impl AppEngineHttpTarget {
    #[cfg(any(test, feature = "test-support"))]
    /// Create a fixture instance for testing.
    pub fn fixture() -> Self {
        Self {
            app_engine_routing: Some(AppEngineRouting::fixture()),
            relative_uri: Some("test-relative_uri".into()),
            headers: Default::default(),
            body: Some("test-body".into()),
        }
    }
}

/// App Engine Routing. For more information about services, versions, and instances see [An
/// Overview of App Engine](https://cloud.google.com/appengine/docs/python/an-overview-of-app-
/// engine), [Microservices Architecture on Google App
/// Engine](https://cloud.google.com/appengine/docs/python/microservices-on-app-engine), [App
/// Engine Standard request
/// routing](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed),
/// and [App Engine Flex request
/// routing](https://cloud.google.com/appengine/docs/flexible/python/how-requests-are-routed).
///
/// **GCP API**: `cloudscheduler.v1.AppEngineRouting`
/// **Reference**: <https://cloud.google.com/scheduler/docs/reference/rest/v1/AppEngineRouting>
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppEngineRouting {
    /// App service. By default, the job is sent to the service which is the default service
    /// when the job is attempted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service: Option<String>,

    /// App version. By default, the job is sent to the version which is the default version
    /// when the job is attempted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,

    /// App instance. By default, the job is sent to an instance which is available when the job
    /// is attempted. Requests can only be sent to a specific instance if [manual scaling is
    /// used in App Engine Standard](https://cloud.google.com/appengine/docs/python/an-overview-
    /// of-app-engine?#scaling_types_and_instance_classes). App Engine Flex does not support
    /// instances. For more information, see [App Engine Standard request
    /// routing](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-
    /// routed) and [App Engine Flex request
    /// routing](https://cloud.google.com/appengine/docs/flexible/python/how-requests-are-
    /// routed).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub instance: Option<String>,

    /// Output only. The host that the job is sent to. For more information about how App Engine
    /// requests are routed, see
    /// [here](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed).
    /// The host is constructed as:
    /// * `host = [application_domain_name]` `| [service] + '.' + [application_domain_name]` `|
    ///   [version] + '.' + [application_domain_name]` `| [version_dot_service]+ '.' +
    ///   [application_domain_name]` `| [instance] + '.' + [application_domain_name]` `|
    ///   [instance_dot_service] + '.' + [application_domain_name]` `| [instance_dot_version] +
    ///   '.' + [application_domain_name]` `| [instance_dot_version_dot_service] + '.' +
    ///   [application_domain_name]`
    /// * `application_domain_name` = The domain name of the app, for example .appspot.com,
    ///   which is associated with the job's project ID.
    /// * `service =` service
    /// * `version =` version
    /// * `version_dot_service =` version `+ '.' +` service
    /// * `instance =` instance
    /// * `instance_dot_service =` instance `+ '.' +` service
    /// * `instance_dot_version =` instance `+ '.' +` version
    /// * `instance_dot_version_dot_service =` instance `+ '.' +` version `+ '.' +` service If
    ///   service is empty, then the job will be sent to the service which is the default
    ///   service when the job is attempted. If version is empty, then the job will be sent to
    ///   the version which is the default version when the job is attempted. If instance is
    ///   empty, then the job will be sent to an instance which is available when the job is
    ///   attempted. If service, version, or instance is invalid, then the job will be sent to
    ///   the default version of the default service when the job is attempted.
    ///
    /// *Output-only field.*
    #[serde(skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
}

impl AppEngineRouting {
    #[cfg(any(test, feature = "test-support"))]
    /// Create a fixture instance for testing.
    pub fn fixture() -> Self {
        Self {
            service: Some("test-service".into()),
            version: Some("test-version".into()),
            instance: Some("test-instance".into()),
            host: Some("test-host".into()),
        }
    }
}

/// Settings that determine the retry behavior. For more information, see [Retry
/// jobs](/scheduler/docs/configuring/retry-jobs). By default, if a job does not complete
/// successfully (meaning that an acknowledgement is not received from the handler, then it will
/// be retried with exponential backoff according to the settings in RetryConfig.
///
/// **GCP API**: `cloudscheduler.v1.RetryConfig`
/// **Reference**: <https://cloud.google.com/scheduler/docs/reference/rest/v1/RetryConfig>
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RetryConfig {
    /// The number of attempts that the system will make to run a job using the exponential
    /// backoff procedure described by max_doublings. The default value of retry_count is zero.
    /// If retry_count is 0 (and if max_retry_duration is also 0), a job attempt won't be
    /// retried if it fails. Instead, Cloud Scheduler system will wait for the next scheduled
    /// execution time. Setting retry_count to 0 doesn't prevent failed jobs from running
    /// according to schedule after the failure. If retry_count is set to a non-zero number,
    /// Cloud Scheduler will retry the failed job, using exponential backoff, for retry_count
    /// times until the job succeeds or the number of retries is exhausted. Note that the next
    /// scheduled execution time might be skipped if the retries continue through that time.
    /// Values greater than 5 and negative values are not allowed.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retry_count: Option<i32>,

    /// The time limit for retrying a failed job, measured from the time when an execution was
    /// first attempted. If specified with retry_count, the job will be retried until both
    /// limits are reached. The default value for max_retry_duration is zero, which means retry
    /// duration is unlimited. However, if retry_count is also 0, a job attempt won't be retried
    /// if it fails.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_retry_duration: Option<String>,

    /// The minimum amount of time to wait before retrying a job after it fails. The default
    /// value of this field is 5 seconds.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub min_backoff_duration: Option<String>,

    /// The maximum amount of time to wait before retrying a job after it fails. The default
    /// value of this field is 1 hour.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_backoff_duration: Option<String>,

    /// The time between retries will double `max_doublings` times. A job's retry interval
    /// starts at min_backoff_duration, then doubles `max_doublings` times, then increases
    /// linearly, and finally retries at intervals of max_backoff_duration up to retry_count
    /// times. For examples, see [Retry jobs](/scheduler/docs/configuring/retry-jobs#max-
    /// doublings). The default value of this field is 5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_doublings: Option<i32>,
}

impl RetryConfig {
    #[cfg(any(test, feature = "test-support"))]
    /// Create a fixture instance for testing.
    pub fn fixture() -> Self {
        Self {
            retry_count: Some(100),
            max_retry_duration: Some("test-max_retry_duration".into()),
            min_backoff_duration: Some("test-min_backoff_duration".into()),
            max_backoff_duration: Some("test-max_backoff_duration".into()),
            max_doublings: Some(100),
        }
    }
}

/// The `Status` type defines a logical error model that is suitable for different programming
/// environments, including REST APIs and RPC APIs. It is used by
/// [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error
/// code, error message, and error details. You can find out more about this error model and how
/// to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).
///
/// **GCP API**: `cloudscheduler.v1.Status`
/// **Reference**: <https://cloud.google.com/scheduler/docs/reference/rest/v1/Status>
///
/// ## Coverage
/// 2 of 3 fields included.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct JobStatus {
    /// The status code, which should be an enum value of google.rpc.Code.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub code: Option<i32>,

    /// A developer-facing error message, which should be in English. Any user-facing error
    /// message should be localized and sent in the google.rpc.Status.details field, or
    /// localized by the client.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

impl JobStatus {
    #[cfg(any(test, feature = "test-support"))]
    /// Create a fixture instance for testing.
    pub fn fixture() -> Self {
        Self {
            code: Some(100),
            message: Some("test-message".into()),
        }
    }
}

/// A generic empty message that you can re-use to avoid defining duplicated empty messages in
/// your APIs. A typical example is to use it as the request or the response type of an API
/// method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns
/// (google.protobuf.Empty); }
///
/// **GCP API**: `cloudscheduler.v1.Empty`
/// **Reference**: <https://cloud.google.com/scheduler/docs/reference/rest/v1/Empty>
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SchedulerEmpty {}

impl SchedulerEmpty {
    #[cfg(any(test, feature = "test-support"))]
    /// Create a fixture instance for testing.
    pub fn fixture() -> Self {
        Self {}
    }
}

/// Request message for PauseJob.
///
/// **GCP API**: `cloudscheduler.v1.PauseJobRequest`
/// **Reference**: <https://cloud.google.com/scheduler/docs/reference/rest/v1/PauseJobRequest>
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PauseJobRequest {}

impl PauseJobRequest {
    #[cfg(any(test, feature = "test-support"))]
    /// Create a fixture instance for testing.
    pub fn fixture() -> Self {
        Self {}
    }
}

/// Request message for ResumeJob.
///
/// **GCP API**: `cloudscheduler.v1.ResumeJobRequest`
/// **Reference**: <https://cloud.google.com/scheduler/docs/reference/rest/v1/ResumeJobRequest>
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ResumeJobRequest {}

impl ResumeJobRequest {
    #[cfg(any(test, feature = "test-support"))]
    /// Create a fixture instance for testing.
    pub fn fixture() -> Self {
        Self {}
    }
}

/// Request message for forcing a job to run now using RunJob.
///
/// **GCP API**: `cloudscheduler.v1.RunJobRequest`
/// **Reference**: <https://cloud.google.com/scheduler/docs/reference/rest/v1/RunJobRequest>
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RunJobRequest {}

impl RunJobRequest {
    #[cfg(any(test, feature = "test-support"))]
    /// Create a fixture instance for testing.
    pub fn fixture() -> Self {
        Self {}
    }
}

// ======================================================================
// List response types (generated from operation list_response)
// ======================================================================

/// Response for listing Job resources.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ListJobsResponse {
    /// A list of Job resources.
    #[serde(default)]
    pub jobs: Vec<Job>,

    /// Token for the next page of results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_page_token: Option<String>,
}

impl ListJobsResponse {
    #[cfg(any(test, feature = "test-support"))]
    /// Create a fixture instance for testing.
    pub fn fixture() -> Self {
        Self {
            jobs: vec![],
            next_page_token: None,
        }
    }
}