#![allow(clippy::all)]
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Catalog {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<crate::common::ResourceMeta>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub spec: Option<CatalogSpec>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<CatalogStatus>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CatalogEntry {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<crate::common::ResourceMeta>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub key: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub file: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "sourceText"
)]
pub source_text: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub context: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub description: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "maxLength"
)]
pub max_length: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "sourceHash"
)]
pub source_hash: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub state: Option<EntryState>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub translations: Vec<Translation>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "createTime"
)]
pub create_time: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "updateTime"
)]
pub update_time: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CatalogFile {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub path: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub locale: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub content: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CatalogSpec {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "sourceLocale"
)]
pub source_locale: String,
#[serde(
default,
skip_serializing_if = "Vec::is_empty",
alias = "targetLocales"
)]
pub target_locales: Vec<String>,
#[serde(
default,
skip_serializing_if = "Vec::is_empty",
alias = "pseudoLocales"
)]
pub pseudo_locales: Vec<PseudoLocale>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub tone: String,
#[serde(
default,
skip_serializing_if = "std::collections::BTreeMap::is_empty",
alias = "localeGuidance"
)]
pub locale_guidance: std::collections::BTreeMap<String, String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub glossaries: Vec<String>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CatalogStatus {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "observedGeneration"
)]
pub observed_generation: i64,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub conditions: Vec<crate::common::Condition>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "entryCount"
)]
pub entry_count: i32,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub locales: Vec<LocaleProgress>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "lastSyncTime"
)]
pub last_sync_time: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CreateCatalogRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "catalogId"
)]
pub catalog_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub catalog: Option<Catalog>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CreateGlossaryRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "glossaryId"
)]
pub glossary_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub glossary: Option<Glossary>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DeleteCatalogRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub force: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DeleteGlossaryRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ExportCatalogRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub format: Option<Format>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub locales: Vec<String>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "sourceFallback"
)]
pub source_fallback: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ExportCatalogResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub files: Vec<CatalogFile>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub report: Option<QaReport>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub pending: i32,
#[serde(default, skip_serializing_if = "Vec::is_empty", alias = "glyphSets")]
pub glyph_sets: Vec<GlyphSet>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetCatalogEntryRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetCatalogRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetGlossaryRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Glossary {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub uid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<crate::common::ResourceMeta>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub spec: Option<GlossarySpec>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<GlossaryStatus>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GlossarySpec {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub terms: Vec<GlossaryTerm>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GlossaryStatus {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "observedGeneration"
)]
pub observed_generation: i64,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub conditions: Vec<crate::common::Condition>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "termCount"
)]
pub term_count: i32,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GlossaryTerm {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub term: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub description: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub rule: Option<TermRule>,
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
pub translations: std::collections::BTreeMap<String, String>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub replacement: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub locales: Vec<String>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "caseSensitive"
)]
pub case_sensitive: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GlyphSet {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub locale: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub characters: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListCatalogEntriesRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageSize"
)]
pub page_size: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageToken"
)]
pub page_token: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub filter: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListCatalogEntriesResponse {
#[serde(
default,
skip_serializing_if = "Vec::is_empty",
alias = "catalogEntries"
)]
pub catalog_entries: Vec<CatalogEntry>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextPageToken"
)]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListCatalogsRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageSize"
)]
pub page_size: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageToken"
)]
pub page_token: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub filter: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "orderBy"
)]
pub order_by: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListCatalogsResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub catalogs: Vec<Catalog>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextPageToken"
)]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListGlossariesRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageSize"
)]
pub page_size: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pageToken"
)]
pub page_token: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub filter: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "orderBy"
)]
pub order_by: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListGlossariesResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub glossaries: Vec<Glossary>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "nextPageToken"
)]
pub next_page_token: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct LocaleProgress {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub locale: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub translated: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub pending: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub failed: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub pinned: i32,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct PinTranslationRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub locale: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub text: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct QaFinding {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub entry: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub key: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub locale: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub check: Option<QaCheck>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub severity: Option<QaSeverity>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub message: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct QaReport {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub passed: bool,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub errors: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub warnings: i32,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub findings: Vec<QaFinding>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SyncCatalogRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub format: Option<Format>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub sources: Vec<CatalogFile>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub translations: Vec<CatalogFile>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SyncCatalogResponse {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub catalog: Option<Catalog>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub added: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub changed: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub obsoleted: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub adopted: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub pinned: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub translated: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub pending: i32,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub failed: i32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub usage: Option<Usage>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Translation {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub locale: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub text: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub origin: Option<TranslationOrigin>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub pinned: bool,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub stale: bool,
#[serde(default, skip_serializing_if = "Option::is_none", alias = "qaState")]
pub qa_state: Option<QaState>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub findings: Vec<QaFinding>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "updateTime"
)]
pub update_time: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct UnpinTranslationRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub name: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub locale: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct UpdateCatalogRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub catalog: Option<Catalog>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "updateMask"
)]
pub update_mask: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct UpdateGlossaryRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub glossary: Option<Glossary>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "updateMask"
)]
pub update_mask: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "allowMissing"
)]
pub allow_missing: bool,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct Usage {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "translatedCharacters"
)]
pub translated_characters: i64,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "memoryMatches"
)]
pub memory_matches: i32,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum EntryState {
Active,
Obsolete,
Unknown(String),
}
impl EntryState {
pub fn as_str(&self) -> &str {
match self {
Self::Active => "active",
Self::Obsolete => "obsolete",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"active" => Self::Active,
"obsolete" => Self::Obsolete,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for EntryState {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for EntryState {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for EntryState {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Format {
SylphxJson,
IcuJson,
GettextPo,
Xliff2,
Unknown(String),
}
impl Format {
pub fn as_str(&self) -> &str {
match self {
Self::SylphxJson => "sylphx_json",
Self::IcuJson => "icu_json",
Self::GettextPo => "gettext_po",
Self::Xliff2 => "xliff2",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"sylphx_json" => Self::SylphxJson,
"icu_json" => Self::IcuJson,
"gettext_po" => Self::GettextPo,
"xliff2" => Self::Xliff2,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for Format {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for Format {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for Format {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum PseudoLocale {
Accented,
Bidi,
Wide,
Unknown(String),
}
impl PseudoLocale {
pub fn as_str(&self) -> &str {
match self {
Self::Accented => "accented",
Self::Bidi => "bidi",
Self::Wide => "wide",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"accented" => Self::Accented,
"bidi" => Self::Bidi,
"wide" => Self::Wide,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for PseudoLocale {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for PseudoLocale {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for PseudoLocale {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum QaCheck {
Syntax,
Placeholders,
Markup,
Plural,
Length,
Glossary,
ForbiddenTerm,
Unknown(String),
}
impl QaCheck {
pub fn as_str(&self) -> &str {
match self {
Self::Syntax => "syntax",
Self::Placeholders => "placeholders",
Self::Markup => "markup",
Self::Plural => "plural",
Self::Length => "length",
Self::Glossary => "glossary",
Self::ForbiddenTerm => "forbidden_term",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"syntax" => Self::Syntax,
"placeholders" => Self::Placeholders,
"markup" => Self::Markup,
"plural" => Self::Plural,
"length" => Self::Length,
"glossary" => Self::Glossary,
"forbidden_term" => Self::ForbiddenTerm,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for QaCheck {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for QaCheck {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for QaCheck {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum QaSeverity {
Error,
Warning,
Unknown(String),
}
impl QaSeverity {
pub fn as_str(&self) -> &str {
match self {
Self::Error => "error",
Self::Warning => "warning",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"error" => Self::Error,
"warning" => Self::Warning,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for QaSeverity {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for QaSeverity {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for QaSeverity {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum QaState {
Passed,
Warning,
Failed,
Pending,
Unknown(String),
}
impl QaState {
pub fn as_str(&self) -> &str {
match self {
Self::Passed => "passed",
Self::Warning => "warning",
Self::Failed => "failed",
Self::Pending => "pending",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"passed" => Self::Passed,
"warning" => Self::Warning,
"failed" => Self::Failed,
"pending" => Self::Pending,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for QaState {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for QaState {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for QaState {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum TermRule {
Translate,
Keep,
Forbidden,
Unknown(String),
}
impl TermRule {
pub fn as_str(&self) -> &str {
match self {
Self::Translate => "translate",
Self::Keep => "keep",
Self::Forbidden => "forbidden",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"translate" => Self::Translate,
"keep" => Self::Keep,
"forbidden" => Self::Forbidden,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for TermRule {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for TermRule {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for TermRule {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum TranslationOrigin {
Ai,
Memory,
Human,
Imported,
Unknown(String),
}
impl TranslationOrigin {
pub fn as_str(&self) -> &str {
match self {
Self::Ai => "ai",
Self::Memory => "memory",
Self::Human => "human",
Self::Imported => "imported",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"ai" => Self::Ai,
"memory" => Self::Memory,
"human" => Self::Human,
"imported" => Self::Imported,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for TranslationOrigin {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for TranslationOrigin {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = <String as serde::Deserialize>::deserialize(d)?;
Ok(Self::from_wire(&s))
}
}
impl crate::runtime::QueryValue for TranslationOrigin {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
impl<T: crate::runtime::Transport> crate::runtime::Client<T> {
pub fn localization(&self) -> LocalizationApi<'_, T> {
LocalizationApi { client: self }
}
}
pub struct LocalizationApi<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> LocalizationApi<'a, T> {
pub fn catalogs(&self) -> CatalogsCollection<'a, T> {
CatalogsCollection {
client: self.client,
}
}
pub fn entries(&self) -> EntriesCollection<'a, T> {
EntriesCollection {
client: self.client,
}
}
pub fn glossaries(&self) -> GlossariesCollection<'a, T> {
GlossariesCollection {
client: self.client,
}
}
}
pub struct CatalogsCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> CatalogsCollection<'a, T> {
pub async fn get(&self, request: GetCatalogRequest) -> Result<Catalog, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/catalogs/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListCatalogsRequest,
) -> Result<ListCatalogsResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/catalogs",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("page_size", &request.page_size);
query.push("page_token", &request.page_token);
query.push("filter", &request.filter);
query.push("order_by", &request.order_by);
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListCatalogsRequest,
) -> Result<Vec<Catalog>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.catalogs);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreateCatalogRequest,
) -> Result<Catalog, crate::runtime::Error> {
let path = format!(
"/v1/{}/catalogs",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("catalog_id", &request.catalog_id);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body(&request.catalog)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn update(
&self,
request: UpdateCatalogRequest,
) -> Result<Catalog, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
request
.catalog
.as_ref()
.map(|v| v.name.as_str())
.unwrap_or(""),
"orgs/*/projects/*/envs/*/catalogs/*",
"catalog.name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("update_mask", &request.update_mask);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "PATCH",
path,
query: query.0,
body: Some(crate::runtime::body(&request.catalog)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn delete(
&self,
request: DeleteCatalogRequest,
) -> Result<crate::runtime::Empty, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/catalogs/*",
"name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("etag", &request.etag);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
query.push("force", &request.force);
let http = crate::runtime::HttpRequest {
method: "DELETE",
path,
query: query.0,
body: None,
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn sync(
&self,
request: SyncCatalogRequest,
) -> Result<SyncCatalogResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}:sync",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/catalogs/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn export(
&self,
request: ExportCatalogRequest,
) -> Result<ExportCatalogResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}:export",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/catalogs/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
}
pub struct EntriesCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> EntriesCollection<'a, T> {
pub async fn get(
&self,
request: GetCatalogEntryRequest,
) -> Result<CatalogEntry, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/catalogs/*/entries/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListCatalogEntriesRequest,
) -> Result<ListCatalogEntriesResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/entries",
crate::runtime::path_param(
&request.parent,
"orgs/*/projects/*/envs/*/catalogs/*",
"parent"
)?
);
let mut query = crate::runtime::Query::default();
query.push("page_size", &request.page_size);
query.push("page_token", &request.page_token);
query.push("filter", &request.filter);
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListCatalogEntriesRequest,
) -> Result<Vec<CatalogEntry>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.catalog_entries);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn pin_translation(
&self,
request: PinTranslationRequest,
) -> Result<CatalogEntry, crate::runtime::Error> {
let path = format!(
"/v1/{}:pinTranslation",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/catalogs/*/entries/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn unpin_translation(
&self,
request: UnpinTranslationRequest,
) -> Result<CatalogEntry, crate::runtime::Error> {
let path = format!(
"/v1/{}:unpinTranslation",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/catalogs/*/entries/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["name"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
}
pub struct GlossariesCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> GlossariesCollection<'a, T> {
pub async fn get(
&self,
request: GetGlossaryRequest,
) -> Result<Glossary, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/glossaries/*",
"name"
)?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list(
&self,
request: ListGlossariesRequest,
) -> Result<ListGlossariesResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/glossaries",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("page_size", &request.page_size);
query.push("page_token", &request.page_token);
query.push("filter", &request.filter);
query.push("order_by", &request.order_by);
let http = crate::runtime::HttpRequest {
method: "GET",
path,
query: query.0,
body: None,
mutation: false,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn list_all(
&self,
mut request: ListGlossariesRequest,
) -> Result<Vec<Glossary>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.glossaries);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreateGlossaryRequest,
) -> Result<Glossary, crate::runtime::Error> {
let path = format!(
"/v1/{}/glossaries",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("glossary_id", &request.glossary_id);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body(&request.glossary)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn update(
&self,
request: UpdateGlossaryRequest,
) -> Result<Glossary, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
request
.glossary
.as_ref()
.map(|v| v.name.as_str())
.unwrap_or(""),
"orgs/*/projects/*/envs/*/glossaries/*",
"glossary.name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("update_mask", &request.update_mask);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "PATCH",
path,
query: query.0,
body: Some(crate::runtime::body(&request.glossary)?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn delete(
&self,
request: DeleteGlossaryRequest,
) -> Result<crate::runtime::Empty, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/glossaries/*",
"name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("etag", &request.etag);
query.push("allow_missing", &request.allow_missing);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "DELETE",
path,
query: query.0,
body: None,
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
}