make regen-apis

2026-02-23 15:49:49 +01:00 · 2024-05-16 21:23:40 +02:00
parent 92ad312680
commit ba42c83516
5108 changed files with 1615625 additions and 992044 deletions
--- a/gen/transcoder1/src/api/call_builders.rs
+++ b/gen/transcoder1/src/api/call_builders.rs
--- a/gen/transcoder1/src/api/enums.rs
+++ b/gen/transcoder1/src/api/enums.rs
@@ -0,0 +1,553 @@
+use super::*;
+
+
+
+// region AnimationFadeFadeTypeEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Required. Type of fade animation: `FADE_IN` or `FADE_OUT`.
+pub enum AnimationFadeFadeTypeEnum {
+    
+
+    /// The fade type is not specified.
+    ///
+    /// "FADE_TYPE_UNSPECIFIED"
+    #[serde(rename="FADE_TYPE_UNSPECIFIED")]
+    FADETYPEUNSPECIFIED,
+    
+
+    /// Fade the overlay object into view.
+    ///
+    /// "FADE_IN"
+    #[serde(rename="FADE_IN")]
+    FADEIN,
+    
+
+    /// Fade the overlay object out of view.
+    ///
+    /// "FADE_OUT"
+    #[serde(rename="FADE_OUT")]
+    FADEOUT,
+}
+
+impl AsRef<str> for AnimationFadeFadeTypeEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            AnimationFadeFadeTypeEnum::FADETYPEUNSPECIFIED => "FADE_TYPE_UNSPECIFIED",
+            AnimationFadeFadeTypeEnum::FADEIN => "FADE_IN",
+            AnimationFadeFadeTypeEnum::FADEOUT => "FADE_OUT",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for AnimationFadeFadeTypeEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "FADE_TYPE_UNSPECIFIED" => Ok(AnimationFadeFadeTypeEnum::FADETYPEUNSPECIFIED),
+           "FADE_IN" => Ok(AnimationFadeFadeTypeEnum::FADEIN),
+           "FADE_OUT" => Ok(AnimationFadeFadeTypeEnum::FADEOUT),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a AnimationFadeFadeTypeEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region DashConfigSegmentReferenceSchemeEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The segment reference scheme for a `DASH` manifest. The default is `SEGMENT_LIST`.
+pub enum DashConfigSegmentReferenceSchemeEnum {
+    
+
+    /// The segment reference scheme is not specified.
+    ///
+    /// "SEGMENT_REFERENCE_SCHEME_UNSPECIFIED"
+    #[serde(rename="SEGMENT_REFERENCE_SCHEME_UNSPECIFIED")]
+    SEGMENTREFERENCESCHEMEUNSPECIFIED,
+    
+
+    /// Explicitly lists the URLs of media files for each segment. For example, if SegmentSettings.individual_segments is `true`, then the manifest contains fields similar to the following: ```xml ... ```
+    ///
+    /// "SEGMENT_LIST"
+    #[serde(rename="SEGMENT_LIST")]
+    SEGMENTLIST,
+    
+
+    /// SegmentSettings.individual_segments must be set to `true` to use this segment reference scheme. Uses the DASH specification `` tag to determine the URLs of media files for each segment. For example: ```xml ... ```
+    ///
+    /// "SEGMENT_TEMPLATE_NUMBER"
+    #[serde(rename="SEGMENT_TEMPLATE_NUMBER")]
+    SEGMENTTEMPLATENUMBER,
+}
+
+impl AsRef<str> for DashConfigSegmentReferenceSchemeEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            DashConfigSegmentReferenceSchemeEnum::SEGMENTREFERENCESCHEMEUNSPECIFIED => "SEGMENT_REFERENCE_SCHEME_UNSPECIFIED",
+            DashConfigSegmentReferenceSchemeEnum::SEGMENTLIST => "SEGMENT_LIST",
+            DashConfigSegmentReferenceSchemeEnum::SEGMENTTEMPLATENUMBER => "SEGMENT_TEMPLATE_NUMBER",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for DashConfigSegmentReferenceSchemeEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "SEGMENT_REFERENCE_SCHEME_UNSPECIFIED" => Ok(DashConfigSegmentReferenceSchemeEnum::SEGMENTREFERENCESCHEMEUNSPECIFIED),
+           "SEGMENT_LIST" => Ok(DashConfigSegmentReferenceSchemeEnum::SEGMENTLIST),
+           "SEGMENT_TEMPLATE_NUMBER" => Ok(DashConfigSegmentReferenceSchemeEnum::SEGMENTTEMPLATENUMBER),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a DashConfigSegmentReferenceSchemeEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region H264CodecSettingFrameRateConversionStrategyEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Optional. Frame rate conversion strategy for desired frame rate. The default is `DOWNSAMPLE`.
+pub enum H264CodecSettingFrameRateConversionStrategyEnum {
+    
+
+    /// Unspecified frame rate conversion strategy.
+    ///
+    /// "FRAME_RATE_CONVERSION_STRATEGY_UNSPECIFIED"
+    #[serde(rename="FRAME_RATE_CONVERSION_STRATEGY_UNSPECIFIED")]
+    FRAMERATECONVERSIONSTRATEGYUNSPECIFIED,
+    
+
+    /// Selectively retain frames to reduce the output frame rate. Every _n_ th frame is kept, where `n = ceil(input frame rate / target frame rate)`. When _n_ = 1 (that is, the target frame rate is greater than the input frame rate), the output frame rate matches the input frame rate. When _n_ > 1, frames are dropped and the output frame rate is equal to `(input frame rate / n)`. For more information, see [Calculate frame rate](https://cloud.google.com/transcoder/docs/concepts/frame-rate).
+    ///
+    /// "DOWNSAMPLE"
+    #[serde(rename="DOWNSAMPLE")]
+    DOWNSAMPLE,
+    
+
+    /// Drop or duplicate frames to match the specified frame rate.
+    ///
+    /// "DROP_DUPLICATE"
+    #[serde(rename="DROP_DUPLICATE")]
+    DROPDUPLICATE,
+}
+
+impl AsRef<str> for H264CodecSettingFrameRateConversionStrategyEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            H264CodecSettingFrameRateConversionStrategyEnum::FRAMERATECONVERSIONSTRATEGYUNSPECIFIED => "FRAME_RATE_CONVERSION_STRATEGY_UNSPECIFIED",
+            H264CodecSettingFrameRateConversionStrategyEnum::DOWNSAMPLE => "DOWNSAMPLE",
+            H264CodecSettingFrameRateConversionStrategyEnum::DROPDUPLICATE => "DROP_DUPLICATE",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for H264CodecSettingFrameRateConversionStrategyEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "FRAME_RATE_CONVERSION_STRATEGY_UNSPECIFIED" => Ok(H264CodecSettingFrameRateConversionStrategyEnum::FRAMERATECONVERSIONSTRATEGYUNSPECIFIED),
+           "DOWNSAMPLE" => Ok(H264CodecSettingFrameRateConversionStrategyEnum::DOWNSAMPLE),
+           "DROP_DUPLICATE" => Ok(H264CodecSettingFrameRateConversionStrategyEnum::DROPDUPLICATE),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a H264CodecSettingFrameRateConversionStrategyEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region H265CodecSettingFrameRateConversionStrategyEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Optional. Frame rate conversion strategy for desired frame rate. The default is `DOWNSAMPLE`.
+pub enum H265CodecSettingFrameRateConversionStrategyEnum {
+    
+
+    /// Unspecified frame rate conversion strategy.
+    ///
+    /// "FRAME_RATE_CONVERSION_STRATEGY_UNSPECIFIED"
+    #[serde(rename="FRAME_RATE_CONVERSION_STRATEGY_UNSPECIFIED")]
+    FRAMERATECONVERSIONSTRATEGYUNSPECIFIED,
+    
+
+    /// Selectively retain frames to reduce the output frame rate. Every _n_ th frame is kept, where `n = ceil(input frame rate / target frame rate)`. When _n_ = 1 (that is, the target frame rate is greater than the input frame rate), the output frame rate matches the input frame rate. When _n_ > 1, frames are dropped and the output frame rate is equal to `(input frame rate / n)`. For more information, see [Calculate frame rate](https://cloud.google.com/transcoder/docs/concepts/frame-rate).
+    ///
+    /// "DOWNSAMPLE"
+    #[serde(rename="DOWNSAMPLE")]
+    DOWNSAMPLE,
+    
+
+    /// Drop or duplicate frames to match the specified frame rate.
+    ///
+    /// "DROP_DUPLICATE"
+    #[serde(rename="DROP_DUPLICATE")]
+    DROPDUPLICATE,
+}
+
+impl AsRef<str> for H265CodecSettingFrameRateConversionStrategyEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            H265CodecSettingFrameRateConversionStrategyEnum::FRAMERATECONVERSIONSTRATEGYUNSPECIFIED => "FRAME_RATE_CONVERSION_STRATEGY_UNSPECIFIED",
+            H265CodecSettingFrameRateConversionStrategyEnum::DOWNSAMPLE => "DOWNSAMPLE",
+            H265CodecSettingFrameRateConversionStrategyEnum::DROPDUPLICATE => "DROP_DUPLICATE",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for H265CodecSettingFrameRateConversionStrategyEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "FRAME_RATE_CONVERSION_STRATEGY_UNSPECIFIED" => Ok(H265CodecSettingFrameRateConversionStrategyEnum::FRAMERATECONVERSIONSTRATEGYUNSPECIFIED),
+           "DOWNSAMPLE" => Ok(H265CodecSettingFrameRateConversionStrategyEnum::DOWNSAMPLE),
+           "DROP_DUPLICATE" => Ok(H265CodecSettingFrameRateConversionStrategyEnum::DROPDUPLICATE),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a H265CodecSettingFrameRateConversionStrategyEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region JobModeEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// The processing mode of the job. The default is `PROCESSING_MODE_INTERACTIVE`.
+pub enum JobModeEnum {
+    
+
+    /// The job processing mode is not specified.
+    ///
+    /// "PROCESSING_MODE_UNSPECIFIED"
+    #[serde(rename="PROCESSING_MODE_UNSPECIFIED")]
+    PROCESSINGMODEUNSPECIFIED,
+    
+
+    /// The job processing mode is interactive mode. Interactive job will either be ran or rejected if quota does not allow for it.
+    ///
+    /// "PROCESSING_MODE_INTERACTIVE"
+    #[serde(rename="PROCESSING_MODE_INTERACTIVE")]
+    PROCESSINGMODEINTERACTIVE,
+    
+
+    /// The job processing mode is batch mode. Batch mode allows queuing of jobs.
+    ///
+    /// "PROCESSING_MODE_BATCH"
+    #[serde(rename="PROCESSING_MODE_BATCH")]
+    PROCESSINGMODEBATCH,
+}
+
+impl AsRef<str> for JobModeEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            JobModeEnum::PROCESSINGMODEUNSPECIFIED => "PROCESSING_MODE_UNSPECIFIED",
+            JobModeEnum::PROCESSINGMODEINTERACTIVE => "PROCESSING_MODE_INTERACTIVE",
+            JobModeEnum::PROCESSINGMODEBATCH => "PROCESSING_MODE_BATCH",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for JobModeEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "PROCESSING_MODE_UNSPECIFIED" => Ok(JobModeEnum::PROCESSINGMODEUNSPECIFIED),
+           "PROCESSING_MODE_INTERACTIVE" => Ok(JobModeEnum::PROCESSINGMODEINTERACTIVE),
+           "PROCESSING_MODE_BATCH" => Ok(JobModeEnum::PROCESSINGMODEBATCH),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a JobModeEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region JobOptimizationEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Optional. The optimization strategy of the job. The default is `AUTODETECT`.
+pub enum JobOptimizationEnum {
+    
+
+    /// The optimization strategy is not specified.
+    ///
+    /// "OPTIMIZATION_STRATEGY_UNSPECIFIED"
+    #[serde(rename="OPTIMIZATION_STRATEGY_UNSPECIFIED")]
+    OPTIMIZATIONSTRATEGYUNSPECIFIED,
+    
+
+    /// Prioritize job processing speed.
+    ///
+    /// "AUTODETECT"
+    #[serde(rename="AUTODETECT")]
+    AUTODETECT,
+    
+
+    /// Disable all optimizations.
+    ///
+    /// "DISABLED"
+    #[serde(rename="DISABLED")]
+    DISABLED,
+}
+
+impl AsRef<str> for JobOptimizationEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            JobOptimizationEnum::OPTIMIZATIONSTRATEGYUNSPECIFIED => "OPTIMIZATION_STRATEGY_UNSPECIFIED",
+            JobOptimizationEnum::AUTODETECT => "AUTODETECT",
+            JobOptimizationEnum::DISABLED => "DISABLED",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for JobOptimizationEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "OPTIMIZATION_STRATEGY_UNSPECIFIED" => Ok(JobOptimizationEnum::OPTIMIZATIONSTRATEGYUNSPECIFIED),
+           "AUTODETECT" => Ok(JobOptimizationEnum::AUTODETECT),
+           "DISABLED" => Ok(JobOptimizationEnum::DISABLED),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a JobOptimizationEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region JobStateEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Output only. The current state of the job.
+pub enum JobStateEnum {
+    
+
+    /// The processing state is not specified.
+    ///
+    /// "PROCESSING_STATE_UNSPECIFIED"
+    #[serde(rename="PROCESSING_STATE_UNSPECIFIED")]
+    PROCESSINGSTATEUNSPECIFIED,
+    
+
+    /// The job is enqueued and will be picked up for processing soon.
+    ///
+    /// "PENDING"
+    #[serde(rename="PENDING")]
+    PENDING,
+    
+
+    /// The job is being processed.
+    ///
+    /// "RUNNING"
+    #[serde(rename="RUNNING")]
+    RUNNING,
+    
+
+    /// The job has been completed successfully.
+    ///
+    /// "SUCCEEDED"
+    #[serde(rename="SUCCEEDED")]
+    SUCCEEDED,
+    
+
+    /// The job has failed. For additional information, see [Troubleshooting](https://cloud.google.com/transcoder/docs/troubleshooting).
+    ///
+    /// "FAILED"
+    #[serde(rename="FAILED")]
+    FAILED,
+}
+
+impl AsRef<str> for JobStateEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            JobStateEnum::PROCESSINGSTATEUNSPECIFIED => "PROCESSING_STATE_UNSPECIFIED",
+            JobStateEnum::PENDING => "PENDING",
+            JobStateEnum::RUNNING => "RUNNING",
+            JobStateEnum::SUCCEEDED => "SUCCEEDED",
+            JobStateEnum::FAILED => "FAILED",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for JobStateEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "PROCESSING_STATE_UNSPECIFIED" => Ok(JobStateEnum::PROCESSINGSTATEUNSPECIFIED),
+           "PENDING" => Ok(JobStateEnum::PENDING),
+           "RUNNING" => Ok(JobStateEnum::RUNNING),
+           "SUCCEEDED" => Ok(JobStateEnum::SUCCEEDED),
+           "FAILED" => Ok(JobStateEnum::FAILED),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a JobStateEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region ManifestTypeEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Required. Type of the manifest.
+pub enum ManifestTypeEnum {
+    
+
+    /// The manifest type is not specified.
+    ///
+    /// "MANIFEST_TYPE_UNSPECIFIED"
+    #[serde(rename="MANIFEST_TYPE_UNSPECIFIED")]
+    MANIFESTTYPEUNSPECIFIED,
+    
+
+    /// Create an HLS manifest. The corresponding file extension is `.m3u8`.
+    ///
+    /// "HLS"
+    #[serde(rename="HLS")]
+    HLS,
+    
+
+    /// Create an MPEG-DASH manifest. The corresponding file extension is `.mpd`.
+    ///
+    /// "DASH"
+    #[serde(rename="DASH")]
+    DASH,
+}
+
+impl AsRef<str> for ManifestTypeEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            ManifestTypeEnum::MANIFESTTYPEUNSPECIFIED => "MANIFEST_TYPE_UNSPECIFIED",
+            ManifestTypeEnum::HLS => "HLS",
+            ManifestTypeEnum::DASH => "DASH",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for ManifestTypeEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "MANIFEST_TYPE_UNSPECIFIED" => Ok(ManifestTypeEnum::MANIFESTTYPEUNSPECIFIED),
+           "HLS" => Ok(ManifestTypeEnum::HLS),
+           "DASH" => Ok(ManifestTypeEnum::DASH),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a ManifestTypeEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
+// region Vp9CodecSettingFrameRateConversionStrategyEnum
+#[derive(Clone, Copy, Eq, Hash, Debug, PartialEq, Serialize, Deserialize)]
+/// Optional. Frame rate conversion strategy for desired frame rate. The default is `DOWNSAMPLE`.
+pub enum Vp9CodecSettingFrameRateConversionStrategyEnum {
+    
+
+    /// Unspecified frame rate conversion strategy.
+    ///
+    /// "FRAME_RATE_CONVERSION_STRATEGY_UNSPECIFIED"
+    #[serde(rename="FRAME_RATE_CONVERSION_STRATEGY_UNSPECIFIED")]
+    FRAMERATECONVERSIONSTRATEGYUNSPECIFIED,
+    
+
+    /// Selectively retain frames to reduce the output frame rate. Every _n_ th frame is kept, where `n = ceil(input frame rate / target frame rate)`. When _n_ = 1 (that is, the target frame rate is greater than the input frame rate), the output frame rate matches the input frame rate. When _n_ > 1, frames are dropped and the output frame rate is equal to `(input frame rate / n)`. For more information, see [Calculate frame rate](https://cloud.google.com/transcoder/docs/concepts/frame-rate).
+    ///
+    /// "DOWNSAMPLE"
+    #[serde(rename="DOWNSAMPLE")]
+    DOWNSAMPLE,
+    
+
+    /// Drop or duplicate frames to match the specified frame rate.
+    ///
+    /// "DROP_DUPLICATE"
+    #[serde(rename="DROP_DUPLICATE")]
+    DROPDUPLICATE,
+}
+
+impl AsRef<str> for Vp9CodecSettingFrameRateConversionStrategyEnum {
+    fn as_ref(&self) -> &str {
+        match *self {
+            Vp9CodecSettingFrameRateConversionStrategyEnum::FRAMERATECONVERSIONSTRATEGYUNSPECIFIED => "FRAME_RATE_CONVERSION_STRATEGY_UNSPECIFIED",
+            Vp9CodecSettingFrameRateConversionStrategyEnum::DOWNSAMPLE => "DOWNSAMPLE",
+            Vp9CodecSettingFrameRateConversionStrategyEnum::DROPDUPLICATE => "DROP_DUPLICATE",
+        }
+    }
+}
+
+impl std::convert::TryFrom< &str> for Vp9CodecSettingFrameRateConversionStrategyEnum {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+           "FRAME_RATE_CONVERSION_STRATEGY_UNSPECIFIED" => Ok(Vp9CodecSettingFrameRateConversionStrategyEnum::FRAMERATECONVERSIONSTRATEGYUNSPECIFIED),
+           "DOWNSAMPLE" => Ok(Vp9CodecSettingFrameRateConversionStrategyEnum::DOWNSAMPLE),
+           "DROP_DUPLICATE" => Ok(Vp9CodecSettingFrameRateConversionStrategyEnum::DROPDUPLICATE),
+            _=> Err(()),
+        }
+    }
+}
+
+impl<'a> Into<std::borrow::Cow<'a, str>> for &'a Vp9CodecSettingFrameRateConversionStrategyEnum {
+    fn into(self) -> std::borrow::Cow<'a, str> {
+        self.as_ref().into()
+    }
+}
+
+
+// endregion
+
+
--- a/gen/transcoder1/src/api/hub.rs
+++ b/gen/transcoder1/src/api/hub.rs
@@ -0,0 +1,113 @@
+use super::*;
+
+/// Central instance to access all Transcoder related resource activities
+///
+/// # Examples
+///
+/// Instantiate a new hub
+///
+/// ```test_harness,no_run
+/// extern crate hyper;
+/// extern crate hyper_rustls;
+/// extern crate google_transcoder1 as transcoder1;
+/// use transcoder1::api::Job;
+/// use transcoder1::{Result, Error};
+/// use transcoder1::api::enums::*;
+/// # async fn dox() {
+/// use std::default::Default;
+/// use transcoder1::{Transcoder, 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 = Transcoder::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().unwrap().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 = Job::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().locations_jobs_create(req, "parent")
+///              .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 Transcoder<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 Transcoder<S> {}
+
+impl<'a, S> Transcoder<S> {
+
+    pub fn new<A: 'static + client::GetToken>(client: hyper::Client<S, hyper::body::Body>, auth: A) -> Transcoder<S> {
+        Transcoder {
+            client,
+            auth: Box::new(auth),
+            _user_agent: "google-api-rust-client/5.0.5".to_string(),
+            _base_url: "https://transcoder.googleapis.com/".to_string(),
+            _root_url: "https://transcoder.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.5`.
+    ///
+    /// 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://transcoder.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://transcoder.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)
+    }
+}
--- a/gen/transcoder1/src/api/method_builders.rs
+++ b/gen/transcoder1/src/api/method_builders.rs
@@ -0,0 +1,193 @@
+use super::*;
+/// A builder providing access to all methods supported on *project* resources.
+/// It is not used directly, but through the [`Transcoder`] hub.
+///
+/// # Example
+///
+/// Instantiate a resource builder
+///
+/// ```test_harness,no_run
+/// extern crate hyper;
+/// extern crate hyper_rustls;
+/// extern crate google_transcoder1 as transcoder1;
+/// 
+/// # async fn dox() {
+/// use std::default::Default;
+/// use transcoder1::{Transcoder, 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 = Transcoder::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().unwrap().https_or_http().enable_http1().build()), auth);
+/// // Usually you wouldn't bind this to a variable, but keep calling *CallBuilders*
+/// // like `locations_job_templates_create(...)`, `locations_job_templates_delete(...)`, `locations_job_templates_get(...)`, `locations_job_templates_list(...)`, `locations_jobs_create(...)`, `locations_jobs_delete(...)`, `locations_jobs_get(...)` and `locations_jobs_list(...)`
+/// // to build up your call.
+/// let rb = hub.projects();
+/// # }
+/// ```
+pub struct ProjectMethods<'a, S>
+    where S: 'a {
+
+   pub(super) hub: &'a Transcoder<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:
+    ///
+    /// Creates a job template in the specified region.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    /// * `parent` - Required. The parent location to create this job template. Format: `projects/{project}/locations/{location}`
+    pub fn locations_job_templates_create(&self, request: JobTemplate, parent: &str) -> ProjectLocationJobTemplateCreateCall<'a, S> {
+        ProjectLocationJobTemplateCreateCall {
+            hub: self.hub,
+            _request: request,
+            _parent: parent.to_string(),
+            _job_template_id: Default::default(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Deletes a job template.
+    /// 
+    /// # Arguments
+    ///
+    /// * `name` - Required. The name of the job template to delete. `projects/{project}/locations/{location}/jobTemplates/{job_template}`
+    pub fn locations_job_templates_delete(&self, name: &str) -> ProjectLocationJobTemplateDeleteCall<'a, S> {
+        ProjectLocationJobTemplateDeleteCall {
+            hub: self.hub,
+            _name: name.to_string(),
+            _allow_missing: Default::default(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Returns the job template data.
+    /// 
+    /// # Arguments
+    ///
+    /// * `name` - Required. The name of the job template to retrieve. Format: `projects/{project}/locations/{location}/jobTemplates/{job_template}`
+    pub fn locations_job_templates_get(&self, name: &str) -> ProjectLocationJobTemplateGetCall<'a, S> {
+        ProjectLocationJobTemplateGetCall {
+            hub: self.hub,
+            _name: name.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Lists job templates in the specified region.
+    /// 
+    /// # Arguments
+    ///
+    /// * `parent` - Required. The parent location from which to retrieve the collection of job templates. Format: `projects/{project}/locations/{location}`
+    pub fn locations_job_templates_list(&self, parent: &str) -> ProjectLocationJobTemplateListCall<'a, S> {
+        ProjectLocationJobTemplateListCall {
+            hub: self.hub,
+            _parent: parent.to_string(),
+            _page_token: Default::default(),
+            _page_size: Default::default(),
+            _order_by: Default::default(),
+            _filter: Default::default(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Creates a job in the specified region.
+    /// 
+    /// # Arguments
+    ///
+    /// * `request` - No description provided.
+    /// * `parent` - Required. The parent location to create and process this job. Format: `projects/{project}/locations/{location}`
+    pub fn locations_jobs_create(&self, request: Job, parent: &str) -> ProjectLocationJobCreateCall<'a, S> {
+        ProjectLocationJobCreateCall {
+            hub: self.hub,
+            _request: request,
+            _parent: parent.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Deletes a job.
+    /// 
+    /// # Arguments
+    ///
+    /// * `name` - Required. The name of the job to delete. Format: `projects/{project}/locations/{location}/jobs/{job}`
+    pub fn locations_jobs_delete(&self, name: &str) -> ProjectLocationJobDeleteCall<'a, S> {
+        ProjectLocationJobDeleteCall {
+            hub: self.hub,
+            _name: name.to_string(),
+            _allow_missing: Default::default(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Returns the job data.
+    /// 
+    /// # Arguments
+    ///
+    /// * `name` - Required. The name of the job to retrieve. Format: `projects/{project}/locations/{location}/jobs/{job}`
+    pub fn locations_jobs_get(&self, name: &str) -> ProjectLocationJobGetCall<'a, S> {
+        ProjectLocationJobGetCall {
+            hub: self.hub,
+            _name: name.to_string(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+    
+    /// Create a builder to help you perform the following task:
+    ///
+    /// Lists jobs in the specified region.
+    /// 
+    /// # Arguments
+    ///
+    /// * `parent` - Required. Format: `projects/{project}/locations/{location}`
+    pub fn locations_jobs_list(&self, parent: &str) -> ProjectLocationJobListCall<'a, S> {
+        ProjectLocationJobListCall {
+            hub: self.hub,
+            _parent: parent.to_string(),
+            _page_token: Default::default(),
+            _page_size: Default::default(),
+            _order_by: Default::default(),
+            _filter: Default::default(),
+            _delegate: Default::default(),
+            _additional_params: Default::default(),
+            _scopes: Default::default(),
+        }
+    }
+}
+
+
+
--- a/gen/transcoder1/src/api/mod.rs
+++ b/gen/transcoder1/src/api/mod.rs
@@ -0,0 +1,35 @@
+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::*;
+
+pub mod enums;
+pub(crate) use enums::*;
--- a/gen/transcoder1/src/api/schemas.rs
+++ b/gen/transcoder1/src/api/schemas.rs
--- a/gen/transcoder1/src/api/utilities.rs
+++ b/gen/transcoder1/src/api/utilities.rs
@@ -0,0 +1,24 @@
+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
+    }
+}
+
--- a/gen/transcoder1/src/lib.rs
+++ b/gen/transcoder1/src/lib.rs
@@ -2,14 +2,14 @@
 // This file was generated automatically from 'src/generator/templates/api/lib.rs.mako'
 // DO NOT EDIT !

-//! This documentation was generated from *Transcoder* crate version *5.0.4+20240221*, where *20240221* is the exact revision of the *transcoder:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v5.0.4*.
+//! This documentation was generated from *Transcoder* crate version *5.0.5+20240410*, where *20240410* is the exact revision of the *transcoder:v1* schema built by the [mako](http://www.makotemplates.org/) code generator *v5.0.5*.
 //! 
 //! Everything else about the *Transcoder* *v1* API can be found at the
 //! [official documentation site](https://cloud.google.com/transcoder/docs/).
 //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/transcoder1).
 //! # Features
 //! 
-//! Handle the following *Resources* with ease from the central [hub](Transcoder) ... 
+//! Handle the following *Resources* with ease from the central [hub](Transcoder) ...
 //! 
 //! * projects
 //!  * [*locations job templates create*](api::ProjectLocationJobTemplateCreateCall), [*locations job templates delete*](api::ProjectLocationJobTemplateDeleteCall), [*locations job templates get*](api::ProjectLocationJobTemplateGetCall), [*locations job templates list*](api::ProjectLocationJobTemplateListCall), [*locations jobs create*](api::ProjectLocationJobCreateCall), [*locations jobs delete*](api::ProjectLocationJobDeleteCall), [*locations jobs get*](api::ProjectLocationJobGetCall) and [*locations jobs list*](api::ProjectLocationJobListCall)
@@ -51,8 +51,8 @@
 //! let r = hub.projects().locations_jobs_get(...).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 
+//! 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.
 //! 
@@ -77,23 +77,24 @@
 //! extern crate google_transcoder1 as transcoder1;
 //! use transcoder1::api::Job;
 //! use transcoder1::{Result, Error};
+//! use transcoder1::api::enums::*;
 //! # async fn dox() {
 //! use std::default::Default;
 //! use transcoder1::{Transcoder, oauth2, hyper, hyper_rustls, chrono, FieldMask};
 //! 
-//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and 
+//! // 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, 
+//! // 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 
+//! // 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 = Transcoder::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().https_or_http().enable_http1().build()), auth);
+//! let mut hub = Transcoder::new(hyper::Client::builder().build(hyper_rustls::HttpsConnectorBuilder::new().with_native_roots().unwrap().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 !
@@ -127,10 +128,10 @@
 //! ## 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 
+//! 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 
+//! 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
@@ -140,25 +141,25 @@
 //! 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 
+//! 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 
+//! 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 
+//! 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 
+//! 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