omnibase_infra 0.2.6__py3-none-any.whl

omnibase_infra/enums/__init__.py

@@ -0,0 +1,132 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""ONEX Infrastructure Enumerations Module.
+
+Provides infrastructure-specific enumerations for transport types,
+protocol identification, policy classification, dispatch status,
+message categories, topic types, topic standards, chain validation,
+registration states, handler types, handler error types, handler source types,
+node archetypes, introspection reasons, contract types, circuit breaker states, retry error categories,
+any type violations, security validation, validation severity, selection strategies, backend types,
+registration status, confirmation events, and other infrastructure concerns.
+
+Exports:
+    EnumAnyTypeViolation: Any type violation categories for strong typing validation
+    EnumBackendType: Infrastructure backend types (CONSUL, POSTGRES)
+    EnumChainViolationType: Chain violation types for correlation/causation validation
+    EnumCircuitState: Circuit breaker states (CLOSED, OPEN, HALF_OPEN)
+    EnumConfirmationEventType: Registration confirmation event types
+    EnumConsumerGroupPurpose: Consumer group purpose (CONSUME, INTROSPECTION, REPLAY, AUDIT, BACKFILL)
+    EnumContractType: Contract types for ONEX nodes (effect, compute, reducer, orchestrator)
+    EnumDispatchStatus: Dispatch operation status enumeration
+    EnumEnvironment: Deployment environment classification (DEVELOPMENT, STAGING, PRODUCTION, CI)
+    EnumExecutionShapeViolation: Specific execution shape violation types
+    EnumHandlerErrorType: Handler error types for validation and lifecycle
+    EnumHandlerLoaderError: Handler loader error codes for plugin loading
+    EnumResponseStatus: Handler response status (SUCCESS, ERROR)
+    EnumHandlerSourceMode: Handler source modes for loading strategy (BOOTSTRAP, CONTRACT, HYBRID)
+    EnumHandlerSourceType: Handler validation error source types
+    EnumHandlerType: Handler architectural roles (INFRA_HANDLER, NODE_HANDLER)
+    EnumHandlerTypeCategory: Behavioral classification (COMPUTE, EFFECT)
+    EnumInfraTransportType: Infrastructure transport type enumeration
+    EnumIntrospectionReason: Introspection event reasons (STARTUP, SHUTDOWN, etc.)
+    EnumKafkaAcks: Kafka producer acknowledgment policy (ALL, NONE, LEADER, ALL_REPLICAS)
+    EnumMessageCategory: Message categories (EVENT, COMMAND, INTENT)
+    EnumNodeArchetype: 4-node architecture (EFFECT, COMPUTE, REDUCER, ORCHESTRATOR)
+    EnumNodeOutputType: Node output types for execution shape validation
+    EnumNonRetryableErrorCategory: Non-retryable error categories for DLQ
+    EnumPolicyType: Policy types for RegistryPolicy plugins
+    EnumRegistrationState: Registration FSM states for two-way registration
+    EnumRegistrationStatus: Registration workflow status (IDLE, PENDING, PARTIAL, COMPLETE, FAILED)
+    EnumRegistryResponseStatus: Registry operation response status (SUCCESS, PARTIAL, FAILED)
+    EnumRetryErrorCategory: Error categories for retry decision making
+    EnumSecurityRuleId: Security validation rule identifiers for OMN-1098
+    EnumSelectionStrategy: Selection strategies for capability-based discovery (FIRST, RANDOM, ROUND_ROBIN, LEAST_LOADED)
+    EnumTopicStandard: Topic standards (ONEX_KAFKA, ENVIRONMENT_AWARE)
+    EnumTopicType: Topic types (EVENTS, COMMANDS, INTENTS, SNAPSHOTS)
+    EnumValidationSeverity: Validation error severity levels (ERROR, CRITICAL, WARNING)
+"""
+
+from omnibase_core.enums import EnumTopicType
+from omnibase_infra.enums.enum_any_type_violation import EnumAnyTypeViolation
+from omnibase_infra.enums.enum_backend_type import EnumBackendType
+from omnibase_infra.enums.enum_capture_outcome import EnumCaptureOutcome
+from omnibase_infra.enums.enum_capture_state import EnumCaptureState
+from omnibase_infra.enums.enum_chain_violation_type import EnumChainViolationType
+from omnibase_infra.enums.enum_circuit_state import EnumCircuitState
+from omnibase_infra.enums.enum_confirmation_event_type import EnumConfirmationEventType
+from omnibase_infra.enums.enum_consumer_group_purpose import EnumConsumerGroupPurpose
+from omnibase_infra.enums.enum_contract_type import EnumContractType
+from omnibase_infra.enums.enum_dedupe_strategy import EnumDedupeStrategy
+from omnibase_infra.enums.enum_dispatch_status import EnumDispatchStatus
+from omnibase_infra.enums.enum_environment import EnumEnvironment
+from omnibase_infra.enums.enum_execution_shape_violation import (
+    EnumExecutionShapeViolation,
+)
+from omnibase_infra.enums.enum_handler_error_type import EnumHandlerErrorType
+from omnibase_infra.enums.enum_handler_loader_error import EnumHandlerLoaderError
+from omnibase_infra.enums.enum_handler_source_mode import EnumHandlerSourceMode
+from omnibase_infra.enums.enum_handler_source_type import EnumHandlerSourceType
+from omnibase_infra.enums.enum_handler_type import EnumHandlerType
+from omnibase_infra.enums.enum_handler_type_category import EnumHandlerTypeCategory
+from omnibase_infra.enums.enum_infra_transport_type import EnumInfraTransportType
+from omnibase_infra.enums.enum_introspection_reason import EnumIntrospectionReason
+from omnibase_infra.enums.enum_kafka_acks import EnumKafkaAcks
+from omnibase_infra.enums.enum_message_category import EnumMessageCategory
+from omnibase_infra.enums.enum_node_archetype import EnumNodeArchetype
+from omnibase_infra.enums.enum_node_output_type import EnumNodeOutputType
+from omnibase_infra.enums.enum_non_retryable_error_category import (
+    EnumNonRetryableErrorCategory,
+)
+from omnibase_infra.enums.enum_policy_type import EnumPolicyType
+from omnibase_infra.enums.enum_registration_state import EnumRegistrationState
+from omnibase_infra.enums.enum_registration_status import EnumRegistrationStatus
+from omnibase_infra.enums.enum_registry_response_status import (
+    EnumRegistryResponseStatus,
+)
+from omnibase_infra.enums.enum_response_status import EnumResponseStatus
+from omnibase_infra.enums.enum_retry_error_category import EnumRetryErrorCategory
+from omnibase_infra.enums.enum_security_rule_id import EnumSecurityRuleId
+from omnibase_infra.enums.enum_selection_strategy import EnumSelectionStrategy
+from omnibase_infra.enums.enum_topic_standard import EnumTopicStandard
+from omnibase_infra.enums.enum_validation_severity import EnumValidationSeverity
+
+__all__: list[str] = [
+    "EnumAnyTypeViolation",
+    "EnumBackendType",
+    "EnumCaptureOutcome",
+    "EnumCaptureState",
+    "EnumChainViolationType",
+    "EnumCircuitState",
+    "EnumConfirmationEventType",
+    "EnumConsumerGroupPurpose",
+    "EnumContractType",
+    "EnumDedupeStrategy",
+    "EnumDispatchStatus",
+    "EnumEnvironment",
+    "EnumExecutionShapeViolation",
+    "EnumHandlerErrorType",
+    "EnumHandlerLoaderError",
+    "EnumHandlerSourceMode",
+    "EnumHandlerSourceType",
+    "EnumHandlerType",
+    "EnumHandlerTypeCategory",
+    "EnumInfraTransportType",
+    "EnumIntrospectionReason",
+    "EnumKafkaAcks",
+    "EnumMessageCategory",
+    "EnumNodeArchetype",
+    "EnumNodeOutputType",
+    "EnumNonRetryableErrorCategory",
+    "EnumPolicyType",
+    "EnumRegistrationState",
+    "EnumRegistrationStatus",
+    "EnumRegistryResponseStatus",
+    "EnumResponseStatus",
+    "EnumRetryErrorCategory",
+    "EnumSecurityRuleId",
+    "EnumSelectionStrategy",
+    "EnumTopicStandard",
+    "EnumTopicType",
+    "EnumValidationSeverity",
+]

omnibase_infra/enums/enum_any_type_violation.py

@@ -0,0 +1,104 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Enum for Any type violation categories.
+
+Defines the specific violation types detected by the Any type validator.
+Following the ADR policy:
+- Any is BLOCKED in function signatures (parameters, return types)
+- Any is ALLOWED only in Pydantic Field() definitions WITH required NOTE comment
+- All other Any usage is BLOCKED
+"""
+
+from enum import Enum
+
+
+class EnumAnyTypeViolation(str, Enum):
+    """Violation types for Any type usage detection.
+
+    These violation types correspond to the ONEX Any type policy as defined
+    in the ADR. The policy aims to maintain strong typing throughout the
+    codebase while allowing controlled exceptions for legitimate use cases
+    like JSON-like data structures.
+
+    Attributes:
+        FUNCTION_PARAMETER: Any used as function parameter type annotation.
+        RETURN_TYPE: Any used as function return type annotation.
+        FIELD_MISSING_NOTE: Any used in Pydantic Field() without required NOTE comment.
+        VARIABLE_ANNOTATION: Any used as variable type annotation.
+        TYPE_ALIAS: Any used in type alias definition.
+        CLASS_ATTRIBUTE: Any used as class attribute type annotation.
+        GENERIC_ARGUMENT: Any used as generic type argument (e.g., list[Any]).
+        SYNTAX_ERROR: File has Python syntax error, cannot validate.
+
+    Policy Summary:
+        - ALLOWED: ``field: Any = Field(...) # NOTE: Using Any for JSON-like data``
+        - BLOCKED: ``def func(data: Any) -> Any:``
+        - BLOCKED: ``result: Any = some_call()``
+        - BLOCKED: ``JsonType = dict[str, Any]``
+    """
+
+    FUNCTION_PARAMETER = "function_parameter"
+    RETURN_TYPE = "return_type"
+    FIELD_MISSING_NOTE = "field_missing_note"
+    VARIABLE_ANNOTATION = "variable_annotation"
+    TYPE_ALIAS = "type_alias"
+    CLASS_ATTRIBUTE = "class_attribute"
+    GENERIC_ARGUMENT = "generic_argument"
+    SYNTAX_ERROR = "syntax_error"
+
+    @property
+    def is_exemptable(self) -> bool:
+        """Check if this violation type can be exempted.
+
+        Some violations like SYNTAX_ERROR cannot be exempted because
+        they indicate fundamental issues with the source file.
+
+        Returns:
+            True if the violation type can be exempted via decorator or comment.
+        """
+        return self != EnumAnyTypeViolation.SYNTAX_ERROR
+
+    @property
+    def suggestion(self) -> str:
+        """Get the suggested fix for this violation type.
+
+        Returns:
+            Human-readable suggestion for fixing the violation.
+        """
+        suggestions = {
+            EnumAnyTypeViolation.FUNCTION_PARAMETER: (
+                "Replace Any with specific type (e.g., object, Union, Protocol) "
+                "or use a typed model for complex data structures."
+            ),
+            EnumAnyTypeViolation.RETURN_TYPE: (
+                "Replace Any with specific type. If the return type varies, "
+                "consider using Union types or Protocol for duck typing."
+            ),
+            EnumAnyTypeViolation.FIELD_MISSING_NOTE: (
+                "Add a NOTE comment explaining why Any is needed. "
+                "Example: # NOTE: Using Any instead of JsonType for JSON payload"
+            ),
+            EnumAnyTypeViolation.VARIABLE_ANNOTATION: (
+                "Replace Any with specific type. Use object if truly generic, "
+                "or create a typed model for structured data."
+            ),
+            EnumAnyTypeViolation.TYPE_ALIAS: (
+                "Replace Any in type alias with specific types. "
+                "Consider using TypedDict, Protocol, or explicit Union types."
+            ),
+            EnumAnyTypeViolation.CLASS_ATTRIBUTE: (
+                "Replace Any with specific type annotation. "
+                "For Pydantic models, use Field() with a NOTE comment if Any is required."
+            ),
+            EnumAnyTypeViolation.GENERIC_ARGUMENT: (
+                "Replace Any in generic type with specific type. "
+                "Example: list[object] instead of list[Any]."
+            ),
+            EnumAnyTypeViolation.SYNTAX_ERROR: (
+                "Fix the Python syntax error before Any type validation can proceed."
+            ),
+        }
+        return suggestions.get(self, "Replace Any with a specific type.")
+
+
+__all__ = ["EnumAnyTypeViolation"]

