cribl-control-plane 0.4.0b23__py3-none-any.whl → 0.5.0b3__py3-none-any.whl

cribl_control_plane/models/functionconfschemaserialize.py

@@ -0,0 +1,78 @@
+"""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, List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionConfSchemaSerializeType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""Data output format"""
+
+    # CSV
+    CSV = "csv"
+    # Extended Log File Format
+    ELFF = "elff"
+    # Common Log Format
+    CLF = "clf"
+    # Key=Value Pairs
+    KVP = "kvp"
+    # JSON Object
+    JSON = "json"
+    # Delimited values
+    DELIM = "delim"
+
+
+class FunctionConfSchemaSerializeTypedDict(TypedDict):
+    type: NotRequired[FunctionConfSchemaSerializeType]
+    r"""Data output format"""
+    delim_char: NotRequired[Any]
+    quote_char: NotRequired[Any]
+    escape_char: NotRequired[Any]
+    null_value: NotRequired[Any]
+    fields: NotRequired[List[str]]
+    r"""Required for CSV, ELFF, CLF, and Delimited values. All other formats support wildcard field lists. Examples: host, array*, !host *"""
+    src_field: NotRequired[str]
+    r"""Field containing object to serialize. Leave blank to serialize top-level event fields."""
+    dst_field: NotRequired[str]
+    r"""Field to serialize data to"""
+
+
+class FunctionConfSchemaSerialize(BaseModel):
+    type: Annotated[
+        Optional[FunctionConfSchemaSerializeType],
+        PlainValidator(validate_open_enum(False)),
+    ] = FunctionConfSchemaSerializeType.CSV
+    r"""Data output format"""
+
+    delim_char: Annotated[Optional[Any], pydantic.Field(alias="delimChar")] = None
+
+    quote_char: Annotated[Optional[Any], pydantic.Field(alias="quoteChar")] = None
+
+    escape_char: Annotated[Optional[Any], pydantic.Field(alias="escapeChar")] = None
+
+    null_value: Annotated[Optional[Any], pydantic.Field(alias="nullValue")] = None
+
+    fields: Optional[List[str]] = None
+    r"""Required for CSV, ELFF, CLF, and Delimited values. All other formats support wildcard field lists. Examples: host, array*, !host *"""
+
+    src_field: Annotated[Optional[str], pydantic.Field(alias="srcField")] = None
+    r"""Field containing object to serialize. Leave blank to serialize top-level event fields."""
+
+    dst_field: Annotated[Optional[str], pydantic.Field(alias="dstField")] = "_raw"
+    r"""Field to serialize data to"""
+
+    @field_serializer("type")
+    def serialize_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.FunctionConfSchemaSerializeType(value)
+            except ValueError:
+                return value
+        return value

cribl_control_plane/models/functionconfschemasidlookup.py

@@ -0,0 +1,34 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class FunctionConfSchemaSidlookupFieldTypedDict(TypedDict):
+    expr: str
+    r"""JavaScript expression to compute the value (can be constant)"""
+    name: NotRequired[str]
+    disabled: NotRequired[bool]
+    r"""Set to No to disable the evaluation of an individual expression"""
+
+
+class FunctionConfSchemaSidlookupField(BaseModel):
+    expr: str
+    r"""JavaScript expression to compute the value (can be constant)"""
+
+    name: Optional[str] = None
+
+    disabled: Optional[bool] = False
+    r"""Set to No to disable the evaluation of an individual expression"""
+
+
+class FunctionConfSchemaSidlookupTypedDict(TypedDict):
+    fields: NotRequired[List[FunctionConfSchemaSidlookupFieldTypedDict]]
+    r"""Set of expressions matched to lookup responses"""
+
+
+class FunctionConfSchemaSidlookup(BaseModel):
+    fields: Optional[List[FunctionConfSchemaSidlookupField]] = None
+    r"""Set of expressions matched to lookup responses"""

