cribl-control-plane 0.0.39__py3-none-any.whl → 0.4.0b23__py3-none-any.whl

cribl_control_plane/models/difffiles.py

@@ -0,0 +1,130 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .diffline import DiffLine, DiffLineTypedDict
+from cribl_control_plane.types import BaseModel
+import pydantic
+from typing import List, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+class BlockTypedDict(TypedDict):
+    header: str
+    lines: List[DiffLineTypedDict]
+    r"""Diff Line"""
+    new_start_line: float
+    old_start_line: float
+    old_start_line2: NotRequired[float]
+
+
+class Block(BaseModel):
+    header: str
+
+    lines: List[DiffLine]
+    r"""Diff Line"""
+
+    new_start_line: Annotated[float, pydantic.Field(alias="newStartLine")]
+
+    old_start_line: Annotated[float, pydantic.Field(alias="oldStartLine")]
+
+    old_start_line2: Annotated[
+        Optional[float], pydantic.Field(alias="oldStartLine2")
+    ] = None
+
+
+ChecksumBeforeTypedDict = TypeAliasType(
+    "ChecksumBeforeTypedDict", Union[str, List[str]]
+)
+
+
+ChecksumBefore = TypeAliasType("ChecksumBefore", Union[str, List[str]])
+
+
+OldModeTypedDict = TypeAliasType("OldModeTypedDict", Union[str, List[str]])
+
+
+OldMode = TypeAliasType("OldMode", Union[str, List[str]])
+
+
+class DiffFilesTypedDict(TypedDict):
+    added_lines: float
+    blocks: List[BlockTypedDict]
+    deleted_lines: float
+    is_combined: bool
+    is_git_diff: bool
+    language: str
+    new_name: str
+    old_name: str
+    changed_percentage: NotRequired[float]
+    checksum_after: NotRequired[str]
+    checksum_before: NotRequired[ChecksumBeforeTypedDict]
+    deleted_file_mode: NotRequired[str]
+    is_binary: NotRequired[bool]
+    is_copy: NotRequired[bool]
+    is_deleted: NotRequired[bool]
+    is_new: NotRequired[bool]
+    is_rename: NotRequired[bool]
+    is_too_big: NotRequired[bool]
+    mode: NotRequired[str]
+    new_file_mode: NotRequired[str]
+    new_mode: NotRequired[str]
+    old_mode: NotRequired[OldModeTypedDict]
+    unchanged_percentage: NotRequired[float]
+
+
+class DiffFiles(BaseModel):
+    added_lines: Annotated[float, pydantic.Field(alias="addedLines")]
+
+    blocks: List[Block]
+
+    deleted_lines: Annotated[float, pydantic.Field(alias="deletedLines")]
+
+    is_combined: Annotated[bool, pydantic.Field(alias="isCombined")]
+
+    is_git_diff: Annotated[bool, pydantic.Field(alias="isGitDiff")]
+
+    language: str
+
+    new_name: Annotated[str, pydantic.Field(alias="newName")]
+
+    old_name: Annotated[str, pydantic.Field(alias="oldName")]
+
+    changed_percentage: Annotated[
+        Optional[float], pydantic.Field(alias="changedPercentage")
+    ] = None
+
+    checksum_after: Annotated[Optional[str], pydantic.Field(alias="checksumAfter")] = (
+        None
+    )
+
+    checksum_before: Annotated[
+        Optional[ChecksumBefore], pydantic.Field(alias="checksumBefore")
+    ] = None
+
+    deleted_file_mode: Annotated[
+        Optional[str], pydantic.Field(alias="deletedFileMode")
+    ] = None
+
+    is_binary: Annotated[Optional[bool], pydantic.Field(alias="isBinary")] = None
+
+    is_copy: Annotated[Optional[bool], pydantic.Field(alias="isCopy")] = None
+
+    is_deleted: Annotated[Optional[bool], pydantic.Field(alias="isDeleted")] = None
+
+    is_new: Annotated[Optional[bool], pydantic.Field(alias="isNew")] = None
+
+    is_rename: Annotated[Optional[bool], pydantic.Field(alias="isRename")] = None
+
+    is_too_big: Annotated[Optional[bool], pydantic.Field(alias="isTooBig")] = None
+
+    mode: Optional[str] = None
+
+    new_file_mode: Annotated[Optional[str], pydantic.Field(alias="newFileMode")] = None
+
+    new_mode: Annotated[Optional[str], pydantic.Field(alias="newMode")] = None
+
+    old_mode: Annotated[Optional[OldMode], pydantic.Field(alias="oldMode")] = None
+
+    unchanged_percentage: Annotated[
+        Optional[float], pydantic.Field(alias="unchangedPercentage")
+    ] = None

