omnibase_infra 0.2.6__py3-none-any.whl

omnibase_infra/shared/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""ONEX Infrastructure Shared Module.
+
+Provides shared utilities and components used across infrastructure services.
+"""
+
+__all__: list[str] = []

omnibase_infra/testing/__init__.py

@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Testing utilities for omnibase_infra.
+
+This module provides shared testing utilities for the infrastructure layer,
+including CI environment detection and other common test helpers.
+"""
+
+from omnibase_infra.testing.utils import is_ci_environment
+
+__all__ = ["is_ci_environment"]

omnibase_infra/testing/utils.py

@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Shared testing utilities for omnibase_infra.
+
+This module provides utility functions commonly needed across test files,
+such as environment detection and test configuration helpers.
+"""
+
+import os
+
+
+def is_ci_environment() -> bool:
+    """Detect if running in CI environment.
+
+    Checks common CI environment variables:
+    - CI: Generic CI flag used by most CI systems
+    - GITHUB_ACTIONS: GitHub Actions specific
+
+    Returns:
+        True if running in a CI environment, False otherwise.
+    """
+    ci_value = os.getenv("CI", "").lower()
+    github_actions = os.getenv("GITHUB_ACTIONS", "").lower()
+    return ci_value in ("true", "1", "yes") or github_actions in ("true", "1", "yes")

omnibase_infra/topics/__init__.py

@@ -0,0 +1,45 @@
+"""ONEX Infrastructure Topic Constants.
+
+This module provides platform-reserved topic suffix constants for ONEX infrastructure
+components. Domain services should NOT import from this module - domain topics should
+be defined in domain contracts.
+
+Exports:
+    Platform topic suffix constants (e.g., SUFFIX_NODE_REGISTRATION)
+    ALL_PLATFORM_SUFFIXES: Complete tuple of all platform-reserved suffixes
+    build_full_topic: Compose full topic from env, namespace, and suffix
+    TopicCompositionError: Error raised when topic composition fails
+"""
+
+from omnibase_infra.topics.platform_topic_suffixes import (
+    ALL_PLATFORM_SUFFIXES,
+    SUFFIX_FSM_STATE_TRANSITIONS,
+    SUFFIX_NODE_HEARTBEAT,
+    SUFFIX_NODE_INTROSPECTION,
+    SUFFIX_NODE_REGISTRATION,
+    SUFFIX_REGISTRATION_SNAPSHOTS,
+    SUFFIX_REQUEST_INTROSPECTION,
+    SUFFIX_RUNTIME_TICK,
+)
+from omnibase_infra.topics.util_topic_composition import (
+    MAX_NAMESPACE_LENGTH,
+    TopicCompositionError,
+    build_full_topic,
+)
+
+__all__: list[str] = [
+    # Individual suffix constants
+    "SUFFIX_NODE_REGISTRATION",
+    "SUFFIX_NODE_INTROSPECTION",
+    "SUFFIX_NODE_HEARTBEAT",
+    "SUFFIX_REQUEST_INTROSPECTION",
+    "SUFFIX_FSM_STATE_TRANSITIONS",
+    "SUFFIX_RUNTIME_TICK",
+    "SUFFIX_REGISTRATION_SNAPSHOTS",
+    # Aggregate tuple
+    "ALL_PLATFORM_SUFFIXES",
+    # Topic composition utilities
+    "build_full_topic",
+    "TopicCompositionError",
+    "MAX_NAMESPACE_LENGTH",
+]

omnibase_infra/topics/platform_topic_suffixes.py

@@ -0,0 +1,140 @@
+"""Platform-reserved topic suffixes for ONEX infrastructure.
+
+WARNING: These are platform-reserved suffixes. Domain services must NOT
+import from this module. Domain topics should be defined in domain contracts.
+
+Topic Suffix Format:
+    onex.<kind>.<producer>.<event-name>.v<version>
+
+    Structure:
+        - onex: Required prefix for all ONEX topics
+        - kind: Message category (evt, cmd, intent, snapshot, dlq)
+        - producer: Service/module that produces the message
+        - event-name: Descriptive name using kebab-case
+        - version: Semantic version (v1, v2, etc.)
+
+    Kinds:
+        evt - Event topics (state changes, notifications)
+        cmd - Command topics (requests for action)
+        intent - Intent topics (internal workflow coordination)
+        snapshot - Snapshot topics (periodic state snapshots)
+        dlq - Dead letter queue topics
+
+    Examples:
+        onex.evt.platform.node-registration.v1
+        onex.cmd.platform.request-introspection.v1
+        onex.intent.platform.runtime-tick.v1
+
+Usage:
+    from omnibase_infra.topics import SUFFIX_NODE_REGISTRATION
+
+    # Compose full topic with tenant/namespace prefix
+    full_topic = f"{tenant}.{namespace}.{SUFFIX_NODE_REGISTRATION}"
+
+See Also:
+    omnibase_core.validation.validate_topic_suffix - Validation function
+    omnibase_core.validation.compose_full_topic - Topic composition utility
+"""
+
+from omnibase_core.errors import OnexError
+from omnibase_core.validation import validate_topic_suffix
+
+# =============================================================================
+# PLATFORM-RESERVED TOPIC SUFFIXES
+# =============================================================================
+
+# Node lifecycle events
+SUFFIX_NODE_REGISTRATION: str = "onex.evt.platform.node-registration.v1"
+"""Topic suffix for node registration events.
+
+Published when a node registers with the runtime. Contains node metadata,
+capabilities, and health check configuration.
+"""
+
+SUFFIX_NODE_INTROSPECTION: str = "onex.evt.platform.node-introspection.v1"
+"""Topic suffix for node introspection events.
+
+Published when a node responds to an introspection request. Contains node
+capabilities, supported operations, and current state.
+"""
+
+SUFFIX_NODE_HEARTBEAT: str = "onex.evt.platform.node-heartbeat.v1"
+"""Topic suffix for node heartbeat events.
+
+Published periodically by nodes to indicate liveness. Contains timestamp,
+resource usage metrics, and health status.
+"""
+
+# Command topics
+SUFFIX_REQUEST_INTROSPECTION: str = "onex.cmd.platform.request-introspection.v1"
+"""Topic suffix for introspection request commands.
+
+Published to request introspection from a specific node or all nodes.
+Nodes respond on the SUFFIX_NODE_INTROSPECTION topic.
+"""
+
+# FSM and state management
+SUFFIX_FSM_STATE_TRANSITIONS: str = "onex.evt.platform.fsm-state-transitions.v1"
+"""Topic suffix for FSM state transition events.
+
+Published when a node's finite state machine transitions between states.
+Contains previous state, new state, trigger event, and transition metadata.
+"""
+
+# Runtime coordination
+SUFFIX_RUNTIME_TICK: str = "onex.intent.platform.runtime-tick.v1"
+"""Topic suffix for runtime tick intents.
+
+Internal topic for runtime orchestration. Triggers periodic tasks like
+heartbeat collection, health checks, and scheduled workflows.
+"""
+
+# Registration snapshots
+SUFFIX_REGISTRATION_SNAPSHOTS: str = "onex.snapshot.platform.registration-snapshots.v1"
+"""Topic suffix for registration snapshot events.
+
+Published periodically with aggregated registration state. Used for
+dashboard displays and monitoring systems.
+"""
+
+# =============================================================================
+# AGGREGATE TUPLE
+# =============================================================================
+
+ALL_PLATFORM_SUFFIXES: tuple[str, ...] = (
+    SUFFIX_NODE_REGISTRATION,
+    SUFFIX_NODE_INTROSPECTION,
+    SUFFIX_NODE_HEARTBEAT,
+    SUFFIX_REQUEST_INTROSPECTION,
+    SUFFIX_FSM_STATE_TRANSITIONS,
+    SUFFIX_RUNTIME_TICK,
+    SUFFIX_REGISTRATION_SNAPSHOTS,
+)
+"""Complete tuple of all platform-reserved topic suffixes.
+
+Use this tuple for:
+    - Validating that domain topics don't conflict with platform topics
+    - Iterating over all platform topics for subscription setup
+    - Documentation and discovery
+"""
+
+# =============================================================================
+# IMPORT-TIME VALIDATION
+# =============================================================================
+
+
+def _validate_all_suffixes() -> None:
+    """Validate all suffixes at import time to fail fast on invalid format.
+
+    Raises:
+        OnexError: If any suffix fails validation with details about which
+            suffix failed and why.
+    """
+    for suffix in ALL_PLATFORM_SUFFIXES:
+        result = validate_topic_suffix(suffix)
+        if not result.is_valid:
+            raise OnexError(f"Invalid platform topic suffix '{suffix}': {result.error}")
+
+
+# Run validation at import time
+_validate_all_suffixes()

omnibase_infra/topics/util_topic_composition.py

@@ -0,0 +1,95 @@
+"""Topic composition utilities for ONEX infrastructure.
+
+IMPORTANT: build_full_topic() is the ONLY supported way to compose
+Kafka topics in omnibase_infra. Direct string concatenation is prohibited.
+"""
+
+from omnibase_core.errors import OnexError
+from omnibase_core.validation import validate_topic_suffix
+from omnibase_core.validation.validator_topic_suffix import ENV_PREFIXES
+
+MAX_NAMESPACE_LENGTH = 100
+"""Maximum allowed namespace length.
+
+Kafka topics have a 249 character limit. With env prefix (~10 chars),
+separators (2 dots), and suffix (~50 chars), namespace should be limited
+to ensure total topic length stays within bounds.
+"""
+
+
+class TopicCompositionError(OnexError):
+    """Raised when topic composition fails due to invalid components.
+
+    Extends OnexError to follow ONEX error handling conventions.
+    """
+
+
+def build_full_topic(env: str, namespace: str, suffix: str) -> str:
+    """Build full topic from components with validation.
+
+    Args:
+        env: Environment prefix (e.g., "dev", "staging", "prod", "test", "local")
+        namespace: Namespace/tenant identifier (e.g., "omnibase", "myapp", "tenant-123")
+        suffix: Validated topic suffix (e.g., "onex.evt.platform.node-introspection.v1")
+
+    Returns:
+        Full topic string: {env}.{namespace}.{suffix}
+
+    Raises:
+        TopicCompositionError: If env is not a valid environment prefix
+        TopicCompositionError: If namespace is empty or contains invalid characters
+        TopicCompositionError: If suffix doesn't match ONEX topic format
+
+    Namespace Validation Rules:
+        - Must not be empty
+        - Allowed characters: alphanumeric (a-z, A-Z, 0-9), hyphens (-), underscores (_)
+        - Numeric-only namespaces ARE valid (e.g., "12345") to support numeric tenant IDs
+        - Invalid: spaces, dots, special characters
+
+    Example:
+        >>> build_full_topic("dev", "omnibase", "onex.evt.platform.node-introspection.v1")
+        'dev.omnibase.onex.evt.platform.node-introspection.v1'
+
+        >>> build_full_topic("prod", "myapp", "onex.cmd.platform.request-introspection.v1")
+        'prod.myapp.onex.cmd.platform.request-introspection.v1'
+    """
+    # Validate environment prefix
+    if env not in ENV_PREFIXES:
+        raise TopicCompositionError(
+            f"Invalid environment prefix '{env}'. "
+            f"Must be one of: {', '.join(sorted(ENV_PREFIXES))}"
+        )
+
+    # Validate namespace
+    # Allowed characters: alphanumeric (a-z, A-Z, 0-9), hyphens, underscores
+    # Note: Numeric-only namespaces (e.g., "12345") ARE valid because isalnum()
+    # returns True for digit-only strings. This is intentional to support
+    # numeric tenant/organization IDs as namespaces.
+    if not namespace:
+        raise TopicCompositionError("Namespace cannot be empty")
+    if len(namespace) > MAX_NAMESPACE_LENGTH:
+        raise TopicCompositionError(
+            f"Namespace exceeds maximum length of {MAX_NAMESPACE_LENGTH} characters. "
+            f"Got {len(namespace)} characters."
+        )
+    if not namespace.replace("-", "").replace("_", "").isalnum():
+        raise TopicCompositionError(
+            f"Invalid namespace '{namespace}'. "
+            "Must contain only alphanumeric characters, hyphens, and underscores"
+        )
+
+    # Enforce lowercase to ensure composed topics are valid
+    # (ONEX topic suffixes are lowercase, so namespaces should match)
+    if namespace != namespace.lower():
+        raise TopicCompositionError(
+            f"Namespace must be lowercase: '{namespace}'. "
+            "Use lowercase to ensure consistent topic naming."
+        )
+
+    # Validate suffix using omnibase_core validation
+    result = validate_topic_suffix(suffix)
+    if not result.is_valid:
+        raise TopicCompositionError(f"Invalid topic suffix '{suffix}': {result.error}")
+
+    # Compose full topic
+    return f"{env}.{namespace}.{suffix}"

omnibase_infra/types/__init__.py

@@ -0,0 +1,48 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Types module for omnibase_infra.
+
+This module re-exports commonly used types for external consumption.
+Types are organized into categories:
+
+Top-level exports (this module):
+    - ModelParsedDSN: Pydantic model for parsed DSN components
+    - TypeCacheInfo: NamedTuple for cache hit/miss statistics
+    - TypedDictCapabilities: TypedDict for node capability introspection
+
+Type aliases (from type_infra_aliases):
+    - ASTFunctionDef: ast.AsyncFunctionDef | ast.FunctionDef
+    - MessageOutputCategory: EnumMessageCategory | EnumNodeOutputType
+    - PathInput: Path | str (named to avoid collision with stdlib os.PathLike)
+    - PolicyTypeInput: EnumPolicyType | str
+
+Note on cache-related TypedDicts:
+    TypedDictIntrospectionCache and TypedDictPerformanceMetricsCache are NOT
+    re-exported here because they are internal implementation details of the
+    MixinNodeIntrospection mixin. These types are tightly coupled to the mixin's
+    caching implementation and should not be used directly by external consumers.
+    If needed for testing or advanced use cases, import from the typed_dict submodule:
+        from omnibase_infra.types.typed_dict import TypedDictIntrospectionCache
+"""
+
+from omnibase_infra.types.type_cache_info import TypeCacheInfo
+from omnibase_infra.types.type_dsn import ModelParsedDSN
+from omnibase_infra.types.type_infra_aliases import (
+    ASTFunctionDef,
+    MessageOutputCategory,
+    PathInput,
+    PolicyTypeInput,
+)
+from omnibase_infra.types.typed_dict_capabilities import TypedDictCapabilities
+
+__all__: list[str] = [
+    # Type aliases
+    "ASTFunctionDef",
+    "MessageOutputCategory",
+    "PathInput",
+    "PolicyTypeInput",
+    # Models and TypedDicts
+    "ModelParsedDSN",
+    "TypeCacheInfo",
+    "TypedDictCapabilities",
+]