cribl_control_plane/models/functionconfschemasnmptrapserialize.py

@@ -0,0 +1,92 @@
+"""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, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionConfSchemaSnmpTrapSerializeAuthenticationProtocol(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    # None
+    NONE = "none"
+    # MD5
+    MD5 = "md5"
+    # SHA1
+    SHA = "sha"
+    # SHA224
+    SHA224 = "sha224"
+    # SHA256
+    SHA256 = "sha256"
+    # SHA384
+    SHA384 = "sha384"
+    # SHA512
+    SHA512 = "sha512"
+
+
+class FunctionConfSchemaSnmpTrapSerializeV3UserTypedDict(TypedDict):
+    name: NotRequired[str]
+    auth_protocol: NotRequired[
+        FunctionConfSchemaSnmpTrapSerializeAuthenticationProtocol
+    ]
+    auth_key: NotRequired[Any]
+    priv_protocol: NotRequired[str]
+
+
+class FunctionConfSchemaSnmpTrapSerializeV3User(BaseModel):
+    name: Optional[str] = None
+
+    auth_protocol: Annotated[
+        Annotated[
+            Optional[FunctionConfSchemaSnmpTrapSerializeAuthenticationProtocol],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authProtocol"),
+    ] = FunctionConfSchemaSnmpTrapSerializeAuthenticationProtocol.NONE
+
+    auth_key: Annotated[Optional[Any], pydantic.Field(alias="authKey")] = None
+
+    priv_protocol: Annotated[Optional[str], pydantic.Field(alias="privProtocol")] = (
+        "none"
+    )
+
+    @field_serializer("auth_protocol")
+    def serialize_auth_protocol(self, value):
+        if isinstance(value, str):
+            try:
+                return models.FunctionConfSchemaSnmpTrapSerializeAuthenticationProtocol(
+                    value
+                )
+            except ValueError:
+                return value
+        return value
+
+
+class FunctionConfSchemaSnmpTrapSerializeTypedDict(TypedDict):
+    strict: NotRequired[bool]
+    r"""Prevent event serialization if any required fields are missing. When disabled, @{product} will attempt to serialize the event even if required fields are missing, which could cause unexpected behavior at the downstream receiver."""
+    drop_failed_events: NotRequired[bool]
+    r"""When disabled, `snmpSerializeErrors` will be set on the event, and the `__snmpRaw` field will be removed to prevent @{product} from sending the event from the SNMP Trap Destination"""
+    v3_user: NotRequired[FunctionConfSchemaSnmpTrapSerializeV3UserTypedDict]
+
+
+class FunctionConfSchemaSnmpTrapSerialize(BaseModel):
+    strict: Optional[bool] = True
+    r"""Prevent event serialization if any required fields are missing. When disabled, @{product} will attempt to serialize the event even if required fields are missing, which could cause unexpected behavior at the downstream receiver."""
+
+    drop_failed_events: Annotated[
+        Optional[bool], pydantic.Field(alias="dropFailedEvents")
+    ] = True
+    r"""When disabled, `snmpSerializeErrors` will be set on the event, and the `__snmpRaw` field will be removed to prevent @{product} from sending the event from the SNMP Trap Destination"""
+
+    v3_user: Annotated[
+        Optional[FunctionConfSchemaSnmpTrapSerializeV3User],
+        pydantic.Field(alias="v3User"),
+    ] = None

cribl_control_plane/models/functionconfschemasort.py

@@ -0,0 +1,41 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionConfSchemaSortTypedDict(TypedDict):
+    sort_id: NotRequired[str]
+    r"""Has to be unique if there are multiple sorts on the pipeline."""
+    comparison_expression: NotRequired[str]
+    r"""The expression can access the events via the 'left' and 'right' properties."""
+    top_n: NotRequired[float]
+    r"""Limits the output to N (highest/lowest) events"""
+    max_events: NotRequired[float]
+    r"""Specifies the number of events that can flow into this function"""
+    suppress_previews: NotRequired[bool]
+    r"""Toggle this on to suppress generating previews of intermediate results"""
+
+
+class FunctionConfSchemaSort(BaseModel):
+    sort_id: Annotated[Optional[str], pydantic.Field(alias="sortId")] = None
+    r"""Has to be unique if there are multiple sorts on the pipeline."""
+
+    comparison_expression: Annotated[
+        Optional[str], pydantic.Field(alias="comparisonExpression")
+    ] = None
+    r"""The expression can access the events via the 'left' and 'right' properties."""
+
+    top_n: Annotated[Optional[float], pydantic.Field(alias="topN")] = None
+    r"""Limits the output to N (highest/lowest) events"""
+
+    max_events: Annotated[Optional[float], pydantic.Field(alias="maxEvents")] = None
+    r"""Specifies the number of events that can flow into this function"""
+
+    suppress_previews: Annotated[
+        Optional[bool], pydantic.Field(alias="suppressPreviews")
+    ] = None
+    r"""Toggle this on to suppress generating previews of intermediate results"""

cribl_control_plane/models/functionconfschemastore.py

@@ -0,0 +1,75 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionConfSchemaStoreMappingOfFieldNamesTypedDict(TypedDict):
+    r"""Mapping event property names to output field names"""
+
+
+class FunctionConfSchemaStoreMappingOfFieldNames(BaseModel):
+    r"""Mapping event property names to output field names"""
+
+
+class FunctionConfSchemaStoreTypedDict(TypedDict):
+    type: NotRequired[str]
+    r"""The type of knowledge object, generated by the function (i.e., 'lookup')"""
+    destination: NotRequired[str]
+    r"""Configures where and how the data should be stored"""
+    description: NotRequired[str]
+    r"""The knowledge object's description"""
+    field_mapping: NotRequired[FunctionConfSchemaStoreMappingOfFieldNamesTypedDict]
+    r"""Mapping event property names to output field names"""
+    separator: NotRequired[str]
+    r"""Character to be used as value delimiter in output"""
+    overwrite: NotRequired[bool]
+    r"""For existing files, an error is thrown if overwrite is false or the file is replaced if overwrite is true"""
+    compress: NotRequired[str]
+    r"""True will compress output, false leaves it as it is and auto decides based on size"""
+    tee: NotRequired[bool]
+    r"""Tee results to the next operator"""
+    max_events: NotRequired[float]
+    r"""Limits how many events can be stored"""
+    suppress_previews: NotRequired[bool]
+    r"""Suppresses the timer-based export stats generating"""
+
+
+class FunctionConfSchemaStore(BaseModel):
+    type: Optional[str] = "lookup"
+    r"""The type of knowledge object, generated by the function (i.e., 'lookup')"""
+
+    destination: Optional[str] = None
+    r"""Configures where and how the data should be stored"""
+
+    description: Optional[str] = None
+    r"""The knowledge object's description"""
+
+    field_mapping: Annotated[
+        Optional[FunctionConfSchemaStoreMappingOfFieldNames],
+        pydantic.Field(alias="fieldMapping"),
+    ] = None
+    r"""Mapping event property names to output field names"""
+
+    separator: Optional[str] = ","
+    r"""Character to be used as value delimiter in output"""
+
+    overwrite: Optional[bool] = False
+    r"""For existing files, an error is thrown if overwrite is false or the file is replaced if overwrite is true"""
+
+    compress: Optional[str] = "auto"
+    r"""True will compress output, false leaves it as it is and auto decides based on size"""
+
+    tee: Optional[bool] = False
+    r"""Tee results to the next operator"""
+
+    max_events: Annotated[Optional[float], pydantic.Field(alias="maxEvents")] = 10000
+    r"""Limits how many events can be stored"""
+
+    suppress_previews: Annotated[
+        Optional[bool], pydantic.Field(alias="suppressPreviews")
+    ] = False
+    r"""Suppresses the timer-based export stats generating"""

