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

cribl_control_plane/models/functionlocalsearchdatatypeparser.py

@@ -0,0 +1,76 @@
+"""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, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionLocalSearchDatatypeParserID(str, Enum):
+    LOCAL_SEARCH_DATATYPE_PARSER = "local_search_datatype_parser"
+
+
+class FunctionLocalSearchDatatypeParserSchemaTypedDict(TypedDict):
+    ruleset_id: str
+    r"""ID of the local search datatype ruleset"""
+
+
+class FunctionLocalSearchDatatypeParserSchema(BaseModel):
+    ruleset_id: Annotated[str, pydantic.Field(alias="rulesetId")]
+    r"""ID of the local search datatype ruleset"""
+
+
+class FunctionLocalSearchDatatypeParserTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionLocalSearchDatatypeParserID
+    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[FunctionLocalSearchDatatypeParserSchemaTypedDict]
+
+
+class FunctionLocalSearchDatatypeParser(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionLocalSearchDatatypeParserID
+
+    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[FunctionLocalSearchDatatypeParserSchema],
+        pydantic.Field(alias="schema"),
+    ] = None

cribl_control_plane/models/functionlocalsearchrulesetrunner.py

@@ -0,0 +1,97 @@
+"""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, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionLocalSearchRulesetRunnerID(str, Enum):
+    LOCAL_SEARCH_RULESET_RUNNER = "local_search_ruleset_runner"
+
+
+class RulesetType(str, Enum, metaclass=utils.OpenEnumMeta):
+    DATASET = "dataset"
+    DATATYPE = "datatype"
+
+
+class FunctionLocalSearchRulesetRunnerSchemaTypedDict(TypedDict):
+    ruleset_type: NotRequired[RulesetType]
+    ruleset_id: NotRequired[str]
+
+
+class FunctionLocalSearchRulesetRunnerSchema(BaseModel):
+    ruleset_type: Annotated[
+        Annotated[Optional[RulesetType], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="rulesetType"),
+    ] = None
+
+    ruleset_id: Annotated[Optional[str], pydantic.Field(alias="rulesetId")] = None
+
+    @field_serializer("ruleset_type")
+    def serialize_ruleset_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.RulesetType(value)
+            except ValueError:
+                return value
+        return value
+
+
+class FunctionLocalSearchRulesetRunnerTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionLocalSearchRulesetRunnerID
+    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[FunctionLocalSearchRulesetRunnerSchemaTypedDict]
+
+
+class FunctionLocalSearchRulesetRunner(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionLocalSearchRulesetRunnerID
+
+    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[FunctionLocalSearchRulesetRunnerSchema], pydantic.Field(alias="schema")
+    ] = None

cribl_control_plane/models/functionlookup.py