omnibase_infra/types/type_cache_info.py

@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2025 OmniNode Team
+
+"""Cache information type for topic parser caching statistics.
+
+This module provides a type-safe NamedTuple for representing cache statistics,
+mirroring the structure of functools._CacheInfo for compatibility with LRU
+cache implementations.
+
+Example:
+    >>> from omnibase_infra.types import TypeCacheInfo
+    >>> info = TypeCacheInfo(hits=100, misses=10, maxsize=128, currsize=50)
+    >>> print(f"Hit rate: {info.hits / (info.hits + info.misses):.2%}")
+    Hit rate: 90.91%
+"""
+
+from typing import NamedTuple
+
+__all__ = ["TypeCacheInfo"]
+
+
+class TypeCacheInfo(NamedTuple):
+    """Cache statistics for topic parsing operations.
+
+    This mirrors functools._CacheInfo structure for type safety when
+    exposing cache statistics from LRU-cached parsing functions.
+
+    Attributes:
+        hits: Number of cache hits (requests served from cache).
+        misses: Number of cache misses (requests requiring computation).
+        maxsize: Maximum cache size, or None for unlimited cache.
+        currsize: Current number of entries in the cache.
+
+    Example:
+        >>> info = TypeCacheInfo(hits=50, misses=5, maxsize=128, currsize=30)
+        >>> info.hits
+        50
+        >>> info.maxsize
+        128
+
+    Note:
+        This type is intentionally compatible with functools._CacheInfo
+        to allow seamless interoperability with standard library caching.
+    """
+
+    hits: int
+    misses: int
+    maxsize: int | None
+    currsize: int