cribl_control_plane/models/functionconfschemasuppress.py

@@ -0,0 +1,57 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionConfSchemaSuppressTypedDict(TypedDict):
+    key_expr: NotRequired[str]
+    r"""Suppression key expression used to uniquely identify events to suppress. For example, `${ip}:${port}` will use fields ip and port from each event to generate the key."""
+    allow: NotRequired[float]
+    r"""The number of events to allow per time period"""
+    suppress_period_sec: NotRequired[float]
+    r"""The number of seconds to suppress events after 'Number to allow' events are received"""
+    drop_events_mode: NotRequired[bool]
+    r"""If disabled, suppressed events will be tagged with suppress=1 but not dropped"""
+    max_cache_size: NotRequired[float]
+    r"""The maximum number of keys that can be cached before idle entries are removed. Leave at default unless you understand the implications of changing."""
+    cache_idle_timeout_periods: NotRequired[float]
+    r"""The number of suppression periods 'Suppression Period' of inactivity before a cache entry is considered idle. Leave at default unless you understand the implications of changing."""
+    num_events_idle_timeout_trigger: NotRequired[float]
+    r"""Check cache for idle sessions every N events when cache size is > 'Maximum Cache Size'. Leave at default unless you understand the implications of changing."""
+
+
+class FunctionConfSchemaSuppress(BaseModel):
+    key_expr: Annotated[Optional[str], pydantic.Field(alias="keyExpr")] = None
+    r"""Suppression key expression used to uniquely identify events to suppress. For example, `${ip}:${port}` will use fields ip and port from each event to generate the key."""
+
+    allow: Optional[float] = 1
+    r"""The number of events to allow per time period"""
+
+    suppress_period_sec: Annotated[
+        Optional[float], pydantic.Field(alias="suppressPeriodSec")
+    ] = 30
+    r"""The number of seconds to suppress events after 'Number to allow' events are received"""
+
+    drop_events_mode: Annotated[
+        Optional[bool], pydantic.Field(alias="dropEventsMode")
+    ] = True
+    r"""If disabled, suppressed events will be tagged with suppress=1 but not dropped"""
+
+    max_cache_size: Annotated[Optional[float], pydantic.Field(alias="maxCacheSize")] = (
+        50000
+    )
+    r"""The maximum number of keys that can be cached before idle entries are removed. Leave at default unless you understand the implications of changing."""
+
+    cache_idle_timeout_periods: Annotated[
+        Optional[float], pydantic.Field(alias="cacheIdleTimeoutPeriods")
+    ] = 2
+    r"""The number of suppression periods 'Suppression Period' of inactivity before a cache entry is considered idle. Leave at default unless you understand the implications of changing."""
+
+    num_events_idle_timeout_trigger: Annotated[
+        Optional[float], pydantic.Field(alias="numEventsIdleTimeoutTrigger")
+    ] = 10000
+    r"""Check cache for idle sessions every N events when cache size is > 'Maximum Cache Size'. Leave at default unless you understand the implications of changing."""

