codegen

1 files changed, 289 insertions, 660 deletions

diff --git a/rust/fatcat-api-spec/src/client.rs b/rust/fatcat-api-spec/src/client.rs
index 1e889092..b67e193a 100644
--- a/rust/fatcat-api-spec/src/client.rs
+++ b/rust/fatcat-api-spec/src/client.rs
@@ -227,6 +227,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateContainerResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -322,6 +329,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateContainerBatchResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -405,6 +419,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(DeleteContainerResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -484,6 +505,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(DeleteContainerEditResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -554,21 +582,6 @@ impl Api for Client {
 
                     Ok(GetContainerResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetContainerResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -633,21 +646,6 @@ impl Api for Client {
 
                     Ok(GetContainerEditResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetContainerEditResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -716,21 +714,6 @@ impl Api for Client {
 
                     Ok(GetContainerHistoryResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetContainerHistoryResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -795,21 +778,6 @@ impl Api for Client {
 
                     Ok(GetContainerRedirectsResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetContainerRedirectsResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -886,21 +854,6 @@ impl Api for Client {
 
                     Ok(GetContainerRevisionResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetContainerRevisionResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -981,21 +934,6 @@ impl Api for Client {
 
                     Ok(LookupContainerResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(LookupContainerResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -1090,6 +1028,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(UpdateContainerResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -1177,6 +1122,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateCreatorResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -1272,6 +1224,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateCreatorBatchResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -1355,6 +1314,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(DeleteCreatorResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -1434,6 +1400,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(DeleteCreatorEditResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -1504,21 +1477,6 @@ impl Api for Client {
 
                     Ok(GetCreatorResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetCreatorResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -1583,21 +1541,6 @@ impl Api for Client {
 
                     Ok(GetCreatorEditResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetCreatorEditResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -1666,21 +1609,6 @@ impl Api for Client {
 
                     Ok(GetCreatorHistoryResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetCreatorHistoryResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -1745,21 +1673,6 @@ impl Api for Client {
 
                     Ok(GetCreatorRedirectsResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetCreatorRedirectsResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -1828,21 +1741,6 @@ impl Api for Client {
 
                     Ok(GetCreatorReleasesResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetCreatorReleasesResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -1919,21 +1817,6 @@ impl Api for Client {
 
                     Ok(GetCreatorRevisionResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetCreatorRevisionResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -2014,21 +1897,6 @@ impl Api for Client {
 
                     Ok(LookupCreatorResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(LookupCreatorResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -2123,6 +1991,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(UpdateCreatorResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -2315,6 +2190,28 @@ impl Api for Client {
 
                     Ok(AcceptEditgroupResponse::BadRequest(body))
                 }
+                401 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
+                    let response_www_authenticate = response
+                        .headers
+                        .get::<ResponseWwwAuthenticate>()
+                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
+
+                    Ok(AcceptEditgroupResponse::NotAuthorized {
+                        body: body,
+                        www_authenticate: response_www_authenticate.0.clone(),
+                    })
+                }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(AcceptEditgroupResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -2387,6 +2284,28 @@ impl Api for Client {
 
                     Ok(CreateEditgroupResponse::BadRequest(body))
                 }
+                401 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
+                    let response_www_authenticate = response
+                        .headers
+                        .get::<ResponseWwwAuthenticate>()
+                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
+
+                    Ok(CreateEditgroupResponse::NotAuthorized {
+                        body: body,
+                        www_authenticate: response_www_authenticate.0.clone(),
+                    })
+                }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateEditgroupResponse::Forbidden(body))
+                }
                 500 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -2633,6 +2552,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateFileResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -2728,6 +2654,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateFileBatchResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -2811,6 +2744,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(DeleteFileResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -2890,6 +2830,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(DeleteFileEditResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -2960,21 +2907,6 @@ impl Api for Client {
 
                     Ok(GetFileResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetFileResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -3039,21 +2971,6 @@ impl Api for Client {
 
                     Ok(GetFileEditResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetFileEditResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -3122,21 +3039,6 @@ impl Api for Client {
 
                     Ok(GetFileHistoryResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetFileHistoryResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -3201,21 +3103,6 @@ impl Api for Client {
 
                     Ok(GetFileRedirectsResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetFileRedirectsResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -3292,21 +3179,6 @@ impl Api for Client {
 
                     Ok(GetFileRevisionResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetFileRevisionResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -3390,21 +3262,6 @@ impl Api for Client {
 
                     Ok(LookupFileResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(LookupFileResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -3499,6 +3356,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(UpdateFileResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -3586,6 +3450,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateFilesetResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -3681,6 +3552,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateFilesetBatchResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -3764,6 +3642,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(DeleteFilesetResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -3843,6 +3728,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(DeleteFilesetEditResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -3913,21 +3805,6 @@ impl Api for Client {
 
                     Ok(GetFilesetResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetFilesetResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -3992,21 +3869,6 @@ impl Api for Client {
 
                     Ok(GetFilesetEditResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetFilesetEditResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -4075,21 +3937,6 @@ impl Api for Client {
 
                     Ok(GetFilesetHistoryResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetFilesetHistoryResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -4154,21 +4001,6 @@ impl Api for Client {
 
                     Ok(GetFilesetRedirectsResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetFilesetRedirectsResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -4245,21 +4077,6 @@ impl Api for Client {
 
                     Ok(GetFilesetRevisionResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetFilesetRevisionResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -4354,6 +4171,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(UpdateFilesetResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -4441,6 +4265,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateReleaseResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -4536,6 +4367,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateReleaseBatchResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -4619,6 +4457,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateWorkResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -4702,6 +4547,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(DeleteReleaseResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -4781,6 +4633,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(DeleteReleaseEditResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -4851,21 +4710,6 @@ impl Api for Client {
 
                     Ok(GetReleaseResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetReleaseResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -4930,21 +4774,6 @@ impl Api for Client {
 
                     Ok(GetReleaseEditResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetReleaseEditResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -5013,21 +4842,6 @@ impl Api for Client {
 
                     Ok(GetReleaseFilesResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetReleaseFilesResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -5096,21 +4910,6 @@ impl Api for Client {
 
                     Ok(GetReleaseFilesetsResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetReleaseFilesetsResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -5179,21 +4978,6 @@ impl Api for Client {
 
                     Ok(GetReleaseHistoryResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetReleaseHistoryResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -5258,21 +5042,6 @@ impl Api for Client {
 
                     Ok(GetReleaseRedirectsResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetReleaseRedirectsResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -5349,21 +5118,6 @@ impl Api for Client {
 
                     Ok(GetReleaseRevisionResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetReleaseRevisionResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -5432,21 +5186,6 @@ impl Api for Client {
 
                     Ok(GetReleaseWebcapturesResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetReleaseWebcapturesResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -5539,21 +5278,6 @@ impl Api for Client {
 
                     Ok(LookupReleaseResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(LookupReleaseResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -5648,6 +5372,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(UpdateReleaseResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -5740,6 +5471,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateWebcaptureResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -5835,6 +5573,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateWebcaptureBatchResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -5918,6 +5663,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(DeleteWebcaptureResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -5997,6 +5749,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(DeleteWebcaptureEditResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -6067,21 +5826,6 @@ impl Api for Client {
 
                     Ok(GetWebcaptureResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetWebcaptureResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -6146,21 +5890,6 @@ impl Api for Client {
 
                     Ok(GetWebcaptureEditResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetWebcaptureEditResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -6229,21 +5958,6 @@ impl Api for Client {
 
                     Ok(GetWebcaptureHistoryResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetWebcaptureHistoryResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -6308,21 +6022,6 @@ impl Api for Client {
 
                     Ok(GetWebcaptureRedirectsResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetWebcaptureRedirectsResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -6399,21 +6098,6 @@ impl Api for Client {
 
                     Ok(GetWebcaptureRevisionResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetWebcaptureRevisionResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -6508,6 +6192,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(UpdateWebcaptureResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -6603,6 +6294,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(CreateWorkBatchResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -6686,6 +6384,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(DeleteWorkResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -6765,6 +6470,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(DeleteWorkEditResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -6835,21 +6547,6 @@ impl Api for Client {
 
                     Ok(GetWorkResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetWorkResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -6914,21 +6611,6 @@ impl Api for Client {
 
                     Ok(GetWorkEditResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetWorkEditResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -6997,21 +6679,6 @@ impl Api for Client {
 
                     Ok(GetWorkHistoryResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetWorkHistoryResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -7076,21 +6743,6 @@ impl Api for Client {
 
                     Ok(GetWorkRedirectsResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetWorkRedirectsResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -7159,21 +6811,6 @@ impl Api for Client {
 
                     Ok(GetWorkReleasesResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetWorkReleasesResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -7250,21 +6887,6 @@ impl Api for Client {
 
                     Ok(GetWorkRevisionResponse::BadRequest(body))
                 }
-                401 => {
-                    let mut buf = String::new();
-                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
-                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
-                    header! { (ResponseWwwAuthenticate, "WWW_Authenticate") => [String] }
-                    let response_www_authenticate = response
-                        .headers
-                        .get::<ResponseWwwAuthenticate>()
-                        .ok_or_else(|| "Required response header WWW_Authenticate for response 401 was not found.")?;
-
-                    Ok(GetWorkRevisionResponse::NotAuthorized {
-                        body: body,
-                        www_authenticate: response_www_authenticate.0.clone(),
-                    })
-                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
@@ -7359,6 +6981,13 @@ impl Api for Client {
                         www_authenticate: response_www_authenticate.0.clone(),
                     })
                 }
+                403 => {
+                    let mut buf = String::new();
+                    response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+                    let body = serde_json::from_str::<models::ErrorResponse>(&buf)?;
+
+                    Ok(UpdateWorkResponse::Forbidden(body))
+                }
                 404 => {
                     let mut buf = String::new();
                     response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;