omnibase_infra/types/type_dsn.py

@@ -0,0 +1,173 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2025 OmniNode Team
+
+"""Strongly-typed DSN parse result model.
+
+This module provides a Pydantic model for representing parsed PostgreSQL
+Data Source Name (DSN) connection strings with full type safety and
+validation.
+
+The model replaces loose dict[str, object] return types with a structured,
+immutable, and validated representation of DSN components.
+
+Example:
+    >>> from omnibase_infra.types import ModelParsedDSN
+    >>> dsn = ModelParsedDSN(
+    ...     scheme="postgresql",
+    ...     username="admin",
+    ...     password="secret",
+    ...     hostname="localhost",
+    ...     port=5432,
+    ...     database="mydb",
+    ... )
+    >>> dsn.hostname
+    'localhost'
+    >>> dsn.port
+    5432
+
+Note:
+    The model is frozen (immutable) to ensure DSN components cannot be
+    accidentally modified after parsing. This provides safety when passing
+    DSN information through multiple layers of the application.
+"""
+
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+__all__ = ["ModelParsedDSN"]
+
+
+class ModelParsedDSN(BaseModel):
+    """Strongly-typed DSN parse result for PostgreSQL connection strings.
+
+    This model provides a structured representation of parsed DSN components
+    with validation for port ranges and scheme restrictions. The model is
+    immutable (frozen) to prevent accidental modification of connection
+    parameters.
+
+    Attributes:
+        scheme: The database scheme/protocol. Must be 'postgresql' or 'postgres'.
+        username: The database username for authentication. None if not specified.
+        password: The database password for authentication. None if not specified.
+            Note: Handle with care as this contains sensitive credentials.
+        hostname: The database server hostname or IP address. None if not specified.
+        port: The database server port number (1-65535). None if not specified.
+        database: The name of the database to connect to.
+        query: Additional connection parameters as key-value pairs. Values may be
+            strings or lists of strings for multi-value parameters.
+
+    Example:
+        >>> dsn = ModelParsedDSN(
+        ...     scheme="postgresql",
+        ...     username="app_user",
+        ...     hostname="db.example.com",
+        ...     port=5432,
+        ...     database="production",
+        ...     query={"sslmode": "require"},
+        ... )
+        >>> dsn.scheme
+        'postgresql'
+        >>> dsn.query
+        {'sslmode': 'require'}
+
+    Note:
+        The password field should be handled carefully in logging and
+        error messages to avoid credential exposure. Use the sanitization
+        utilities from util_dsn_validation for safe string representations.
+    """
+
+    scheme: Literal["postgresql", "postgres"] = Field(
+        description="Database scheme/protocol. Must be 'postgresql' or 'postgres'."
+    )
+    username: str | None = Field(
+        default=None,
+        description="Database username for authentication.",
+    )
+    password: str | None = Field(
+        default=None,
+        description="Database password for authentication. Handle with care.",
+    )
+    hostname: str | None = Field(
+        default=None,
+        description="Database server hostname or IP address.",
+    )
+    port: int | None = Field(
+        default=None,
+        ge=1,
+        le=65535,
+        description="Database server port number (valid range: 1-65535).",
+    )
+    database: str = Field(
+        description="Name of the database to connect to.",
+    )
+    query: dict[str, str | list[str]] = Field(
+        default_factory=dict,
+        description="Additional connection parameters as key-value pairs.",
+    )
+
+    model_config = ConfigDict(frozen=True, extra="forbid", from_attributes=True)
+
+    def __repr__(self) -> str:
+        """Return string representation with masked password.
+
+        This method overrides the default Pydantic __repr__ to prevent
+        credential exposure in logs, debug output, and error messages.
+        The actual password value remains accessible via the .password
+        attribute for legitimate use cases.
+
+        Returns:
+            String representation with password shown as '[REDACTED]' if set,
+            or None if not set.
+
+        Example:
+            >>> dsn = ModelParsedDSN(
+            ...     scheme="postgresql",
+            ...     username="admin",
+            ...     password="secret123",
+            ...     hostname="localhost",
+            ...     port=5432,
+            ...     database="mydb",
+            ... )
+            >>> repr(dsn)  # Shows '[REDACTED]' instead of 'secret123'
+            "ModelParsedDSN(scheme='postgresql', username='admin', ...)"
+        """
+        password_display = "[REDACTED]" if self.password else None
+        return (
+            f"ModelParsedDSN(scheme={self.scheme!r}, username={self.username!r}, "
+            f"password={password_display!r}, hostname={self.hostname!r}, "
+            f"port={self.port!r}, database={self.database!r}, query={self.query!r})"
+        )
+
+    def __str__(self) -> str:
+        """Return string representation with masked password.
+
+        Delegates to __repr__ to ensure consistent password masking across
+        all string conversion contexts (str(), print(), f-strings, etc.).
+
+        Returns:
+            String representation with password masked.
+        """
+        return self.__repr__()
+
+    def to_sanitized_dict(self) -> dict[str, object]:
+        """Return a dict representation with the password masked.
+
+        Useful for logging and debugging without exposing credentials.
+
+        Returns:
+            dict[str, object]: Model data with password replaced by '[REDACTED]' if set.
+
+        Example:
+            >>> dsn = ModelParsedDSN(
+            ...     scheme="postgresql", username="user", password="secret",
+            ...     hostname="localhost", port=5432, database="mydb"
+            ... )
+            >>> dsn.to_sanitized_dict()
+            {'scheme': 'postgresql', 'username': 'user', 'password': '[REDACTED]',
+             'hostname': 'localhost', 'port': 5432, 'database': 'mydb', 'query': {}}
+        """
+        data = self.model_dump()
+        if data.get("password"):
+            data["password"] = "[REDACTED]"
+        return data