cribl_control_plane/models/functionconfschematee.py

@@ -0,0 +1,32 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+import pydantic
+from typing import Dict, List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionConfSchemaTeeTypedDict(TypedDict):
+    command: NotRequired[str]
+    r"""Command to execute and feed events to, via stdin. One JSON-formatted event per line."""
+    args: NotRequired[List[str]]
+    restart_on_exit: NotRequired[bool]
+    r"""Restart the process if it exits and/or we fail to write to it"""
+    env: NotRequired[Dict[str, str]]
+    r"""Environment variables to overwrite or set"""
+
+
+class FunctionConfSchemaTee(BaseModel):
+    command: Optional[str] = None
+    r"""Command to execute and feed events to, via stdin. One JSON-formatted event per line."""
+
+    args: Optional[List[str]] = None
+
+    restart_on_exit: Annotated[
+        Optional[bool], pydantic.Field(alias="restartOnExit")
+    ] = True
+    r"""Restart the process if it exits and/or we fail to write to it"""
+
+    env: Optional[Dict[str, str]] = None
+    r"""Environment variables to overwrite or set"""

cribl_control_plane/models/functionconfschematrimtimestamp.py

@@ -0,0 +1,16 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class FunctionConfSchemaTrimTimestampTypedDict(TypedDict):
+    field: NotRequired[str]
+    r"""Name of field in which to save the timestamp. (If empty, timestamp will not be saved to a field.)"""
+
+
+class FunctionConfSchemaTrimTimestamp(BaseModel):
+    field: Optional[str] = None
+    r"""Name of field in which to save the timestamp. (If empty, timestamp will not be saved to a field.)"""