@@ -0,0 +1,148 @@
+"""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 FunctionLookupID(str, Enum):
+    LOOKUP = "lookup"
+
+
+class InFieldTypedDict(TypedDict):
+    event_field: str
+    r"""Field name as it appears in events"""
+    lookup_field: NotRequired[str]
+    r"""Optional: The field name as it appears in the lookup file. Defaults to event field name"""
+
+
+class InField(BaseModel):
+    event_field: Annotated[str, pydantic.Field(alias="eventField")]
+    r"""Field name as it appears in events"""
+
+    lookup_field: Annotated[Optional[str], pydantic.Field(alias="lookupField")] = None
+    r"""Optional: The field name as it appears in the lookup file. Defaults to event field name"""
+
+
+class OutFieldTypedDict(TypedDict):
+    lookup_field: str
+    r"""The field name as it appears in the lookup file"""
+    event_field: NotRequired[str]
+    r"""Optional: Field name to add to event. Defaults to lookup field name."""
+    default_value: NotRequired[str]
+    r"""Optional: Value to assign if lookup entry is not found"""
+
+
+class OutField(BaseModel):
+    lookup_field: Annotated[str, pydantic.Field(alias="lookupField")]
+    r"""The field name as it appears in the lookup file"""
+
+    event_field: Annotated[Optional[str], pydantic.Field(alias="eventField")] = None
+    r"""Optional: Field name to add to event. Defaults to lookup field name."""
+
+    default_value: Annotated[Optional[str], pydantic.Field(alias="defaultValue")] = None
+    r"""Optional: Value to assign if lookup entry is not found"""
+
+
+class FunctionLookupSchemaTypedDict(TypedDict):
+    file: str
+    r"""Path to the lookup file. Reference environment variables via $. Example: $HOME/file.csv"""
+    db_lookup: NotRequired[bool]
+    r"""Enable to use a disk-based lookup. This option displays only the settings relevant to disk-based mode and hides those for in-memory lookups."""
+    match_mode: NotRequired[Any]
+    match_type: NotRequired[Any]
+    reload_period_sec: NotRequired[Any]
+    in_fields: NotRequired[List[InFieldTypedDict]]
+    r"""Fields that should be used to key into the lookup table"""
+    out_fields: NotRequired[List[OutFieldTypedDict]]
+    r"""Fields to add to events after matching lookup. Defaults to all if not specified."""
+    add_to_event: NotRequired[bool]
+    r"""Add the looked-up values to _raw, as key=value pairs"""
+    ignore_case: NotRequired[Any]
+
+
+class FunctionLookupSchema(BaseModel):
+    file: str
+    r"""Path to the lookup file. Reference environment variables via $. Example: $HOME/file.csv"""
+
+    db_lookup: Annotated[Optional[bool], pydantic.Field(alias="dbLookup")] = False
+    r"""Enable to use a disk-based lookup. This option displays only the settings relevant to disk-based mode and hides those for in-memory lookups."""
+
+    match_mode: Annotated[Optional[Any], pydantic.Field(alias="matchMode")] = None
+
+    match_type: Annotated[Optional[Any], pydantic.Field(alias="matchType")] = None
+
+    reload_period_sec: Annotated[
+        Optional[Any], pydantic.Field(alias="reloadPeriodSec")
+    ] = None
+
+    in_fields: Annotated[Optional[List[InField]], pydantic.Field(alias="inFields")] = (
+        None
+    )
+    r"""Fields that should be used to key into the lookup table"""
+
+    out_fields: Annotated[
+        Optional[List[OutField]], pydantic.Field(alias="outFields")
+    ] = None
+    r"""Fields to add to events after matching lookup. Defaults to all if not specified."""
+
+    add_to_event: Annotated[Optional[bool], pydantic.Field(alias="addToEvent")] = False
+    r"""Add the looked-up values to _raw, as key=value pairs"""
+
+    ignore_case: Annotated[Optional[Any], pydantic.Field(alias="ignoreCase")] = None
+
+
+class FunctionLookupTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionLookupID
+    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[FunctionLookupSchemaTypedDict]
+
+
+class FunctionLookup(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionLookupID
+
+    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[FunctionLookupSchema], pydantic.Field(alias="schema")
+    ] = None

cribl_control_plane/models/functionmask.py

@@ -0,0 +1,121 @@
+"""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 FunctionMaskID(str, Enum):
+    MASK = "mask"
+
+
+class FunctionMaskRuleTypedDict(TypedDict):
+    match_regex: str
+    r"""Pattern to replace. Use /g to replace all matches."""
+    replace_expr: NotRequired[str]
+    r"""A JavaScript expression or literal to replace the matching content. Capturing groups can be referenced as g1, g2, and so on, and event fields as event.<fieldName>."""
+    disabled: NotRequired[bool]
+    r"""Set to No to disable the evaluation of an individual rule"""
+
+
+class FunctionMaskRule(BaseModel):
+    match_regex: Annotated[str, pydantic.Field(alias="matchRegex")]
+    r"""Pattern to replace. Use /g to replace all matches."""
+
+    replace_expr: Annotated[Optional[str], pydantic.Field(alias="replaceExpr")] = "''"
+    r"""A JavaScript expression or literal to replace the matching content. Capturing groups can be referenced as g1, g2, and so on, and event fields as event.<fieldName>."""
+
+    disabled: Optional[bool] = False
+    r"""Set to No to disable the evaluation of an individual rule"""
+
+
+class FunctionMaskFlagTypedDict(TypedDict):
+    value: str
+    r"""JavaScript expression to compute the value (can be constant)"""
+    name: NotRequired[str]
+
+
+class FunctionMaskFlag(BaseModel):
+    value: str
+    r"""JavaScript expression to compute the value (can be constant)"""
+
+    name: Optional[str] = None
+
+
+class FunctionMaskSchemaTypedDict(TypedDict):
+    rules: List[FunctionMaskRuleTypedDict]
+    fields: NotRequired[List[str]]
+    r"""Fields on which to apply the masking rules. Supports * wildcards, except when used on internal fields."""
+    depth: NotRequired[int]
+    r"""Depth to which the Mask Function will search for fields to mask"""
+    flags: NotRequired[List[FunctionMaskFlagTypedDict]]
+    r"""Fields to evaluate if one or more masking rules are matched"""
+
+
+class FunctionMaskSchema(BaseModel):
+    rules: List[FunctionMaskRule]
+
+    fields: Optional[List[str]] = None
+    r"""Fields on which to apply the masking rules. Supports * wildcards, except when used on internal fields."""
+
+    depth: Optional[int] = 5
+    r"""Depth to which the Mask Function will search for fields to mask"""
+
+    flags: Optional[List[FunctionMaskFlag]] = None
+    r"""Fields to evaluate if one or more masking rules are matched"""
+
+
+class FunctionMaskTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionMaskID
+    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[FunctionMaskSchemaTypedDict]
+
+
+class FunctionMask(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionMaskID
+
+    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[FunctionMaskSchema], pydantic.Field(alias="schema")] = (
+        None
+    )