omnibase_infra/types/type_infra_aliases.py

@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""
+Infrastructure-specific type aliases for union complexity reduction.
+
+These type aliases consolidate repeated union patterns found in omnibase_infra,
+following the same pattern as omnibase_core.types.type_json.
+
+When to use each alias:
+    MessageOutputCategory: Use for message routing, dispatcher selection,
+        and node output validation. Accepts both EnumMessageCategory (EVENT,
+        COMMAND, INTENT) and EnumNodeOutputType (includes PROJECTION).
+
+    PathInput: Use for function parameters that accept filesystem paths.
+        Allows callers to pass either Path objects or string paths.
+
+    PolicyTypeInput: Use for policy configuration APIs that need flexibility
+        between enum values and string representations.
+
+    ASTFunctionDef: Use when analyzing Python AST for function definitions,
+        covering both sync and async functions.
+
+See OMN-1358 for the union reduction initiative that drove these definitions.
+"""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from omnibase_infra.enums import EnumMessageCategory, EnumNodeOutputType, EnumPolicyType
+
+# Message category or node output type (for routing and validation)
+# Replaces 24 occurrences of: EnumMessageCategory | EnumNodeOutputType
+type MessageOutputCategory = EnumMessageCategory | EnumNodeOutputType
+
+# Filesystem path input flexibility
+# Replaces 11 occurrences of: Path | str
+# Note: Named PathInput (not PathLike) to avoid collision with stdlib os.PathLike Protocol.
+# PathInput represents filesystem path flexibility (Path | str), whereas os.PathLike is
+# a Protocol for objects implementing __fspath__().
+type PathInput = Path | str
+
+# Policy type with string fallback for API flexibility
+# Replaces 8 occurrences of: EnumPolicyType | str
+# NOTE: This is an INPUT type alias for API flexibility. Pydantic validators
+# using validate_policy_type_value() COERCE strings to EnumPolicyType, so
+# the actual stored value is always an enum, ensuring type-safe field access.
+type PolicyTypeInput = EnumPolicyType | str
+
+# AST function definition node types
+# Replaces 7 occurrences of: ast.AsyncFunctionDef | ast.FunctionDef
+type ASTFunctionDef = ast.AsyncFunctionDef | ast.FunctionDef
+
+__all__ = [
+    "ASTFunctionDef",
+    "MessageOutputCategory",
+    "PathInput",
+    "PolicyTypeInput",
+]