cribl_control_plane/models/functionconfschemaunion.py

@@ -0,0 +1,22 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+import pydantic
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionConfSchemaUnionTypedDict(TypedDict):
+    search_job_id: NotRequired[str]
+    r"""The id for this search job."""
+    stage_ids: NotRequired[List[str]]
+    r"""The stages we are unioning with."""
+
+
+class FunctionConfSchemaUnion(BaseModel):
+    search_job_id: Annotated[Optional[str], pydantic.Field(alias="searchJobId")] = None
+    r"""The id for this search job."""
+
+    stage_ids: Annotated[Optional[List[str]], pydantic.Field(alias="stageIds")] = None
+    r"""The stages we are unioning with."""

cribl_control_plane/models/functionconfschemaunroll.py

@@ -0,0 +1,22 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionConfSchemaUnrollTypedDict(TypedDict):
+    src_expr: NotRequired[str]
+    r"""Field in which to find/calculate the array to unroll. Example: _raw, _raw.split(/\n/)"""
+    dst_field: NotRequired[str]
+    r"""Field in destination event in which to place the unrolled value"""
+
+
+class FunctionConfSchemaUnroll(BaseModel):
+    src_expr: Annotated[Optional[str], pydantic.Field(alias="srcExpr")] = "_raw"
+    r"""Field in which to find/calculate the array to unroll. Example: _raw, _raw.split(/\n/)"""
+
+    dst_field: Annotated[Optional[str], pydantic.Field(alias="dstField")] = "_raw"
+    r"""Field in destination event in which to place the unrolled value"""

cribl_control_plane/models/functionconfschemawindow.py

@@ -0,0 +1,40 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+import pydantic
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionConfSchemaWindowTypedDict(TypedDict):
+    event_window_id: NotRequired[float]
+    r"""Identifies the unique ID, used for a event window"""
+    registered_functions: NotRequired[List[str]]
+    r"""All window functions, tracked by this event window"""
+    tail_event_count: NotRequired[float]
+    r"""Number of events to keep before the current event in the window"""
+    head_event_count: NotRequired[float]
+    r"""Number of events to keep after the current event in the window"""
+
+
+class FunctionConfSchemaWindow(BaseModel):
+    event_window_id: Annotated[
+        Optional[float], pydantic.Field(alias="eventWindowId")
+    ] = None
+    r"""Identifies the unique ID, used for a event window"""
+
+    registered_functions: Annotated[
+        Optional[List[str]], pydantic.Field(alias="registeredFunctions")
+    ] = None
+    r"""All window functions, tracked by this event window"""
+
+    tail_event_count: Annotated[
+        Optional[float], pydantic.Field(alias="tailEventCount")
+    ] = 0
+    r"""Number of events to keep before the current event in the window"""
+
+    head_event_count: Annotated[
+        Optional[float], pydantic.Field(alias="headEventCount")
+    ] = 0
+    r"""Number of events to keep after the current event in the window"""

cribl_control_plane/models/functionconfschemaxmlunroll.py