omnibase_infra/enums/enum_backend_type.py

@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Backend type enumeration.
+
+This module defines the backend type enumeration for infrastructure
+registration and service discovery operations.
+"""
+
+from enum import Enum
+
+
+class EnumBackendType(str, Enum):
+    """Infrastructure backend types.
+
+    Identifies the backend infrastructure service for registration
+    and service discovery operations.
+
+    Attributes:
+        CONSUL: HashiCorp Consul for service discovery and health checking
+        POSTGRES: PostgreSQL database for persistent registration storage
+    """
+
+    CONSUL = "consul"
+    POSTGRES = "postgres"
+
+
+__all__: list[str] = ["EnumBackendType"]

omnibase_infra/enums/enum_capture_outcome.py

@@ -0,0 +1,42 @@
+# SPDX-FileCopyrightText: 2025 OmniNode Team <info@omninode.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+"""
+Capture outcome enum for corpus capture service.
+
+.. versionadded:: 0.5.0
+    Added for CorpusCapture (OMN-1203)
+"""
+
+from enum import Enum
+
+
+class EnumCaptureOutcome(str, Enum):
+    """Outcome of a capture attempt."""
+
+    CAPTURED = "captured"
+    """Execution was successfully captured."""
+
+    SKIPPED_HANDLER_FILTER = "skipped_handler_filter"
+    """Skipped due to handler filter (not in whitelist)."""
+
+    SKIPPED_TIME_WINDOW = "skipped_time_window"
+    """Skipped due to time window filter."""
+
+    SKIPPED_SAMPLE_RATE = "skipped_sample_rate"
+    """Skipped due to sampling (random selection)."""
+
+    SKIPPED_DUPLICATE = "skipped_duplicate"
+    """Skipped due to deduplication."""
+
+    SKIPPED_CORPUS_FULL = "skipped_corpus_full"
+    """Skipped because corpus is at max_executions."""
+
+    SKIPPED_NOT_CAPTURING = "skipped_not_capturing"
+    """Skipped because capture is not active."""
+
+    SKIPPED_TIMEOUT = "skipped_timeout"
+    """Skipped because capture operation timed out."""
+
+    FAILED = "failed"
+    """Capture failed due to an error."""

omnibase_infra/enums/enum_capture_state.py

@@ -0,0 +1,88 @@
+# SPDX-FileCopyrightText: 2025 OmniNode Team <info@omninode.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+"""
+Corpus capture state enum.
+
+Defines the lifecycle states for corpus capture operations.
+
+.. versionadded:: 0.5.0
+    Added for CorpusCapture (OMN-1203)
+"""
+
+from enum import Enum
+
+
+class EnumCaptureState(str, Enum):
+    """
+    Lifecycle states for corpus capture.
+
+    The capture service transitions through these states during its lifecycle:
+
+    State Transitions::
+
+        IDLE ──create_corpus()──> READY
+        READY ──start_capture()──> CAPTURING
+        CAPTURING ──pause_capture()──> PAUSED
+        CAPTURING ──max_executions reached──> FULL
+        PAUSED ──resume_capture()──> CAPTURING
+        PAUSED ──close_corpus()──> CLOSED
+        CAPTURING ──close_corpus()──> CLOSED
+        FULL ──close_corpus()──> CLOSED
+        READY ──close_corpus()──> CLOSED
+
+    .. versionadded:: 0.5.0
+        Added for CorpusCapture (OMN-1203)
+    """
+
+    IDLE = "idle"
+    """No active corpus. Initial state or after corpus is archived."""
+
+    READY = "ready"
+    """Corpus created and configured, but not yet capturing."""
+
+    CAPTURING = "capturing"
+    """Actively capturing executions into the corpus."""
+
+    PAUSED = "paused"
+    """Capture temporarily suspended. Can be resumed."""
+
+    FULL = "full"
+    """Corpus has reached max_executions limit. Can only close."""
+
+    CLOSED = "closed"
+    """Corpus finalized and sealed. No more captures allowed."""
+
+    def can_capture(self) -> bool:
+        """Check if captures are allowed in this state."""
+        return self == EnumCaptureState.CAPTURING
+
+    def can_transition_to(self, target: "EnumCaptureState") -> bool:
+        """
+        Check if transition to target state is valid.
+
+        Args:
+            target: The target state to transition to.
+
+        Returns:
+            True if the transition is valid.
+        """
+        valid_transitions: dict[EnumCaptureState, set[EnumCaptureState]] = {
+            EnumCaptureState.IDLE: {EnumCaptureState.READY},
+            EnumCaptureState.READY: {
+                EnumCaptureState.CAPTURING,
+                EnumCaptureState.CLOSED,
+            },
+            EnumCaptureState.CAPTURING: {
+                EnumCaptureState.PAUSED,
+                EnumCaptureState.FULL,
+                EnumCaptureState.CLOSED,
+            },
+            EnumCaptureState.PAUSED: {
+                EnumCaptureState.CAPTURING,
+                EnumCaptureState.CLOSED,
+            },
+            EnumCaptureState.FULL: {EnumCaptureState.CLOSED},
+            EnumCaptureState.CLOSED: set(),  # Terminal state
+        }
+        return target in valid_transitions.get(self, set())

omnibase_infra/enums/enum_chain_violation_type.py

@@ -0,0 +1,119 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Chain Violation Type Enumeration.
+
+Defines violation types for correlation and causation chain validation.
+Used by the chain validation system to classify violations in message
+propagation chains.
+
+Thread Safety:
+    All enums in this module are immutable and thread-safe.
+    Enum values can be safely shared across threads without synchronization.
+"""
+
+from __future__ import annotations
+
+from enum import Enum, unique
+
+# Module-level cached descriptions for O(1) lookup without repeated dict creation.
+# Must be defined outside the enum class since enums don't support ClassVar attributes
+# in the same way regular classes do.
+_CHAIN_VIOLATION_DESCRIPTIONS: dict[str, str] = {
+    "correlation_mismatch": (
+        "correlation_id doesn't match parent message's correlation_id"
+    ),
+    "causation_chain_broken": (
+        "causation_id doesn't equal parent message's message_id"
+    ),
+    "causation_ancestor_skipped": (
+        "causation chain skips one or more ancestors in the message lineage"
+    ),
+}
+
+
+@unique
+class EnumChainViolationType(str, Enum):
+    """Violation types for correlation and causation chain validation.
+
+    Represents specific types of violations that can occur when validating
+    that messages properly maintain their correlation and causation chains
+    during propagation through the system.
+
+    Values:
+        CORRELATION_MISMATCH: correlation_id doesn't match parent message's
+            correlation_id. All messages in a chain must share the same
+            correlation_id to enable distributed tracing.
+        CAUSATION_CHAIN_BROKEN: causation_id doesn't equal parent's message_id.
+            Each message's causation_id must reference its direct parent.
+        CAUSATION_ANCESTOR_SKIPPED: causation chain skips one or more ancestors.
+            The causation chain must form an unbroken sequence back to the
+            original message.
+
+    Example:
+        >>> violation_type = EnumChainViolationType.CORRELATION_MISMATCH
+        >>> str(violation_type)
+        'correlation_mismatch'
+        >>> violation_type.get_description()
+        "correlation_id doesn't match parent message's correlation_id"
+    """
+
+    CORRELATION_MISMATCH = "correlation_mismatch"
+    """correlation_id doesn't match parent message's correlation_id."""
+
+    CAUSATION_CHAIN_BROKEN = "causation_chain_broken"
+    """causation_id doesn't equal parent message's message_id."""
+
+    CAUSATION_ANCESTOR_SKIPPED = "causation_ancestor_skipped"
+    """causation chain skips one or more ancestors in the message lineage."""
+
+    def __str__(self) -> str:
+        """Return the string value for serialization."""
+        return self.value
+
+    def get_description(self) -> str:
+        """Get a human-readable description of the violation type.
+
+        Returns:
+            A human-readable description of what this violation type means.
+
+        Example:
+            >>> EnumChainViolationType.CORRELATION_MISMATCH.get_description()
+            "correlation_id doesn't match parent message's correlation_id"
+        """
+        return _CHAIN_VIOLATION_DESCRIPTIONS.get(
+            self.value, "Unknown chain violation type"
+        )
+
+    def is_correlation_violation(self) -> bool:
+        """Check if this is a correlation-related violation.
+
+        Returns:
+            True if the violation relates to correlation_id propagation.
+
+        Example:
+            >>> EnumChainViolationType.CORRELATION_MISMATCH.is_correlation_violation()
+            True
+            >>> EnumChainViolationType.CAUSATION_CHAIN_BROKEN.is_correlation_violation()
+            False
+        """
+        return self == EnumChainViolationType.CORRELATION_MISMATCH
+
+    def is_causation_violation(self) -> bool:
+        """Check if this is a causation-related violation.
+
+        Returns:
+            True if the violation relates to causation_id propagation.
+
+        Example:
+            >>> EnumChainViolationType.CAUSATION_CHAIN_BROKEN.is_causation_violation()
+            True
+            >>> EnumChainViolationType.CORRELATION_MISMATCH.is_causation_violation()
+            False
+        """
+        return self in {
+            EnumChainViolationType.CAUSATION_CHAIN_BROKEN,
+            EnumChainViolationType.CAUSATION_ANCESTOR_SKIPPED,
+        }
+
+
+__all__ = ["EnumChainViolationType"]