cribl_control_plane/models/diffline.py

@@ -0,0 +1,26 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .difflinecontext import DiffLineContext, DiffLineContextTypedDict
+from .difflinedelete import DiffLineDelete, DiffLineDeleteTypedDict
+from .difflineinsert import DiffLineInsert, DiffLineInsertTypedDict
+from cribl_control_plane.utils import get_discriminator
+from pydantic import Discriminator, Tag
+from typing import Union
+from typing_extensions import Annotated, TypeAliasType
+
+
+DiffLineTypedDict = TypeAliasType(
+    "DiffLineTypedDict",
+    Union[DiffLineDeleteTypedDict, DiffLineInsertTypedDict, DiffLineContextTypedDict],
+)
+
+
+DiffLine = Annotated[
+    Union[
+        Annotated[DiffLineDelete, Tag("delete")],
+        Annotated[DiffLineInsert, Tag("insert")],
+        Annotated[DiffLineContext, Tag("context")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]

cribl_control_plane/models/difflinecontext.py

@@ -0,0 +1,28 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+from enum import Enum
+import pydantic
+from typing_extensions import Annotated, TypedDict
+
+
+class DiffLineContextType(str, Enum):
+    CONTEXT = "context"
+
+
+class DiffLineContextTypedDict(TypedDict):
+    type: DiffLineContextType
+    new_number: float
+    old_number: float
+    content: str
+
+
+class DiffLineContext(BaseModel):
+    type: DiffLineContextType
+
+    new_number: Annotated[float, pydantic.Field(alias="newNumber")]
+
+    old_number: Annotated[float, pydantic.Field(alias="oldNumber")]
+
+    content: str

cribl_control_plane/models/difflinedelete.py

@@ -0,0 +1,25 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+from enum import Enum
+import pydantic
+from typing_extensions import Annotated, TypedDict
+
+
+class DiffLineDeleteType(str, Enum):
+    DELETE = "delete"
+
+
+class DiffLineDeleteTypedDict(TypedDict):
+    type: DiffLineDeleteType
+    old_number: float
+    content: str
+
+
+class DiffLineDelete(BaseModel):
+    type: DiffLineDeleteType
+
+    old_number: Annotated[float, pydantic.Field(alias="oldNumber")]
+
+    content: str

cribl_control_plane/models/difflineinsert.py

@@ -0,0 +1,25 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+from enum import Enum
+import pydantic
+from typing_extensions import Annotated, TypedDict
+
+
+class DiffLineInsertType(str, Enum):
+    INSERT = "insert"
+
+
+class DiffLineInsertTypedDict(TypedDict):
+    type: DiffLineInsertType
+    new_number: float
+    content: str
+
+
+class DiffLineInsert(BaseModel):
+    type: DiffLineInsertType
+
+    new_number: Annotated[float, pydantic.Field(alias="newNumber")]
+
+    content: str

cribl_control_plane/models/distributedsummary.py

@@ -9,7 +9,9 @@ from typing_extensions import Annotated, TypedDict
 class DistributedSummaryGroupsTypedDict(TypedDict):
     count: float
     destinations: float
+    packs: float
     pipelines: float
+    quick_connects: float
     routes: float
     sources: float
 
@@ -19,8 +21,12 @@ class DistributedSummaryGroups(BaseModel):
 
     destinations: float
 
+    packs: float
+
     pipelines: float
 
+    quick_connects: Annotated[float, pydantic.Field(alias="quickConnects")]
+
     routes: float
 
     sources: float

cribl_control_plane/models/functionaggregatemetrics.py

@@ -0,0 +1,206 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane import models, utils
+from cribl_control_plane.types import BaseModel
+from cribl_control_plane.utils import validate_open_enum
+from enum import Enum
+import pydantic
+from pydantic import field_serializer
+from pydantic.functional_validators import PlainValidator
+from typing import Any, Dict, List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionAggregateMetricsID(str, Enum):
+    AGGREGATE_METRICS = "aggregate_metrics"
+
+
+class FunctionAggregateMetricsMetricType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""The output metric type"""
+
+    AUTOMATIC = "automatic"
+    COUNTER = "counter"
+    DISTRIBUTION = "distribution"
+    GAUGE = "gauge"
+    HISTOGRAM = "histogram"
+    SUMMARY = "summary"
+    TIMER = "timer"
+
+
+class AggregationTypedDict(TypedDict):
+    agg: str
+    r"""Aggregate function to perform on events. Example: sum(bytes).where(action=='REJECT').as(TotalBytes)"""
+    metric_type: NotRequired[FunctionAggregateMetricsMetricType]
+    r"""The output metric type"""
+
+
+class Aggregation(BaseModel):
+    agg: str
+    r"""Aggregate function to perform on events. Example: sum(bytes).where(action=='REJECT').as(TotalBytes)"""
+
+    metric_type: Annotated[
+        Annotated[
+            Optional[FunctionAggregateMetricsMetricType],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="metricType"),
+    ] = FunctionAggregateMetricsMetricType.AUTOMATIC
+    r"""The output metric type"""
+
+    @field_serializer("metric_type")
+    def serialize_metric_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.FunctionAggregateMetricsMetricType(value)
+            except ValueError:
+                return value
+        return value
+
+
+class FunctionAggregateMetricsAddTypedDict(TypedDict):
+    value: str
+    r"""JavaScript expression to compute the value (can be constant)"""
+    name: NotRequired[str]
+
+
+class FunctionAggregateMetricsAdd(BaseModel):
+    value: str
+    r"""JavaScript expression to compute the value (can be constant)"""
+
+    name: Optional[str] = None
+
+
+class FunctionAggregateMetricsSchemaTypedDict(TypedDict):
+    aggregations: List[AggregationTypedDict]
+    r"""Combination of Aggregation function and output metric type"""
+    passthrough: NotRequired[bool]
+    r"""Pass through the original events along with the aggregation events"""
+    preserve_group_bys: NotRequired[bool]
+    r"""Preserve the structure of the original aggregation event's groupby fields"""
+    sufficient_stats_only: NotRequired[bool]
+    r"""Output only statistics that are sufficient for the supplied aggregations"""
+    prefix: NotRequired[str]
+    r"""A prefix that is prepended to all of the fields output by this Aggregations Function"""
+    time_window: NotRequired[str]
+    r"""The time span of the tumbling window for aggregating events. Must be a valid time string (such as 10s)."""
+    groupbys: NotRequired[List[str]]
+    r"""Optional: One or more dimensions to group aggregates by. Supports wildcard expressions. Wrap dimension names in quotes if using literal identifiers, such as 'service.name'. Warning: Using wildcard '*' causes all dimensions in the event to be included, which can result in high cardinality and increased memory usage. Exclude dimensions that can result in high cardinality before using wildcards. Example: !_time, !_numericValue, *"""
+    flush_event_limit: NotRequired[float]
+    r"""The maximum number of events to include in any given aggregation event"""
+    flush_mem_limit: NotRequired[str]
+    r"""The memory usage limit to impose upon aggregations. Defaults to 80% of the process memory; value configured above default limit is ignored. Accepts numerals with units like KB and MB (example: 128MB)."""
+    cumulative: NotRequired[bool]
+    r"""Enable to retain aggregations for cumulative aggregations when flushing out an aggregation table event. When disabled (the default), aggregations are reset to 0 on flush."""
+    should_treat_dots_as_literals: NotRequired[bool]
+    r"""Treat dots in dimension names as literals. This is useful for top-level dimensions that contain dots, such as 'service.name'."""
+    add: NotRequired[List[FunctionAggregateMetricsAddTypedDict]]
+    r"""Set of key-value pairs to evaluate and add/set"""
+    flush_on_input_close: NotRequired[bool]
+    r"""Flush aggregations when an input stream is closed. If disabled, Time Window Settings control flush behavior."""
+
+
+class FunctionAggregateMetricsSchema(BaseModel):
+    aggregations: List[Aggregation]
+    r"""Combination of Aggregation function and output metric type"""
+
+    passthrough: Optional[bool] = False
+    r"""Pass through the original events along with the aggregation events"""
+
+    preserve_group_bys: Annotated[
+        Optional[bool], pydantic.Field(alias="preserveGroupBys")
+    ] = False
+    r"""Preserve the structure of the original aggregation event's groupby fields"""
+
+    sufficient_stats_only: Annotated[
+        Optional[bool], pydantic.Field(alias="sufficientStatsOnly")
+    ] = False
+    r"""Output only statistics that are sufficient for the supplied aggregations"""
+
+    prefix: Optional[str] = None
+    r"""A prefix that is prepended to all of the fields output by this Aggregations Function"""
+
+    time_window: Annotated[Optional[str], pydantic.Field(alias="timeWindow")] = "10s"
+    r"""The time span of the tumbling window for aggregating events. Must be a valid time string (such as 10s)."""
+
+    groupbys: Optional[List[str]] = None
+    r"""Optional: One or more dimensions to group aggregates by. Supports wildcard expressions. Wrap dimension names in quotes if using literal identifiers, such as 'service.name'. Warning: Using wildcard '*' causes all dimensions in the event to be included, which can result in high cardinality and increased memory usage. Exclude dimensions that can result in high cardinality before using wildcards. Example: !_time, !_numericValue, *"""
+
+    flush_event_limit: Annotated[
+        Optional[float], pydantic.Field(alias="flushEventLimit")
+    ] = None
+    r"""The maximum number of events to include in any given aggregation event"""
+
+    flush_mem_limit: Annotated[Optional[str], pydantic.Field(alias="flushMemLimit")] = (
+        None
+    )
+    r"""The memory usage limit to impose upon aggregations. Defaults to 80% of the process memory; value configured above default limit is ignored. Accepts numerals with units like KB and MB (example: 128MB)."""
+
+    cumulative: Optional[bool] = False
+    r"""Enable to retain aggregations for cumulative aggregations when flushing out an aggregation table event. When disabled (the default), aggregations are reset to 0 on flush."""
+
+    should_treat_dots_as_literals: Annotated[
+        Optional[bool], pydantic.Field(alias="shouldTreatDotsAsLiterals")
+    ] = True
+    r"""Treat dots in dimension names as literals. This is useful for top-level dimensions that contain dots, such as 'service.name'."""
+
+    add: Optional[List[FunctionAggregateMetricsAdd]] = None
+    r"""Set of key-value pairs to evaluate and add/set"""
+
+    flush_on_input_close: Annotated[
+        Optional[bool], pydantic.Field(alias="flushOnInputClose")
+    ] = True
+    r"""Flush aggregations when an input stream is closed. If disabled, Time Window Settings control flush behavior."""
+
+
+class FunctionAggregateMetricsTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionAggregateMetricsID
+    load_time: float
+    mod_time: float
+    name: str
+    uischema: Dict[str, Any]
+    version: str
+    async_timeout: NotRequired[float]
+    cribl_version: NotRequired[str]
+    disabled: NotRequired[bool]
+    handle_signals: NotRequired[bool]
+    sync: NotRequired[bool]
+    schema_: NotRequired[FunctionAggregateMetricsSchemaTypedDict]
+
+
+class FunctionAggregateMetrics(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionAggregateMetricsID
+
+    load_time: Annotated[float, pydantic.Field(alias="loadTime")]
+
+    mod_time: Annotated[float, pydantic.Field(alias="modTime")]
+
+    name: str
+
+    uischema: Dict[str, Any]
+
+    version: str
+
+    async_timeout: Annotated[Optional[float], pydantic.Field(alias="asyncTimeout")] = (
+        None
+    )
+
+    cribl_version: Optional[str] = None
+
+    disabled: Optional[bool] = None
+
+    handle_signals: Annotated[Optional[bool], pydantic.Field(alias="handleSignals")] = (
+        None
+    )
+
+    sync: Optional[bool] = None
+
+    schema_: Annotated[
+        Optional[FunctionAggregateMetricsSchema], pydantic.Field(alias="schema")
+    ] = None

cribl_control_plane/models/functionaggregation.py

@@ -0,0 +1,172 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+from enum import Enum
+import pydantic
+from typing import Any, Dict, List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionAggregationID(str, Enum):
+    AGGREGATION = "aggregation"
+
+
+class FunctionAggregationAddTypedDict(TypedDict):
+    value: str
+    r"""JavaScript expression to compute the value (can be constant)"""
+    name: NotRequired[str]
+
+
+class FunctionAggregationAdd(BaseModel):
+    value: str
+    r"""JavaScript expression to compute the value (can be constant)"""
+
+    name: Optional[str] = None
+
+
+class FunctionAggregationSchemaTypedDict(TypedDict):
+    aggregations: List[str]
+    r"""Aggregate function to perform on events. Example: sum(bytes).where(action=='REJECT').as(TotalBytes)"""
+    passthrough: NotRequired[bool]
+    r"""Pass through the original events along with the aggregation events"""
+    preserve_group_bys: NotRequired[bool]
+    r"""Preserve the structure of the original aggregation event's groupby fields"""
+    sufficient_stats_only: NotRequired[bool]
+    r"""Output only statistics that are sufficient for the supplied aggregations"""
+    metrics_mode: NotRequired[bool]
+    r"""Enable to output the aggregates as metrics. When disabled, aggregates are output as events."""
+    prefix: NotRequired[str]
+    r"""A prefix that is prepended to all of the fields output by this Aggregations Function"""
+    time_window: NotRequired[str]
+    r"""The time span of the tumbling window for aggregating events. Must be a valid time string (such as 10s)."""
+    groupbys: NotRequired[List[str]]
+    r"""Optional: One or more fields to group aggregates by. Supports wildcard expressions. Warning: Using wildcard '*' causes all fields in the event to be included, which can result in high cardinality and increased memory usage. Exclude fields that can result in high cardinality before using wildcards. Example: !_time, !_numericValue, *"""
+    flush_event_limit: NotRequired[float]
+    r"""The maximum number of events to include in any given aggregation event"""
+    flush_mem_limit: NotRequired[str]
+    r"""The memory usage limit to impose upon aggregations. Defaults to 80% of the process memory; value configured above default limit is ignored. Accepts numerals with units like KB and MB (example: 128MB)."""
+    cumulative: NotRequired[bool]
+    r"""Enable to retain aggregations for cumulative aggregations when flushing out an aggregation table event. When disabled (the default), aggregations are reset to 0 on flush."""
+    search_agg_mode: NotRequired[str]
+    r"""Allows Cribl Search-specific aggregation configuration"""
+    add: NotRequired[List[FunctionAggregationAddTypedDict]]
+    r"""Set of key-value pairs to evaluate and add/set"""
+    should_treat_dots_as_literals: NotRequired[bool]
+    r"""Treat dots in dimension names as literals. This is useful for top-level dimensions that contain dots, such as 'service.name'."""
+    flush_on_input_close: NotRequired[bool]
+    r"""Flush aggregations when an input stream is closed. If disabled, Time Window Settings control flush behavior."""
+
+
+class FunctionAggregationSchema(BaseModel):
+    aggregations: List[str]
+    r"""Aggregate function to perform on events. Example: sum(bytes).where(action=='REJECT').as(TotalBytes)"""
+
+    passthrough: Optional[bool] = False
+    r"""Pass through the original events along with the aggregation events"""
+
+    preserve_group_bys: Annotated[
+        Optional[bool], pydantic.Field(alias="preserveGroupBys")
+    ] = False
+    r"""Preserve the structure of the original aggregation event's groupby fields"""
+
+    sufficient_stats_only: Annotated[
+        Optional[bool], pydantic.Field(alias="sufficientStatsOnly")
+    ] = False
+    r"""Output only statistics that are sufficient for the supplied aggregations"""
+
+    metrics_mode: Annotated[Optional[bool], pydantic.Field(alias="metricsMode")] = False
+    r"""Enable to output the aggregates as metrics. When disabled, aggregates are output as events."""
+
+    prefix: Optional[str] = None
+    r"""A prefix that is prepended to all of the fields output by this Aggregations Function"""
+
+    time_window: Annotated[Optional[str], pydantic.Field(alias="timeWindow")] = "10s"
+    r"""The time span of the tumbling window for aggregating events. Must be a valid time string (such as 10s)."""
+
+    groupbys: Optional[List[str]] = None
+    r"""Optional: One or more fields to group aggregates by. Supports wildcard expressions. Warning: Using wildcard '*' causes all fields in the event to be included, which can result in high cardinality and increased memory usage. Exclude fields that can result in high cardinality before using wildcards. Example: !_time, !_numericValue, *"""
+
+    flush_event_limit: Annotated[
+        Optional[float], pydantic.Field(alias="flushEventLimit")
+    ] = None
+    r"""The maximum number of events to include in any given aggregation event"""
+
+    flush_mem_limit: Annotated[Optional[str], pydantic.Field(alias="flushMemLimit")] = (
+        None
+    )
+    r"""The memory usage limit to impose upon aggregations. Defaults to 80% of the process memory; value configured above default limit is ignored. Accepts numerals with units like KB and MB (example: 128MB)."""
+
+    cumulative: Optional[bool] = False
+    r"""Enable to retain aggregations for cumulative aggregations when flushing out an aggregation table event. When disabled (the default), aggregations are reset to 0 on flush."""
+
+    search_agg_mode: Annotated[Optional[str], pydantic.Field(alias="searchAggMode")] = (
+        None
+    )
+    r"""Allows Cribl Search-specific aggregation configuration"""
+
+    add: Optional[List[FunctionAggregationAdd]] = None
+    r"""Set of key-value pairs to evaluate and add/set"""
+
+    should_treat_dots_as_literals: Annotated[
+        Optional[bool], pydantic.Field(alias="shouldTreatDotsAsLiterals")
+    ] = False
+    r"""Treat dots in dimension names as literals. This is useful for top-level dimensions that contain dots, such as 'service.name'."""
+
+    flush_on_input_close: Annotated[
+        Optional[bool], pydantic.Field(alias="flushOnInputClose")
+    ] = True
+    r"""Flush aggregations when an input stream is closed. If disabled, Time Window Settings control flush behavior."""
+
+
+class FunctionAggregationTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionAggregationID
+    load_time: float
+    mod_time: float
+    name: str
+    uischema: Dict[str, Any]
+    version: str
+    async_timeout: NotRequired[float]
+    cribl_version: NotRequired[str]
+    disabled: NotRequired[bool]
+    handle_signals: NotRequired[bool]
+    sync: NotRequired[bool]
+    schema_: NotRequired[FunctionAggregationSchemaTypedDict]
+
+
+class FunctionAggregation(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionAggregationID
+
+    load_time: Annotated[float, pydantic.Field(alias="loadTime")]
+
+    mod_time: Annotated[float, pydantic.Field(alias="modTime")]
+
+    name: str
+
+    uischema: Dict[str, Any]
+
+    version: str
+
+    async_timeout: Annotated[Optional[float], pydantic.Field(alias="asyncTimeout")] = (
+        None
+    )
+
+    cribl_version: Optional[str] = None
+
+    disabled: Optional[bool] = None
+
+    handle_signals: Annotated[Optional[bool], pydantic.Field(alias="handleSignals")] = (
+        None
+    )
+
+    sync: Optional[bool] = None
+
+    schema_: Annotated[
+        Optional[FunctionAggregationSchema], pydantic.Field(alias="schema")
+    ] = None