@@ -0,0 +1,34 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from cribl_control_plane.types import BaseModel
+import pydantic
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionConfSchemaXMLUnrollTypedDict(TypedDict):
+    unroll: NotRequired[str]
+    r"""Path to array to unroll. Example: ^root\.child\.ElementToUnroll$"""
+    inherit: NotRequired[str]
+    r"""Regex matching elements to copy into each unrolled event. Example: ^root\.(childA|childB|childC)$"""
+    unroll_idx_field: NotRequired[str]
+    r"""Add a field with this name, containing the index at which the item was located, starting from 0"""
+    pretty: NotRequired[bool]
+    r"""Pretty print the output XML"""
+
+
+class FunctionConfSchemaXMLUnroll(BaseModel):
+    unroll: Optional[str] = None
+    r"""Path to array to unroll. Example: ^root\.child\.ElementToUnroll$"""
+
+    inherit: Optional[str] = None
+    r"""Regex matching elements to copy into each unrolled event. Example: ^root\.(childA|childB|childC)$"""
+
+    unroll_idx_field: Annotated[
+        Optional[str], pydantic.Field(alias="unrollIdxField")
+    ] = "unroll_idx"
+    r"""Add a field with this name, containing the index at which the item was located, starting from 0"""
+
+    pretty: Optional[bool] = False
+    r"""Pretty print the output XML"""

cribl_control_plane/models/functiondistinct.py

@@ -1,10 +1,14 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .functionconfschemadistinct import (
+    FunctionConfSchemaDistinct,
+    FunctionConfSchemaDistinctTypedDict,
+)
 from cribl_control_plane.types import BaseModel
 from enum import Enum
 import pydantic
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -12,40 +16,6 @@ class FunctionDistinctID(str, Enum):
     DISTINCT = "distinct"
 
 
-class DistinctConfigurationTypedDict(TypedDict):
-    group_by: List[str]
-    r"""Defines the properties that are concatenated to produce distinct key"""
-    max_combinations: NotRequired[float]
-    r"""maximum number of tracked combinations"""
-    max_depth: NotRequired[float]
-    r"""maximum number of groupBy properties"""
-    is_federated: NotRequired[bool]
-    r"""indicator that the operator runs on a federated executor"""
-    suppress_previews: NotRequired[bool]
-    r"""Toggle this on to suppress generating previews of intermediate results"""
-
-
-class DistinctConfiguration(BaseModel):
-    group_by: Annotated[List[str], pydantic.Field(alias="groupBy")]
-    r"""Defines the properties that are concatenated to produce distinct key"""
-
-    max_combinations: Annotated[
-        Optional[float], pydantic.Field(alias="maxCombinations")
-    ] = 10000
-    r"""maximum number of tracked combinations"""
-
-    max_depth: Annotated[Optional[float], pydantic.Field(alias="maxDepth")] = 15
-    r"""maximum number of groupBy properties"""
-
-    is_federated: Annotated[Optional[bool], pydantic.Field(alias="isFederated")] = False
-    r"""indicator that the operator runs on a federated executor"""
-
-    suppress_previews: Annotated[
-        Optional[bool], pydantic.Field(alias="suppressPreviews")
-    ] = None
-    r"""Toggle this on to suppress generating previews of intermediate results"""
-
-
 class FunctionDistinctTypedDict(TypedDict):
     filename: str
     group: str
@@ -60,7 +30,7 @@ class FunctionDistinctTypedDict(TypedDict):
     disabled: NotRequired[bool]
     handle_signals: NotRequired[bool]
     sync: NotRequired[bool]
-    schema_: NotRequired[DistinctConfigurationTypedDict]
+    schema_: NotRequired[FunctionConfSchemaDistinctTypedDict]
 
 
 class FunctionDistinct(BaseModel):
@@ -95,5 +65,5 @@ class FunctionDistinct(BaseModel):
     sync: Optional[bool] = None
 
     schema_: Annotated[
-        Optional[DistinctConfiguration], pydantic.Field(alias="schema")
+        Optional[FunctionConfSchemaDistinct], pydantic.Field(alias="schema")
     ] = None