#![allow(clippy::all)]
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ConfigChange {
#[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 target: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub action: Option<ConfigChangeAction>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
with = "crate::runtime::int64",
alias = "targetGeneration"
)]
pub target_generation: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub spec: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub principal: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "originRequestId"
)]
pub origin_request_id: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ConfigFlag {
#[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<ConfigFlagSpec>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<ConfigFlagStatus>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ConfigFlagEvaluation {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "configFlag"
)]
pub config_flag: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub value: serde_json::Value,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub reason: Option<EvaluationReason>,
#[serde(default, skip_serializing_if = "Option::is_none", alias = "ruleIndex")]
pub rule_index: Option<i32>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ConfigFlagSpec {
#[serde(default, skip_serializing_if = "Option::is_none", alias = "valueType")]
pub value_type: Option<ConfigValueType>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "defaultValue"
)]
pub default_value: serde_json::Value,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub rules: Vec<TargetingRule>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub description: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "clientVisible"
)]
pub client_visible: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ConfigFlagStatus {
#[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")]
pub wave: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "waveCount"
)]
pub wave_count: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "updatedCellCount"
)]
pub updated_cell_count: i32,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "cellCount"
)]
pub cell_count: i32,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ConfigSegment {
#[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<ConfigSegmentSpec>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<ConfigSegmentStatus>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ConfigSegmentSpec {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub included: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub excluded: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub conditions: Vec<TargetingCondition>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub description: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ConfigSegmentStatus {
#[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>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct CreateConfigFlagRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(default, skip_serializing_if = "Option::is_none", alias = "configFlag")]
pub config_flag: Option<ConfigFlag>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "configFlagId"
)]
pub config_flag_id: String,
#[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 CreateConfigSegmentRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "Option::is_none",
alias = "configSegment"
)]
pub config_segment: Option<ConfigSegment>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "configSegmentId"
)]
pub config_segment_id: String,
#[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 DeleteConfigFlagRequest {
#[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 = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct DeleteConfigSegmentRequest {
#[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 = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct EvaluateConfigFlagsRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub context: Option<EvaluationContext>,
#[serde(default, skip_serializing_if = "Vec::is_empty", alias = "configFlags")]
pub config_flags: Vec<String>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct EvaluateConfigFlagsResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub evaluations: Vec<ConfigFlagEvaluation>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct EvaluationContext {
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "userId"
)]
pub user_id: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "anonymousId"
)]
pub anonymous_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub attributes: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct GetConfigChangeRequest {
#[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 GetConfigFlagRequest {
#[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 GetConfigSegmentRequest {
#[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 ListConfigChangesRequest {
#[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 ListConfigChangesResponse {
#[serde(
default,
skip_serializing_if = "Vec::is_empty",
alias = "configChanges"
)]
pub config_changes: Vec<ConfigChange>,
#[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 ListConfigFlagsRequest {
#[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 ListConfigFlagsResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty", alias = "configFlags")]
pub config_flags: Vec<ConfigFlag>,
#[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 ListConfigSegmentsRequest {
#[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,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct ListConfigSegmentsResponse {
#[serde(
default,
skip_serializing_if = "Vec::is_empty",
alias = "configSegments"
)]
pub config_segments: Vec<ConfigSegment>,
#[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 SnapshotConfigFlagsRequest {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub parent: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "ifNoneMatch"
)]
pub if_none_match: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SnapshotConfigFlagsResponse {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub etag: String,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "notModified"
)]
pub not_modified: bool,
#[serde(default, skip_serializing_if = "Vec::is_empty", alias = "configFlags")]
pub config_flags: Vec<ConfigFlag>,
#[serde(
default,
skip_serializing_if = "Vec::is_empty",
alias = "configSegments"
)]
pub config_segments: Vec<ConfigSegment>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "pollInterval"
)]
pub poll_interval: String,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct TargetingCondition {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub attribute: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub operator: Option<ConditionOperator>,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub value: serde_json::Value,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct TargetingRule {
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub value: serde_json::Value,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub percentage: Option<i32>,
#[serde(
default,
skip_serializing_if = "crate::runtime::is_default",
alias = "bucketAttribute"
)]
pub bucket_attribute: String,
#[serde(default, skip_serializing_if = "crate::runtime::is_default")]
pub description: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub conditions: Vec<TargetingCondition>,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct UpdateConfigFlagRequest {
#[serde(default, skip_serializing_if = "Option::is_none", alias = "configFlag")]
pub config_flag: Option<ConfigFlag>,
#[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 = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct UpdateConfigSegmentRequest {
#[serde(
default,
skip_serializing_if = "Option::is_none",
alias = "configSegment"
)]
pub config_segment: Option<ConfigSegment>,
#[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 = "validateOnly"
)]
pub validate_only: bool,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ConditionOperator {
Equals,
NotEquals,
GreaterThan,
GreaterOrEqual,
LessThan,
LessOrEqual,
Contains,
NotContains,
StartsWith,
EndsWith,
In,
NotIn,
Matches,
SemverGreaterThan,
SemverGreaterOrEqual,
SemverLessThan,
SemverLessOrEqual,
InSegment,
NotInSegment,
Unknown(String),
}
impl ConditionOperator {
pub fn as_str(&self) -> &str {
match self {
Self::Equals => "equals",
Self::NotEquals => "not_equals",
Self::GreaterThan => "greater_than",
Self::GreaterOrEqual => "greater_or_equal",
Self::LessThan => "less_than",
Self::LessOrEqual => "less_or_equal",
Self::Contains => "contains",
Self::NotContains => "not_contains",
Self::StartsWith => "starts_with",
Self::EndsWith => "ends_with",
Self::In => "in",
Self::NotIn => "not_in",
Self::Matches => "matches",
Self::SemverGreaterThan => "semver_greater_than",
Self::SemverGreaterOrEqual => "semver_greater_or_equal",
Self::SemverLessThan => "semver_less_than",
Self::SemverLessOrEqual => "semver_less_or_equal",
Self::InSegment => "in_segment",
Self::NotInSegment => "not_in_segment",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"equals" => Self::Equals,
"not_equals" => Self::NotEquals,
"greater_than" => Self::GreaterThan,
"greater_or_equal" => Self::GreaterOrEqual,
"less_than" => Self::LessThan,
"less_or_equal" => Self::LessOrEqual,
"contains" => Self::Contains,
"not_contains" => Self::NotContains,
"starts_with" => Self::StartsWith,
"ends_with" => Self::EndsWith,
"in" => Self::In,
"not_in" => Self::NotIn,
"matches" => Self::Matches,
"semver_greater_than" => Self::SemverGreaterThan,
"semver_greater_or_equal" => Self::SemverGreaterOrEqual,
"semver_less_than" => Self::SemverLessThan,
"semver_less_or_equal" => Self::SemverLessOrEqual,
"in_segment" => Self::InSegment,
"not_in_segment" => Self::NotInSegment,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for ConditionOperator {
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 ConditionOperator {
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 ConditionOperator {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ConfigChangeAction {
Create,
Update,
Delete,
Unknown(String),
}
impl ConfigChangeAction {
pub fn as_str(&self) -> &str {
match self {
Self::Create => "create",
Self::Update => "update",
Self::Delete => "delete",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"create" => Self::Create,
"update" => Self::Update,
"delete" => Self::Delete,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for ConfigChangeAction {
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 ConfigChangeAction {
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 ConfigChangeAction {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ConfigValueType {
Bool,
String,
Int64,
Double,
Json,
Unknown(String),
}
impl ConfigValueType {
pub fn as_str(&self) -> &str {
match self {
Self::Bool => "bool",
Self::String => "string",
Self::Int64 => "int64",
Self::Double => "double",
Self::Json => "json",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"bool" => Self::Bool,
"string" => Self::String,
"int64" => Self::Int64,
"double" => Self::Double,
"json" => Self::Json,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for ConfigValueType {
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 ConfigValueType {
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 ConfigValueType {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum EvaluationReason {
TargetingMatch,
Split,
Default,
Disabled,
NotFound,
Unknown(String),
}
impl EvaluationReason {
pub fn as_str(&self) -> &str {
match self {
Self::TargetingMatch => "targeting_match",
Self::Split => "split",
Self::Default => "default",
Self::Disabled => "disabled",
Self::NotFound => "not_found",
Self::Unknown(s) => s.as_str(),
}
}
pub fn from_wire(s: &str) -> Self {
match s {
"targeting_match" => Self::TargetingMatch,
"split" => Self::Split,
"default" => Self::Default,
"disabled" => Self::Disabled,
"not_found" => Self::NotFound,
other => Self::Unknown(other.to_string()),
}
}
}
impl serde::Serialize for EvaluationReason {
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 EvaluationReason {
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 EvaluationReason {
fn query_value(&self) -> Option<String> {
Some(self.as_str().to_string())
}
}
impl<T: crate::runtime::Transport> crate::runtime::Client<T> {
pub fn config(&self) -> ConfigApi<'_, T> {
ConfigApi { client: self }
}
}
pub struct ConfigApi<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> ConfigApi<'a, T> {
pub fn config_flags(&self) -> ConfigFlagsCollection<'a, T> {
ConfigFlagsCollection {
client: self.client,
}
}
pub fn config_segments(&self) -> ConfigSegmentsCollection<'a, T> {
ConfigSegmentsCollection {
client: self.client,
}
}
pub fn config_changes(&self) -> ConfigChangesCollection<'a, T> {
ConfigChangesCollection {
client: self.client,
}
}
}
pub struct ConfigFlagsCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> ConfigFlagsCollection<'a, T> {
pub async fn get(
&self,
request: GetConfigFlagRequest,
) -> Result<ConfigFlag, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/config_flags/*",
"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: ListConfigFlagsRequest,
) -> Result<ListConfigFlagsResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/config_flags",
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: ListConfigFlagsRequest,
) -> Result<Vec<ConfigFlag>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.config_flags);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreateConfigFlagRequest,
) -> Result<crate::runtime::Operation<'a, T, ConfigFlag>, crate::runtime::Error> {
let path = format!(
"/v1/{}/config_flags",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("config_flag_id", &request.config_flag_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.config_flag)?),
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
pub async fn update(
&self,
request: UpdateConfigFlagRequest,
) -> Result<crate::runtime::Operation<'a, T, ConfigFlag>, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
request
.config_flag
.as_ref()
.map(|v| v.name.as_str())
.unwrap_or(""),
"orgs/*/projects/*/envs/*/config_flags/*",
"config_flag.name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("update_mask", &request.update_mask);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "PATCH",
path,
query: query.0,
body: Some(crate::runtime::body(&request.config_flag)?),
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
pub async fn delete(
&self,
request: DeleteConfigFlagRequest,
) -> Result<crate::runtime::Operation<'a, T, crate::runtime::Empty>, crate::runtime::Error>
{
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/config_flags/*",
"name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("etag", &request.etag);
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,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
pub async fn evaluate(
&self,
request: EvaluateConfigFlagsRequest,
) -> Result<EvaluateConfigFlagsResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/config_flags:evaluate",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let query = crate::runtime::Query::default();
let http = crate::runtime::HttpRequest {
method: "POST",
path,
query: query.0,
body: Some(crate::runtime::body_without(&request, &["parent"])?),
mutation: true,
origin: None,
effect_ids: false,
};
self.client.call(http).await
}
pub async fn snapshot(
&self,
request: SnapshotConfigFlagsRequest,
) -> Result<SnapshotConfigFlagsResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/config_flags:snapshot",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("if_none_match", &request.if_none_match);
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 struct ConfigSegmentsCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> ConfigSegmentsCollection<'a, T> {
pub async fn get(
&self,
request: GetConfigSegmentRequest,
) -> Result<ConfigSegment, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/config_segments/*",
"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: ListConfigSegmentsRequest,
) -> Result<ListConfigSegmentsResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/config_segments",
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);
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: ListConfigSegmentsRequest,
) -> Result<Vec<ConfigSegment>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.config_segments);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
pub async fn create(
&self,
request: CreateConfigSegmentRequest,
) -> Result<crate::runtime::Operation<'a, T, ConfigSegment>, crate::runtime::Error> {
let path = format!(
"/v1/{}/config_segments",
crate::runtime::path_param(&request.parent, "orgs/*/projects/*/envs/*", "parent")?
);
let mut query = crate::runtime::Query::default();
query.push("config_segment_id", &request.config_segment_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.config_segment)?),
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
pub async fn update(
&self,
request: UpdateConfigSegmentRequest,
) -> Result<crate::runtime::Operation<'a, T, ConfigSegment>, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
request
.config_segment
.as_ref()
.map(|v| v.name.as_str())
.unwrap_or(""),
"orgs/*/projects/*/envs/*/config_segments/*",
"config_segment.name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("update_mask", &request.update_mask);
query.push("validate_only", &request.validate_only);
let http = crate::runtime::HttpRequest {
method: "PATCH",
path,
query: query.0,
body: Some(crate::runtime::body(&request.config_segment)?),
mutation: true,
origin: None,
effect_ids: false,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
pub async fn delete(
&self,
request: DeleteConfigSegmentRequest,
) -> Result<crate::runtime::Operation<'a, T, crate::runtime::Empty>, crate::runtime::Error>
{
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/config_segments/*",
"name"
)?
);
let mut query = crate::runtime::Query::default();
query.push("etag", &request.etag);
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,
};
let operation = self.client.call(http).await?;
Ok(crate::runtime::Operation::new(self.client, operation))
}
}
pub struct ConfigChangesCollection<'a, T> {
client: &'a crate::runtime::Client<T>,
}
impl<'a, T: crate::runtime::Transport> ConfigChangesCollection<'a, T> {
pub async fn get(
&self,
request: GetConfigChangeRequest,
) -> Result<ConfigChange, crate::runtime::Error> {
let path = format!(
"/v1/{}",
crate::runtime::path_param(
&request.name,
"orgs/*/projects/*/envs/*/config_changes/*",
"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: ListConfigChangesRequest,
) -> Result<ListConfigChangesResponse, crate::runtime::Error> {
let path = format!(
"/v1/{}/config_changes",
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);
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: ListConfigChangesRequest,
) -> Result<Vec<ConfigChange>, crate::runtime::Error> {
let mut items = Vec::new();
loop {
let page = self.list(request.clone()).await?;
items.extend(page.config_changes);
if page.next_page_token.is_empty() {
return Ok(items);
}
request.page_token = page.next_page_token;
}
}
}