omnibase_infra/enums/enum_circuit_state.py

@@ -0,0 +1,51 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Circuit breaker state enumeration.
+
+This module defines the state enumeration for the circuit breaker pattern
+used in infrastructure components for fault tolerance.
+
+See Also:
+    - MixinAsyncCircuitBreaker: Mixin implementing the circuit breaker pattern
+    - docs/patterns/circuit_breaker_implementation.md: Implementation guide
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class EnumCircuitState(str, Enum):
+    """Circuit breaker state machine.
+
+    The circuit breaker implements a 3-state pattern for fault tolerance:
+
+    States:
+        CLOSED: Normal operation
+            - All requests are allowed
+            - Failures are counted
+            - Transitions to OPEN when failure threshold is reached
+
+        OPEN: Circuit tripped
+            - All requests are blocked
+            - Raises InfraUnavailableError immediately
+            - Automatically transitions to HALF_OPEN after reset timeout
+
+        HALF_OPEN: Testing recovery
+            - Limited requests allowed for testing
+            - First success transitions to CLOSED
+            - First failure transitions back to OPEN
+
+    State Transitions:
+        CLOSED -> OPEN: Failure count >= threshold
+        OPEN -> HALF_OPEN: Current time - last_failure_time > reset_timeout
+        HALF_OPEN -> CLOSED: First successful operation
+        HALF_OPEN -> OPEN: First failed operation
+    """
+
+    CLOSED = "closed"
+    OPEN = "open"
+    HALF_OPEN = "half_open"
+
+
+__all__: list[str] = ["EnumCircuitState"]

omnibase_infra/enums/enum_confirmation_event_type.py

@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Confirmation event type enumeration.
+
+This module defines the event type enumeration for registration confirmation
+events emitted by infrastructure backends.
+"""
+
+from enum import Enum
+
+
+class EnumConfirmationEventType(str, Enum):
+    """Registration confirmation event types.
+
+    Identifies the type of confirmation event emitted when a backend
+    successfully processes a registration operation.
+
+    Attributes:
+        CONSUL_REGISTERED: Service successfully registered with Consul
+        POSTGRES_REGISTRATION_UPSERTED: Registration record upserted in PostgreSQL
+    """
+
+    CONSUL_REGISTERED = "consul.registered"
+    POSTGRES_REGISTRATION_UPSERTED = "postgres.registration_upserted"
+
+
+__all__: list[str] = ["EnumConfirmationEventType"]