webui_protocol/

gen_webui.rs

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.

// This file is @generated by prost-build from proto/webui.proto.
// Do not edit manually. Regenerate with: cargo xtask proto
// This file is @generated by prost-build.
/// Per-component metadata keyed by tag name.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ComponentData {
    /// Non-WebUI client-side template payload.
    /// FAST plugins store complete <f-template> HTML here.
    #[prost(string, tag = "1")]
    pub template: ::prost::alloc::string::String,
    /// Component CSS content for the Module strategy.
    /// Contains the full CSS content when CssStrategy::Module is active.
    /// Empty for Link and Style strategies (CSS is handled via <link> tags
    /// or inline <style> tags baked into raw fragments by the parser).
    #[prost(string, tag = "2")]
    pub css: ::prost::alloc::string::String,
    /// External stylesheet href for the Link CSS strategy.
    /// Set to e.g. "/my-card.css" when the component has a CSS file and the
    /// build used CssStrategy::Link. Empty for Style/Module strategies and
    /// for components without CSS.
    /// The handler uses css_strategy and dom_strategy on WebUIProtocol to
    /// decide what to emit in <head>:
    ///    Link + Shadow → <link rel="preload"> (shadow root has the stylesheet)
    ///    Link + Light  → <link rel="stylesheet"> (no shadow root to host it)
    #[prost(string, tag = "3")]
    pub css_href: ::prost::alloc::string::String,
    /// WebUI plugin JSON-safe component metadata.
    /// Stored separately from executable condition closures so handlers can emit
    /// the static metadata in application/json data blocks.
    #[prost(string, tag = "4")]
    pub template_json: ::prost::alloc::string::String,
    /// WebUI plugin component-local JavaScript condition closure array.
    /// Empty when the component has no conditions or boolean attributes.
    #[prost(string, tag = "5")]
    pub template_functions: ::prost::alloc::string::String,
    /// Exact @observable + @attr property keys when hydration_mode is KEYS.
    /// Existing SSR host attributes take precedence; bootstrap state fills
    /// attribute-backed properties that were not materialized on the host.
    /// Template roots already exist in the trusted SSR DOM and do not enter
    /// initial state solely because a component has authored browser code.
    /// Sorted and deduplicated; empty for NONE and ALL.
    #[prost(string, repeated, tag = "6")]
    pub hydration_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Exact partial-navigation keys when navigation_mode is KEYS. Authored
    /// components use @observable + @attr property keys plus template roots.
    /// Scriptless compiled templates include only their template roots.
    /// Sorted and deduplicated; empty for NONE and ALL.
    #[prost(string, repeated, tag = "7")]
    pub navigation_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// How initial hydration state is selected for this component.
    #[prost(enumeration = "StateProjectionMode", tag = "8")]
    pub hydration_mode: i32,
    /// How partial-navigation state is selected for this component. Presence is
    /// significant: protocols produced before projection metadata leave this
    /// absent, so handlers preserve full state instead of treating it as NONE.
    #[prost(enumeration = "StateProjectionMode", optional, tag = "9")]
    pub navigation_mode: ::core::option::Option<i32>,
}
/// Root protocol containing all fragment records and build metadata.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WebUiProtocol {
    #[prost(map = "string, message", tag = "1")]
    pub fragments: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        FragmentList,
    >,
    /// Sorted, deduplicated CSS custom property names used across all components
    /// and entry page styles (e.g., "colorBrandBackground", "spacingMedium").
    /// Only usage via var(--name) is included; local definitions are excluded.
    #[prost(string, repeated, tag = "2")]
    pub tokens: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Per-component data keyed by tag name (f-template + CSS).
    #[prost(map = "string, message", tag = "3")]
    pub components: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ComponentData,
    >,
    /// Build-wide CSS delivery strategy. Determines how the handler emits
    /// CSS-related tags in <head> for components with css_href.
    #[prost(enumeration = "CssStrategy", tag = "4")]
    pub css_strategy: i32,
    /// Build-wide DOM encapsulation strategy. Combined with css_strategy to
    /// decide preload vs stylesheet emission.
    #[prost(enumeration = "DomStrategy", tag = "5")]
    pub dom_strategy: i32,
    /// Whether initial SSR metadata contains full state or WebUI component
    /// projection. Partial-navigation state remains component-driven.
    #[prost(enumeration = "InitialStateStrategy", tag = "6")]
    pub initial_state_strategy: i32,
    /// Ready-to-write `<link rel="modulepreload">` hrefs for the shared chunks
    /// that the page's critical module entries statically import, in the exact
    /// order they must be emitted (largest chunk first).
    ///
    /// These chunks are named only inside the entry's own bytes, so the browser's
    /// preload scanner cannot discover them until it has downloaded and parsed
    /// the entry. Emitting them as hints removes that serialization.
    ///
    /// Order is load-bearing: preloads are issued in document order over one
    /// connection, so a small chunk ahead of a large one delays the long pole.
    /// The compiler resolves and sorts these at build time so the handler writes
    /// them verbatim with no per-request work.
    #[prost(string, repeated, tag = "7")]
    pub module_preloads: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Free-form <boundary name> values keyed by entry fragment and stored in
    /// declaration order. Hosts resolve a name once to its zero-based BoundaryId;
    /// names never reach the rendered HTML response.
    #[prost(map = "string, message", tag = "8")]
    pub streaming_boundaries: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        StreamingBoundaryList,
    >,
}
/// Ordered compile-time boundary names for one entry fragment.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StreamingBoundaryList {
    #[prost(string, repeated, tag = "1")]
    pub names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// A list of fragments (needed because protobuf maps cannot have repeated values directly).
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FragmentList {
    #[prost(message, repeated, tag = "1")]
    pub fragments: ::prost::alloc::vec::Vec<WebUiFragment>,
}
/// A single fragment — one of several types.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WebUiFragment {
    #[prost(oneof = "web_ui_fragment::Fragment", tags = "1, 2, 3, 4, 5, 6, 7, 8, 9")]
    pub fragment: ::core::option::Option<web_ui_fragment::Fragment>,
}
/// Nested message and enum types in `WebUIFragment`.
pub mod web_ui_fragment {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Fragment {
        #[prost(message, tag = "1")]
        Raw(super::WebUiFragmentRaw),
        #[prost(message, tag = "2")]
        Component(super::WebUiFragmentComponent),
        #[prost(message, tag = "3")]
        ForLoop(super::WebUiFragmentFor),
        #[prost(message, tag = "4")]
        Signal(super::WebUiFragmentSignal),
        #[prost(message, tag = "5")]
        IfCond(super::WebUiFragmentIf),
        #[prost(message, tag = "6")]
        Attribute(super::WebUiFragmentAttribute),
        #[prost(message, tag = "7")]
        Plugin(super::WebUiFragmentPlugin),
        #[prost(message, tag = "8")]
        Route(super::WebUiFragmentRoute),
        #[prost(message, tag = "9")]
        Outlet(super::WebUiFragmentOutlet),
    }
}
/// Declarative route definition linking a URL path template to a component.
/// Nested routes are expressed via repeated children.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WebUiFragmentRoute {
    #[prost(string, tag = "1")]
    pub path: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub fragment_id: ::prost::alloc::string::String,
    #[prost(bool, tag = "3")]
    pub exact: bool,
    /// Nested child routes rendered at the component's <outlet />.
    #[prost(message, repeated, tag = "4")]
    pub children: ::prost::alloc::vec::Vec<WebUiFragmentRoute>,
    /// Comma-separated allowlist of query parameters forwarded as attributes.
    /// Empty string means no query params are forwarded (deny-by-default).
    #[prost(string, tag = "5")]
    pub allowed_query: ::prost::alloc::string::String,
    /// When true, the router preserves the mounted component instance across
    /// navigations instead of destroying and recreating it. Opt-in per route.
    #[prost(bool, tag = "6")]
    pub keep_alive: bool,
    /// Cache tag templates for this route (e.g. "thread:{threadId}", "inbox").
    /// Placeholders like {param} are resolved at render time with actual param values.
    #[prost(string, repeated, tag = "7")]
    pub cache_tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Invalidation tag templates (e.g. "inbox", "thread:{threadId}").
    /// After a mutation action on this route, these tags are auto-invalidated.
    /// Supports {param} placeholders resolved at render time.
    #[prost(string, repeated, tag = "8")]
    pub invalidates: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Component tag name for the pending/loading UI (e.g. "mail-skeleton").
    /// Validated at build time — build fails if the component does not exist.
    #[prost(string, tag = "9")]
    pub pending_component: ::prost::alloc::string::String,
    /// Component tag name for the error boundary UI (e.g. "error-page").
    /// Validated at build time — build fails if the component does not exist.
    #[prost(string, tag = "10")]
    pub error_component: ::prost::alloc::string::String,
}
/// Outlet placeholder — marks where matched child route content renders.
/// Components use this to indicate where nested route children are rendered.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WebUiFragmentOutlet {}
/// Opaque plugin-specific data passed from parser plugin to handler plugin.
/// WebUI framework does not interpret this data — it is a pass-through conduit.
/// Each parser/handler plugin pair defines its own binary contract for the data field.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WebUiFragmentPlugin {
    #[prost(bytes = "vec", tag = "1")]
    pub data: ::prost::alloc::vec::Vec<u8>,
}
/// Static text or HTML content.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WebUiFragmentRaw {
    #[prost(string, tag = "1")]
    pub value: ::prost::alloc::string::String,
}
/// Reference to a reusable component fragment.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WebUiFragmentComponent {
    #[prost(string, tag = "1")]
    pub fragment_id: ::prost::alloc::string::String,
}
/// Loop directive iterating over a collection.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WebUiFragmentFor {
    #[prost(string, tag = "1")]
    pub item: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub collection: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub fragment_id: ::prost::alloc::string::String,
}
/// Dynamic data binding via signal.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WebUiFragmentSignal {
    #[prost(string, tag = "1")]
    pub value: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub raw: bool,
}
/// Conditional rendering fragment.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WebUiFragmentIf {
    #[prost(message, optional, tag = "1")]
    pub condition: ::core::option::Option<ConditionExpr>,
    #[prost(string, tag = "2")]
    pub fragment_id: ::prost::alloc::string::String,
}
/// Dynamic attribute binding.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WebUiFragmentAttribute {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// For simple dynamic attrs, the signal name.
    #[prost(string, tag = "2")]
    pub value: ::prost::alloc::string::String,
    /// For mixed (template) attrs, the sub-stream ID.
    #[prost(string, tag = "3")]
    pub template: ::prost::alloc::string::String,
    /// True for :-prefixed complex attributes.
    #[prost(bool, tag = "4")]
    pub complex: bool,
    /// True for the first dynamic attribute on a component element.
    #[prost(bool, tag = "5")]
    pub attr_start: bool,
    /// True for skipped attributes (class, style, role, data-*, aria-*).
    #[prost(bool, tag = "6")]
    pub attr_skip: bool,
    /// True for static attribute values on components.
    #[prost(bool, tag = "7")]
    pub raw_value: bool,
    /// For ?-prefixed boolean attributes, the condition tree.
    #[prost(message, optional, tag = "8")]
    pub condition_tree: ::core::option::Option<ConditionExpr>,
}
/// A condition expression tree.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConditionExpr {
    #[prost(oneof = "condition_expr::Expr", tags = "1, 2, 3, 4")]
    pub expr: ::core::option::Option<condition_expr::Expr>,
}
/// Nested message and enum types in `ConditionExpr`.
pub mod condition_expr {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Expr {
        #[prost(message, tag = "1")]
        Predicate(super::Predicate),
        #[prost(message, tag = "2")]
        Not(::prost::alloc::boxed::Box<super::NotCondition>),
        #[prost(message, tag = "3")]
        Compound(::prost::alloc::boxed::Box<super::CompoundCondition>),
        #[prost(message, tag = "4")]
        Identifier(super::IdentifierCondition),
    }
}
/// Simple comparison predicate.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Predicate {
    #[prost(string, tag = "1")]
    pub left: ::prost::alloc::string::String,
    #[prost(enumeration = "ComparisonOperator", tag = "2")]
    pub operator: i32,
    #[prost(string, tag = "3")]
    pub right: ::prost::alloc::string::String,
}
/// Negation wrapper.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NotCondition {
    #[prost(message, optional, boxed, tag = "1")]
    pub condition: ::core::option::Option<::prost::alloc::boxed::Box<ConditionExpr>>,
}
/// Two conditions joined by a logical operator.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompoundCondition {
    #[prost(message, optional, boxed, tag = "1")]
    pub left: ::core::option::Option<::prost::alloc::boxed::Box<ConditionExpr>>,
    #[prost(enumeration = "LogicalOperator", tag = "2")]
    pub op: i32,
    #[prost(message, optional, boxed, tag = "3")]
    pub right: ::core::option::Option<::prost::alloc::boxed::Box<ConditionExpr>>,
}
/// Single identifier (variable name).
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct IdentifierCondition {
    #[prost(string, tag = "1")]
    pub value: ::prost::alloc::string::String,
}
/// Build-wide initial-state behavior.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum InitialStateStrategy {
    /// Emit the complete state object. Used by default and non-WebUI plugins.
    Full = 0,
    /// Select state from reachable WebUI component surfaces.
    Components = 1,
}
impl InitialStateStrategy {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Full => "INITIAL_STATE_STRATEGY_FULL",
            Self::Components => "INITIAL_STATE_STRATEGY_COMPONENTS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "INITIAL_STATE_STRATEGY_FULL" => Some(Self::Full),
            "INITIAL_STATE_STRATEGY_COMPONENTS" => Some(Self::Components),
            _ => None,
        }
    }
}
/// Per-component state selection.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum StateProjectionMode {
    /// The component is known not to consume state through this channel.
    None = 0,
    /// Select the component's explicit sorted key list.
    Keys = 1,
    /// The complete surface is unknown, so preserve correctness with full state.
    All = 2,
}
impl StateProjectionMode {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::None => "STATE_PROJECTION_MODE_NONE",
            Self::Keys => "STATE_PROJECTION_MODE_KEYS",
            Self::All => "STATE_PROJECTION_MODE_ALL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "STATE_PROJECTION_MODE_NONE" => Some(Self::None),
            "STATE_PROJECTION_MODE_KEYS" => Some(Self::Keys),
            "STATE_PROJECTION_MODE_ALL" => Some(Self::All),
            _ => None,
        }
    }
}
/// CSS delivery strategy chosen at build time.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CssStrategy {
    Link = 0,
    Style = 1,
    Module = 2,
}
impl CssStrategy {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Link => "CSS_STRATEGY_LINK",
            Self::Style => "CSS_STRATEGY_STYLE",
            Self::Module => "CSS_STRATEGY_MODULE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "CSS_STRATEGY_LINK" => Some(Self::Link),
            "CSS_STRATEGY_STYLE" => Some(Self::Style),
            "CSS_STRATEGY_MODULE" => Some(Self::Module),
            _ => None,
        }
    }
}
/// DOM encapsulation strategy chosen at build time.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DomStrategy {
    Shadow = 0,
    Light = 1,
}
impl DomStrategy {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Shadow => "DOM_STRATEGY_SHADOW",
            Self::Light => "DOM_STRATEGY_LIGHT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DOM_STRATEGY_SHADOW" => Some(Self::Shadow),
            "DOM_STRATEGY_LIGHT" => Some(Self::Light),
            _ => None,
        }
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum LogicalOperator {
    Unspecified = 0,
    And = 1,
    Or = 2,
}
impl LogicalOperator {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "LOGICAL_OPERATOR_UNSPECIFIED",
            Self::And => "AND",
            Self::Or => "OR",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "LOGICAL_OPERATOR_UNSPECIFIED" => Some(Self::Unspecified),
            "AND" => Some(Self::And),
            "OR" => Some(Self::Or),
            _ => None,
        }
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ComparisonOperator {
    Unspecified = 0,
    GreaterThan = 1,
    LessThan = 2,
    Equal = 3,
    NotEqual = 4,
    GreaterThanOrEqual = 5,
    LessThanOrEqual = 6,
}
impl ComparisonOperator {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "COMPARISON_OPERATOR_UNSPECIFIED",
            Self::GreaterThan => "GREATER_THAN",
            Self::LessThan => "LESS_THAN",
            Self::Equal => "EQUAL",
            Self::NotEqual => "NOT_EQUAL",
            Self::GreaterThanOrEqual => "GREATER_THAN_OR_EQUAL",
            Self::LessThanOrEqual => "LESS_THAN_OR_EQUAL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "COMPARISON_OPERATOR_UNSPECIFIED" => Some(Self::Unspecified),
            "GREATER_THAN" => Some(Self::GreaterThan),
            "LESS_THAN" => Some(Self::LessThan),
            "EQUAL" => Some(Self::Equal),
            "NOT_EQUAL" => Some(Self::NotEqual),
            "GREATER_THAN_OR_EQUAL" => Some(Self::GreaterThanOrEqual),
            "LESS_THAN_OR_EQUAL" => Some(Self::LessThanOrEqual),
            _ => None,
        }
    }
}