cribl_control_plane/models/functionmvexpand.py

@@ -0,0 +1,128 @@
+"""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 FunctionMvExpandID(str, Enum):
+    MV_EXPAND = "mv_expand"
+
+
+class BagExpansionMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""decides if bag-values are expanded to bags or arrays"""
+
+    # Store as object
+    BAG = "bag"
+    # Store as array
+    ARRAY = "array"
+
+
+class FunctionMvExpandSchemaTypedDict(TypedDict):
+    source_fields: List[str]
+    r"""Array of property-/field-names to expand"""
+    target_names: NotRequired[List[str]]
+    r"""stores the value as new target field name"""
+    row_limit: NotRequired[float]
+    r"""max. number of rows generated out of every source events"""
+    item_index_name: NotRequired[str]
+    r"""name of an optional index property generated into the output"""
+    bag_expansion_mode: NotRequired[BagExpansionMode]
+    r"""decides if bag-values are expanded to bags or arrays"""
+
+
+class FunctionMvExpandSchema(BaseModel):
+    source_fields: Annotated[List[str], pydantic.Field(alias="sourceFields")]
+    r"""Array of property-/field-names to expand"""
+
+    target_names: Annotated[
+        Optional[List[str]], pydantic.Field(alias="targetNames")
+    ] = None
+    r"""stores the value as new target field name"""
+
+    row_limit: Annotated[Optional[float], pydantic.Field(alias="rowLimit")] = (
+        9007199254740991
+    )
+    r"""max. number of rows generated out of every source events"""
+
+    item_index_name: Annotated[Optional[str], pydantic.Field(alias="itemIndexName")] = (
+        None
+    )
+    r"""name of an optional index property generated into the output"""
+
+    bag_expansion_mode: Annotated[
+        Annotated[
+            Optional[BagExpansionMode], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="bagExpansionMode"),
+    ] = BagExpansionMode.BAG
+    r"""decides if bag-values are expanded to bags or arrays"""
+
+    @field_serializer("bag_expansion_mode")
+    def serialize_bag_expansion_mode(self, value):
+        if isinstance(value, str):
+            try:
+                return models.BagExpansionMode(value)
+            except ValueError:
+                return value
+        return value
+
+
+class FunctionMvExpandTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionMvExpandID
+    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[FunctionMvExpandSchemaTypedDict]
+
+
+class FunctionMvExpand(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionMvExpandID
+
+    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[FunctionMvExpandSchema], pydantic.Field(alias="schema")
+    ] = None

cribl_control_plane/models/functionmvpull.py

@@ -0,0 +1,99 @@
+"""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, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FunctionMvPullID(str, Enum):
+    MV_PULL = "mv_pull"
+
+
+class FunctionMvPullSchemaTypedDict(TypedDict):
+    array_path: str
+    r"""Field name of the array within events that contains the data objects of interest. Can be a path."""
+    relative_key_path: str
+    r"""Extract the K-V pair's key from this field, relative to the data object."""
+    relative_value_path: str
+    r"""Extract the K-V pair's value from this field, relative to the data object."""
+    target_bag_path: NotRequired[str]
+    r"""Optionally, specify a bag as the target for K-V entries. If not specified, these entries are stored on each top-level event."""
+    delete_original: NotRequired[bool]
+    r"""Toggle this on to remove each original array of data objects after extraction. If toggled off, arrays are retained."""
+
+
+class FunctionMvPullSchema(BaseModel):
+    array_path: Annotated[str, pydantic.Field(alias="arrayPath")]
+    r"""Field name of the array within events that contains the data objects of interest. Can be a path."""
+
+    relative_key_path: Annotated[str, pydantic.Field(alias="relativeKeyPath")]
+    r"""Extract the K-V pair's key from this field, relative to the data object."""
+
+    relative_value_path: Annotated[str, pydantic.Field(alias="relativeValuePath")]
+    r"""Extract the K-V pair's value from this field, relative to the data object."""
+
+    target_bag_path: Annotated[Optional[str], pydantic.Field(alias="targetBagPath")] = (
+        None
+    )
+    r"""Optionally, specify a bag as the target for K-V entries. If not specified, these entries are stored on each top-level event."""
+
+    delete_original: Annotated[
+        Optional[bool], pydantic.Field(alias="deleteOriginal")
+    ] = False
+    r"""Toggle this on to remove each original array of data objects after extraction. If toggled off, arrays are retained."""
+
+
+class FunctionMvPullTypedDict(TypedDict):
+    filename: str
+    group: str
+    id: FunctionMvPullID
+    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[FunctionMvPullSchemaTypedDict]
+
+
+class FunctionMvPull(BaseModel):
+    filename: Annotated[str, pydantic.Field(alias="__filename")]
+
+    group: str
+
+    id: FunctionMvPullID
+
+    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[FunctionMvPullSchema], pydantic.Field(alias="schema")
+    ] = None